module Rakka.Environment
    ( Environment(..)
    , InterpTable
    , setupEnv
    )
    where

import           Data.Map (Map)
import qualified Data.Map as M
import           Network
import qualified Network.HTTP.Lucu.Config as LC
import           Rakka.Storage
import           Rakka.SystemConfig
import           Rakka.Wiki.Interpreter
import qualified Rakka.Wiki.Interpreter.Base      as Base
import qualified Rakka.Wiki.Interpreter.Image     as Image
import qualified Rakka.Wiki.Interpreter.Trackback as Trackback
import qualified Rakka.Wiki.Interpreter.Outline   as Outline
import           Subversion.Repository
import           System.Directory
import           System.FilePath
import           System.Log.Logger

logger = "Rakka.Environment"


data Environment = Environment {
      envLocalStateDir :: !FilePath
    , envLucuConf      :: !LC.Config
    , envRepository    :: !Repository
    , envStorage       :: !Storage
    , envSysConf       :: !SystemConfig
    , envInterpTable   :: !InterpTable
    }


type InterpTable = Map String Interpreter


setupEnv :: FilePath -> PortNumber -> IO Environment
setupEnv lsdir portNum
    = do let lucuConf    = LC.defaultConfig {
                             LC.cnfServerPort = PortNumber portNum
                           }
             reposPath   = lsdir `combine` "repos"
             storage     = mkStorage
             interpTable = mkInterpTable
         
         reposExist  <- doesDirectoryExist reposPath
         repos       <- if reposExist then
                            do debugM logger ("Found a subversion repository on " ++ reposPath)
                               openRepository reposPath
                        else
                            do noticeM logger ("Creating a subversion repository on " ++ reposPath)
                               createRepository reposPath [] []
         sysConf     <- mkSystemConfig lucuConf repos
         

         return $ Environment {
                      envLocalStateDir = lsdir
                    , envLucuConf      = lucuConf
                    , envRepository    = repos
                    , envStorage       = storage
                    , envSysConf       = sysConf
                    , envInterpTable   = interpTable
                    }


mkInterpTable :: InterpTable
mkInterpTable = listToTable $
                foldl (++) [] [ Base.interpreters
                              , Image.interpreters
                              , Trackback.interpreters
                              , Outline.interpreters
                              ]
    where
      listToTable :: [Interpreter] -> InterpTable
      listToTable xs
          = M.fromList [ (commandName x, x) | x <- xs ]