module Rakka.Wiki.Interpreter.Base
    ( interpreters
    )
    where

import           Data.Map (Map)
import qualified Data.Map as M
import           Data.Maybe
import           Network.URI
import           Rakka.Page
import           Rakka.SystemConfig
import           Rakka.Wiki
import           Rakka.Wiki.Interpreter


interpreters :: [Interpreter]
interpreters = [ lineBreakInterp
               , spanInterp
               , divInterp
               , pageNameInterp
               , otherLangsInterp
               , editPageInterp
               ]


lineBreakInterp :: Interpreter
lineBreakInterp = InlineCommandInterpreter {
                    iciName      = "br"
                  , iciInterpret
                      = \ _ (InlineCommand _ attrs _) -> return $ LineBreak attrs
                  }


spanInterp :: Interpreter
spanInterp = InlineCommandInterpreter {
               iciName      = "span"
             , iciInterpret
                 = \ _ (InlineCommand _ attrs contents) -> return $ Span attrs contents
             }


divInterp :: Interpreter
divInterp = BlockCommandInterpreter {
              bciName      = "div"
            , bciInterpret
                = \ _ (BlockCommand _ attrs contents)
                -> return $ Div attrs (map Block contents)
            }


pageNameInterp :: Interpreter
pageNameInterp = InlineCommandInterpreter {
                   iciName      = "pageName"
                 , iciInterpret
                     = \ ctx _ -> return $ Text (ctxPageName ctx)
                 }


otherLangsInterp :: Interpreter
otherLangsInterp
    = BlockCommandInterpreter {
        bciName      = "inOtherLanguages"
      , bciInterpret
          = \ ctx _ ->
            case fmap pageOtherLang (ctxMainPage ctx) of
              Nothing
                -> return EmptyBlock

              Just linkTable
                  -> do Languages langTable <- getSysConf (ctxSysConf ctx)
                        let merged = mergeTables langTable (M.toList linkTable)
                        return $ mkLangList merged
      }
    where
      mergeTables :: Map LanguageTag LanguageName
                  -> [(LanguageTag, PageName)]
                  -> [(LanguageName, PageName)]
      mergeTables _ []     = []
      mergeTables m (x:xs) = let (langTag, pageName) = x
                                 langName            = fromMaybe langTag (M.lookup langTag m)
                             in
                               (langName, pageName) : mergeTables m xs

      mkLangList :: [(LanguageName, PageName)] -> BlockElement
      mkLangList xs = List Bullet (map mkLangLink xs)

      mkLangLink :: (LanguageName, PageName) -> ListItem
      mkLangLink (langName, pageName)
          = [Inline (PageLink (Just pageName) Nothing (Just langName))]


-- <input type="button"
--        value="Edit"
--        onclick="Rakka.editPage(\"http://example.org/\", \"Foo\")"
--        class="editButton" />
editPageInterp :: Interpreter
editPageInterp 
    = InlineCommandInterpreter {
        iciName      = "editPage"
      , iciInterpret
          = \ ctx (InlineCommand _ args _) ->
            do BaseURI baseURI <- getSysConf (ctxSysConf ctx)

               let pageName = fromMaybe (ctxPageName ctx) (lookup "page" args)
                   label    = fromMaybe "Edit this page" (lookup "label" args)
                   uri      = uriToString id baseURI ""
                   attrs    = [ ("type"   , "button")
                              , ("value"  , label)
                              , ("onclick", "Rakka.editPage(\"" ++ uri ++ "\", \"" ++ pageName ++ "\")")
                              , ("class"  , "editButton")
                              ]

               return (Input attrs)
      }