module Rakka.Storage.Repos
    ( loadPageInRepository
    )
    where

import qualified Data.Map as M
import           Data.Maybe
import           Data.Time
import           Network.HTTP.Lucu hiding (redirect)
import           Rakka.Page
import           Rakka.SystemConfig
import           Rakka.Utils
import           Rakka.W3CDateTime
import           Subversion.Types
import           Subversion.FileSystem
import           Subversion.FileSystem.Revision
import           Subversion.FileSystem.Root
import           Subversion.Repository
import           System.FilePath.Posix


loadPageInRepository :: Repository -> PageName -> Maybe RevNum -> IO (Maybe Page)
loadPageInRepository repos name rev
    = do fs   <- getRepositoryFS repos
         rev' <- case rev of
                   Nothing -> getYoungestRev fs
                   Just r  -> return r
         withRevision fs rev'
             $ do exists <- isFile path
                  case exists of
                    True
                        -> return . Just =<< loadPage'
                    False
                        -> return Nothing
    where
      path :: FilePath
      path = "pages" </> encodePageName name

      loadPage' :: Rev Page
      loadPage' = do redirect <- getNodeProp path "rakka:redirect"
                     case redirect of
                       Nothing
                           -> loadPageEntity
                       Just _
                           -> loadPageRedirect

      loadPageEntity :: Rev Page
      loadPageEntity
          = do props   <- getNodePropList path
               hist    <- getNodeHistory True path
               content <- getFileContentsLBS path
               
               let pageRev  = fst $ head hist
                   mimeType = read
                              $ fromMaybe "text/x-rakka"
                              $ fmap chomp (lookup "svn:mime-type" props)

               lastMod <- getRevisionProp "svn:date"
                          >>= return . fromJust . parseW3CDateTime . chomp . fromJust

               return Entity {
                            pageName      = name
                          , pageType      = mimeType
                          , pageLanguage  = fmap chomp (lookup "rakka:lang" props)
                          , pageFileName  = fmap chomp (lookup "rakka:fileName" props)
                          , pageIsTheme   = any ((== "rakka:isTheme") . fst) props
                          , pageIsFeed    = any ((== "rakka:isFeed") . fst) props
                          , pageIsLocked  = any ((== "rakka:isLocked") . fst) props
                          , pageIsBoring  = any ((== "rakka:isBoring") . fst) props
                          , pageIsBinary  = case mimeType of
                                              MIMEType "text" _ _
                                                  -> any ((== "rakka:isBinary") . fst) props
                                              _
                                                  -> True
                          , pageRevision  = pageRev
                          , pageLastMod   = zonedTimeToUTC lastMod
                          , pageSummary   = lookup "rakka:summary" props
                          , pageOtherLang = fromMaybe M.empty
                                            $ fmap
                                                  (M.fromList . fromJust . deserializeStringPairs)
                                                  (lookup "rakka:otherLang" props)
                          , pageContent   = content                                             
                          }
      
      loadPageRedirect :: Rev Page
      loadPageRedirect = fail "FIXME: loadPageRedirect: not implemented"