--------------------------------------------------------------------------------
{-# LANGUAGE OverloadedStrings #-}

import Hakyll

import Hakyll.Contrib.I18n
    ( Language
    , categoryField'
    , feedConfiguration
    , tagsField'
    , translate
    , translationCompiler
    , translationContext
    )

import Data.List (intersperse)
import System.FilePath ((</>), splitExtension, splitFileName, takeDirectory)
import Text.Pandoc (Format (..), Pandoc)
import Text.Pandoc.Filter.IncludeCode (includeCode)
import Text.Pandoc.Walk (walkM)

import qualified Data.HashMap.Strict as SM (union)
import qualified GHC.IO.Encoding as E

includeCodePandocCompiler :: Compiler (Item String)
includeCodePandocCompiler =
  pandocCompilerWithTransformM
    defaultHakyllReaderOptions
    defaultHakyllWriterOptions
    (unsafeCompiler . (walkM (includeCode (Just (Format "html5")))))

main :: IO ()
main = do
    E.setLocaleEncoding E.utf8
    hakyll $ do
        match "assets/**/*" $ do
            route idRoute
            compile copyFileCompiler

        match "css/*" $ do
            route idRoute
            compile compressCssCompiler

        match "*/translation.yml" $
            compile translationCompiler

        match ("snippets/*" .||. "*/snippets/*") $
            compile getResourceBody

        match ("templates/*" .&&. complement "templates/translation.yml") $
            compile templateBodyCompiler

        create ["index.html"] $ do
            route idRoute
            compile $ do
                defaultTranslation <- loadBody "templates/translation.yml"
                makeItem $ Redirect $ translate defaultTranslation "DEFAULT_LANGUAGE"

        create ["sitemap.xml"] $ do
            route idRoute
            compile $ do
                archives               <- loadAll $ hasVersion "archive"
                archivesAllLanguages   <- loadAll $ hasVersion "archiveAllLanguages"
                categories             <- loadAll $ ("*/categories/*" .&&. hasNoVersion)
                categoriesAllLanguages <- loadAll $ ("*/categories/*" .&&. hasVersion "categoryAllLanguages")
                index                  <- loadAll $ hasVersion "index"
                pages                  <- loadAll $ hasVersion "page"
                posts                  <- loadAll "*/posts/*/*"
                tags                   <- loadAll $ ("*/tags/*" .&&. hasNoVersion)
                tagsAllLanguages       <- loadAll $ ("*/tags/*" .&&. hasVersion "tagAllLanguages")

                let context =
                        listField "archives"               generalContext (return archives)               <>
                        listField "archivesAllLanguages"   generalContext (return archivesAllLanguages)   <>
                        listField "categories"             generalContext (return categories)             <>
                        listField "categoriesAllLanguages" generalContext (return categoriesAllLanguages) <>
                        listField "index"                  generalContext (return index)                  <>
                        listField "pages"                  generalContext (return pages)                  <>
                        listField "posts"                  generalContext (return posts)                  <>
                        listField "tags"                   generalContext (return tags)                   <>
                        listField "tagsAllLanguages"       generalContext (return tagsAllLanguages)

                makeItem ""
                    >>= loadAndApplyTemplate "templates/sitemap.xml" context
                    >>= relativizeUrls

        sequence_ $ [archives, categories, feeds, index, pages, posts, tags] <*> ["en", "fr"]

archives :: Language -> Rules ()
archives language = sequence_ $ [archives', archives''] <*> pure language where
    archives' :: Language -> Rules ()
    archives' language = do
        categories <- buildCategories (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "categories/*.html")
        tags       <- buildTags       (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "tags/*.html")

        create [fromFilePath $ language </> "archive.html"] $ version "archive" $ do
            route indexRoute
            compile $ do
                posts <- recentFirst =<< (loadAll $ fromGlob $ language </> "posts/*/*")

                let context =
                        boolField "single" (const True)                                <>
                        constField "switch" ("/archive" </> language)                  <>
                        listField "posts" (postContext tags categories) (return posts) <>
                        generalContext

                makeItem ""
                    >>= loadAndApplyTemplate "templates/archive.html" context
                    >>= loadAndApplyTemplate "templates/default.html" context
                    >>= relativizeUrls

    archives'' :: Language -> Rules ()
    archives'' language = do
        categories <- buildCategories "*/posts/*/*" (fromCapture $ fromGlob $ language </> "categories/*.html")
        tags       <- buildTags       "*/posts/*/*" (fromCapture $ fromGlob $ language </> "tags/*.html")

        create [fromFilePath $ language </> "archive.html"] $ version "archiveAllLanguages" $ do
            route $ gsubRoute (language </> "archive") (const $ "archive" </> language) `composeRoutes` indexRoute
            compile $ do
                posts <- recentFirst =<< loadAll ("*/posts/*/*")

                let context =
                        boolField "single" (const False)                               <>
                        constField "switch" ("/" ++ language </> "archive")            <>
                        listField "posts" (postContext tags categories) (return posts) <>
                        generalContext

                makeItem ""
                    >>= loadAndApplyTemplate "templates/archive.html" context
                    >>= loadAndApplyTemplate "templates/default.html" context
                    >>= relativizeUrls

categories :: Language -> Rules ()
categories language = sequence_ $ [categories', categories''] <*> pure language where
    categories' :: Language -> Rules ()
    categories' language = do
        categories <- buildCategories (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "categories/*.html")
        tags       <- buildTags       (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "tags/*.html")

        tagsRules categories $ \category pattern -> do
            route indexRoute
            compile $ do
                posts <- recentFirst =<< loadAll pattern

                let context =
                        boolField "single" (const True)                                <>
                        constField "switch" ("/categories" </> language </> category)  <>
                        listField "posts" (postContext tags categories) (return posts) <>
                        generalContext

                makeItem ""
                    >>= loadAndApplyTemplate "templates/category.html" context
                    >>= loadAndApplyTemplate "templates/default.html"  context
                    >>= relativizeUrls

    categories'' :: Language -> Rules ()
    categories'' language = do
        categories <- buildCategories "*/posts/*/*" (fromCapture $ fromGlob $ language </> "categories/*.html")
        tags       <- buildTags "*/posts/*/*"       (fromCapture $ fromGlob $ language </> "tags/*.html")

        version "categoryAllLanguages" $ tagsRules categories $ \category pattern -> do
            route $ gsubRoute (language </> "categories") (const $ "categories" </> language) `composeRoutes` indexRoute
            compile $ do
                posts <- recentFirst =<< loadAll pattern

                let context =
                        boolField "single" (const False)                                    <>
                        constField "switch" ("/" ++ language </> "categories" </> category) <>
                        listField "posts" (postContext tags categories) (return posts)      <>
                        generalContext

                makeItem ""
                    >>= loadAndApplyTemplate "templates/category.html" context
                    >>= loadAndApplyTemplate "templates/default.html"  context
                    >>= relativizeUrls

feeds :: Language -> Rules ()
feeds language = sequence_ $ [atom, rss] <*> pure language where
    atom :: Language -> Rules ()
    atom language = create [fromFilePath $ language </> "atom.xml"] $ do
        route idRoute
        compile $ do
            posts <- fmap (take 10) . recentFirst =<< (loadAll $ fromGlob $ language </> "posts/*/*")

            languageTranslation <- loadBody $ fromFilePath $ language </> "translation.yml"
            defaultTranslation  <- loadBody "templates/translation.yml"

            let translation = SM.union languageTranslation defaultTranslation
                context = listField "posts" generalContext (return posts) <> generalContext

            renderAtom (feedConfiguration translation) generalContext posts

    rss :: Language -> Rules ()
    rss language = create [fromFilePath $ language </> "rss.xml"] $ do
        route idRoute
        compile $ do
            posts <- fmap (take 10) . recentFirst =<< (loadAll $ fromGlob $ language </> "posts/*/*")

            languageTranslation <- loadBody $ fromFilePath $ language </> "translation.yml"
            defaultTranslation  <- loadBody "templates/translation.yml"

            let translation = SM.union languageTranslation defaultTranslation
                context = listField "posts" generalContext (return posts) <> generalContext

            renderRss (feedConfiguration translation) generalContext posts

index :: Language -> Rules ()
index language = do
    categories <- buildCategories (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "categories/*.html")
    tags       <- buildTags       (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "tags/*.html")

    match (fromGlob $ language </> "index.*") $ version "index" $ do
        route $ setExtension "html"
        compile $ do
            posts <- fmap (take 10) . recentFirst =<< (loadAll $ fromGlob $ language </> "posts/*/*")
            let context = listField "posts" (postContext tags categories) (return posts) <> generalContext
            pandocCompiler
                >>= applyAsTemplate                               context
                >>= loadAndApplyTemplate "templates/main.html"    context
                >>= loadAndApplyTemplate "templates/default.html" context
                >>= relativizeUrls

pages :: Language -> Rules ()
pages language = match ((fromGlob $ language </> "*.*") .&&. (complement . fromGlob $ language </> "index.*") .&&. (complement . fromGlob $ language </> "translation.yml")) $ version "page" $ do
    route $ indexRoute
    compile $
        pandocCompiler
            >>= applyAsTemplate                               generalContext
            >>= loadAndApplyTemplate "templates/main.html"    generalContext
            >>= loadAndApplyTemplate "templates/default.html" generalContext
            >>= relativizeUrls

posts :: Language -> Rules ()
posts language = do
    categories <- buildCategories (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "categories/*.html")
    tags       <- buildTags       (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "tags/*.html")

    match (fromGlob $ language </> "posts/*/*") $ do
        route indexRoute
        compile $ do
            let context = postContext tags categories

            pandocCompiler
                >>= saveSnapshot "teaser"
                >>= loadAndApplyTemplate "templates/post.html"    context
                >>= loadAndApplyTemplate "templates/main.html"    context
                >>= loadAndApplyTemplate "templates/default.html" context
                >>= relativizeUrls

tags :: Language -> Rules ()
tags language = sequence_ $ [tags', tags''] <*> pure language where
    tags' :: Language -> Rules ()
    tags' language = do
        categories <- buildCategories (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "categories/*.html")
        tags       <- buildTags       (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "tags/*.html")

        tagsRules tags $ \tag pattern -> do
            route indexRoute
            compile $ do
                posts <- recentFirst =<< loadAll pattern

                let context =
                        boolField "single" (const True)                                <>
                        constField "switch" ("/tags" </> language </> tag)             <>
                        listField "posts" (postContext tags categories) (return posts) <>
                        generalContext

                makeItem ""
                    >>= loadAndApplyTemplate "templates/tag.html"     context
                    >>= loadAndApplyTemplate "templates/default.html" context
                    >>= relativizeUrls

    tags'' :: Language -> Rules ()
    tags'' language = do
        categories <- buildCategories (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "categories/*.html")
        tags       <- buildTags       (fromGlob $ language </> "posts/*/*") (fromCapture $ fromGlob $ language </> "tags/*.html")

        version "tagAllLanguages" $ tagsRules tags $ \tag pattern -> do
            route $ gsubRoute (language </> "tags") (const $ "tags" </> language) `composeRoutes` indexRoute
            compile $ do
                posts <- recentFirst =<< loadAll pattern

                let context =
                        boolField "single" (const False)                               <>
                        constField "switch" ("/" ++ language </> "tags" </> tag)       <>
                        listField "posts" (postContext tags categories) (return posts) <>
                        generalContext

                makeItem ""
                    >>= loadAndApplyTemplate "templates/tag.html"     context
                    >>= loadAndApplyTemplate "templates/default.html" context
                    >>= relativizeUrls

indexRoute :: Routes
indexRoute = customRoute $ (\(p, _) -> p </> "index.html") . splitExtension . toFilePath

dropIndexHtml :: Context a
dropIndexHtml = mapContext transform (urlField "url")
    where
        transform :: FilePath -> FilePath
        transform url = case splitFileName url of
            (p, "index.html") -> takeDirectory p
            _                 -> url

generalContext :: Context String
generalContext = dropIndexHtml <> translationContext <> defaultContext

postContext :: Tags -> Tags -> Context String
postContext tags categories =
    Hakyll.Contrib.I18n.categoryField' "category" categories <>
    Hakyll.Contrib.I18n.tagsField' "tags" tags               <>
    teaserField "teaser" "teaser"                            <>
    generalContext