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

import           Control.Concurrent.STM
import           Control.Arrow.ArrowIO
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           Rakka.Wiki.Interpreter.Base
import           Subversion.Repository
import           System.Directory
import           System.FilePath


data Environment = Environment {
      envLocalStateDir :: !FilePath
    , envLucuConf      :: !LC.Config
    , envRepository    :: !Repository
    , envStorage       :: !Storage
    , envSysConf       :: !SystemConfig
    , envInterpTable   :: !(TVar 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
         
         reposExist  <- doesDirectoryExist reposPath
         repos       <- if reposExist then
                            openRepository reposPath
                        else
                            createRepository reposPath [] []
         sysConf     <- mkSystemConfig lucuConf repos
         interpTable <- mkInterpTable

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


mkInterpTable :: IO (TVar InterpTable)
mkInterpTable = newTVarIO (listToTable baseInterpreters)
    where
      listToTable :: [Interpreter] -> InterpTable
      listToTable xs
          = M.fromList [ (commandName x, x) | x <- xs ]


getInterpTable :: Environment -> IO InterpTable
getInterpTable = atomically . readTVar . envInterpTable


getInterpTableA :: ArrowIO a => Environment -> a b InterpTable
getInterpTableA = arrIO0 . getInterpTable