module Rakka.Storage
    ( Storage

    , mkStorage -- private

    , getPage
    , putPage

    , getPageA
    , putPageA

    , searchPages
    )
    where

import           Control.Arrow.ArrowIO
import           Control.Concurrent.STM
import           Control.Monad
import           Control.Monad.Trans
import           Data.Maybe
import           Rakka.Page
import           Rakka.Storage.Impl
import           Rakka.Storage.Types
import           Subversion.Types
import           System.IO
import           Subversion.Repository
import           Text.HyperEstraier hiding (WriteLock)

logger = "Rakka.Storage"


mkStorage :: FilePath -> Repository -> (Page -> IO Document) -> IO Storage
mkStorage lsdir repos mkDraft
    = do chan <- startIndexManager lsdir repos mkDraft
         let sto = Storage {
                     stoRepository = repos
                   , stoIndexChan  = chan
                   }
         syncIndex sto
         return sto


getPage :: MonadIO m => Storage -> PageName -> Maybe RevNum -> m (Maybe Page)
getPage = ((liftIO .) .) . getPage' . stoRepository


putPage :: MonadIO m => Storage -> Page -> RevNum -> m ()
putPage sto page oldRev
    = error "FIXME: not implemented"


getPageA :: ArrowIO a => Storage -> a (PageName, Maybe RevNum) (Maybe Page)
getPageA = arrIO2 . getPage 


putPageA :: ArrowIO a => Storage -> a (Page, RevNum) ()
putPageA = arrIO2 . putPage


searchPages :: MonadIO m => Storage -> Condition -> m [(PageName, RevNum)]
searchPages sto cond
    = liftIO $
      do var <- newEmptyTMVarIO
         atomically $ writeTChan (stoIndexChan sto) (SearchIndex cond var)
         atomically $ takeTMVar var


syncIndex :: Storage -> IO ()
syncIndex sto
    = atomically $ writeTChan (stoIndexChan sto) SyncIndex