-- | Offline mode / RC file / -e support module.  Handles spooling lists
-- of commands (from haskeline, files, or the command line) into the vchat
-- layer.
module Lambdabot.Plugin.Core.OfflineRC ( offlineRCPlugin ) where

import Lambdabot.Config.Core
import Lambdabot.IRC
import Lambdabot.Monad
import Lambdabot.Plugin
import Lambdabot.Util

import Control.Concurrent.Lifted
import Control.Exception.Lifted ( evaluate, finally )
import Control.Monad( void, when )
import Control.Monad.State( gets, modify )
import Control.Monad.Trans( lift, liftIO )
import Data.Char
import qualified Data.Map as M
import qualified Data.Set as S
import System.Console.Haskeline (InputT, Settings(..), runInputT, defaultSettings, getInputLine)
import System.IO
import System.Timeout.Lifted
import Codec.Binary.UTF8.String

-- We need to track the number of active sourcings so that we can
-- unregister the server (-> allow the bot to quit) when it is not
-- being used.
type OfflineRCState = Integer
type OfflineRC = ModuleT OfflineRCState LB

offlineRCPlugin :: Module OfflineRCState
offlineRCPlugin :: Module OfflineRCState
offlineRCPlugin = forall st. Module st
newModule
    { moduleDefState :: LB OfflineRCState
moduleDefState = forall (m :: * -> *) a. Monad m => a -> m a
return OfflineRCState
0
    , moduleInit :: ModuleT OfflineRCState LB ()
moduleInit = do
        forall (m :: * -> *) a. MonadLB m => LB a -> m a
lb forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify forall a b. (a -> b) -> a -> b
$ \IRCRWState
s -> IRCRWState
s
            { ircPrivilegedUsers :: Set Nick
ircPrivilegedUsers = forall a. Ord a => a -> Set a -> Set a
S.insert (String -> String -> Nick
Nick String
"offlinerc" String
"null") (IRCRWState -> Set Nick
ircPrivilegedUsers IRCRWState
s)
            }
        -- note: moduleInit is invoked with exceptions masked
        forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadBaseControl IO m => m () -> m ThreadId
forkUnmasked forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadLB m => m ()
waitForInit
            ModuleT OfflineRCState LB ()
lockRC
            [String]
cmds <- forall (m :: * -> *) a. MonadConfig m => Config a -> m a
getConfig Config [String]
onStartupCmds
            forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ String -> ModuleT OfflineRCState LB ()
feed [String]
cmds forall (m :: * -> *) a b.
MonadBaseControl IO m =>
m a -> m b -> m a
`finally` ModuleT OfflineRCState LB ()
unlockRC

    , moduleCmds :: ModuleT OfflineRCState LB [Command (ModuleT OfflineRCState LB)]
moduleCmds = forall (m :: * -> *) a. Monad m => a -> m a
return
        [ (String -> Command Identity
command String
"offline")
            { privileged :: Bool
privileged = Bool
True
            , help :: Cmd (ModuleT OfflineRCState LB) ()
help = forall (m :: * -> *). Monad m => String -> Cmd m ()
say String
"offline. Start a repl"
            , process :: String -> Cmd (ModuleT OfflineRCState LB) ()
process = forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ do
                ModuleT OfflineRCState LB ()
lockRC
                String
histFile <- forall (m :: * -> *) a. MonadLB m => LB a -> m a
lb forall a b. (a -> b) -> a -> b
$ String -> LB String
findLBFileForWriting String
"offlinerc"
                let settings :: Settings (ModuleT OfflineRCState LB)
settings = forall (m :: * -> *). MonadIO m => Settings m
defaultSettings { historyFile :: Maybe String
historyFile = forall a. a -> Maybe a
Just String
histFile }
                ThreadId
_ <- forall (m :: * -> *). MonadBaseControl IO m => m () -> m ThreadId
fork (forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Settings m -> InputT m a -> m a
runInputT Settings (ModuleT OfflineRCState LB)
settings InputT (ModuleT OfflineRCState LB) ()
replLoop forall (m :: * -> *) a b.
MonadBaseControl IO m =>
m a -> m b -> m a
`finally` ModuleT OfflineRCState LB ()
unlockRC)
                forall (m :: * -> *) a. Monad m => a -> m a
return ()
            }
        , (String -> Command Identity
command String
"rc")
            { privileged :: Bool
privileged = Bool
True
            , help :: Cmd (ModuleT OfflineRCState LB) ()
help = forall (m :: * -> *). Monad m => String -> Cmd m ()
say String
"rc name. Read a file of commands (asynchronously). TODO: better name."
            , process :: String -> Cmd (ModuleT OfflineRCState LB) ()
process = \String
fn -> forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ do
                String
txt <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
io forall a b. (a -> b) -> a -> b
$ String -> IO String
readFile String
fn
                forall (m :: * -> *) a. MonadIO m => IO a -> m a
io forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadBase IO m => a -> m a
evaluate forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr seq :: forall a b. a -> b -> b
seq () String
txt
                ModuleT OfflineRCState LB ()
lockRC
                ThreadId
_ <- forall (m :: * -> *). MonadBaseControl IO m => m () -> m ThreadId
fork (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ String -> ModuleT OfflineRCState LB ()
feed (String -> [String]
lines String
txt) forall (m :: * -> *) a b.
MonadBaseControl IO m =>
m a -> m b -> m a
`finally` ModuleT OfflineRCState LB ()
unlockRC)
                forall (m :: * -> *) a. Monad m => a -> m a
return ()
            }
        ]
    }

feed :: String -> OfflineRC ()
feed :: String -> ModuleT OfflineRCState LB ()
feed String
msg = do
    String
cmdPrefix <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> a
head (forall (m :: * -> *) a. MonadConfig m => Config a -> m a
getConfig Config [String]
commandPrefixes)
    let msg' :: String
msg' = case String
msg of
            Char
'>':String
xs -> String
cmdPrefix forall a. [a] -> [a] -> [a]
++ String
"run " forall a. [a] -> [a] -> [a]
++ String
xs
            Char
'!':String
xs -> String
xs
            String
_      -> String
cmdPrefix forall a. [a] -> [a] -> [a]
++ forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
== Char
' ') String
msg
    -- note that `msg'` is unicode, but lambdabot wants utf-8 lists of bytes
    forall (m :: * -> *) a. MonadLB m => LB a -> m a
lb forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadBaseControl IO m =>
Int -> m a -> m (Maybe a)
timeout (Int
15 forall a. Num a => a -> a -> a
* Int
1000 forall a. Num a => a -> a -> a
* Int
1000) forall b c a. (b -> c) -> (a -> b) -> a -> c
. IrcMessage -> LB ()
received forall a b. (a -> b) -> a -> b
$
              IrcMessage { ircMsgServer :: String
ircMsgServer = String
"offlinerc"
                         , ircMsgLBName :: String
ircMsgLBName = String
"offline"
                         , ircMsgPrefix :: String
ircMsgPrefix = String
"null!n=user@null"
                         , ircMsgCommand :: String
ircMsgCommand = String
"PRIVMSG"
                         , ircMsgParams :: [String]
ircMsgParams = [String
"offline", String
":" forall a. [a] -> [a] -> [a]
++ String -> String
encodeString String
msg' ] }

handleMsg :: IrcMessage -> OfflineRC ()
handleMsg :: IrcMessage -> ModuleT OfflineRCState LB ()
handleMsg IrcMessage
msg = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let str :: String
str = case (forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. IrcMessage -> [String]
ircMsgParams) IrcMessage
msg of
            []    -> []
            (String
x:[String]
_) -> forall a. [a] -> [a]
tail String
x
    -- str contains utf-8 list of bytes; convert to unicode
    Handle -> String -> IO ()
hPutStrLn Handle
stdout (String -> String
decodeString String
str)
    Handle -> IO ()
hFlush Handle
stdout

replLoop :: InputT OfflineRC ()
replLoop :: InputT (ModuleT OfflineRCState LB) ()
replLoop = do
    Maybe String
line <- forall (m :: * -> *).
(MonadIO m, MonadMask m) =>
String -> InputT m (Maybe String)
getInputLine String
"lambdabot> "
    case Maybe String
line of
        Maybe String
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
        Just String
x -> do
            let s' :: String
s' = forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace String
x
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
s') forall a b. (a -> b) -> a -> b
$ do
                forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ String -> ModuleT OfflineRCState LB ()
feed String
s'
            Bool
continue <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (forall k a. Ord k => k -> Map k a -> Bool
M.member String
"offlinerc" forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRCRWState -> Map String Bool
ircPersists)
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
continue InputT (ModuleT OfflineRCState LB) ()
replLoop

lockRC :: OfflineRC ()
lockRC :: ModuleT OfflineRCState LB ()
lockRC = do
    forall (m :: * -> *) a.
MonadLBState m =>
(LBState m -> (LBState m -> m ()) -> m a) -> m a
withMS forall a b. (a -> b) -> a -> b
$ \ LBState (ModuleT OfflineRCState LB)
cur LBState (ModuleT OfflineRCState LB) -> ModuleT OfflineRCState LB ()
writ -> do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (LBState (ModuleT OfflineRCState LB)
cur forall a. Eq a => a -> a -> Bool
== OfflineRCState
0) forall a b. (a -> b) -> a -> b
$ do
            forall st. String -> Server st -> ModuleT st LB ()
registerServer String
"offlinerc" IrcMessage -> ModuleT OfflineRCState LB ()
handleMsg
            forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify forall a b. (a -> b) -> a -> b
$ \IRCRWState
state' ->
                IRCRWState
state' { ircPersists :: Map String Bool
ircPersists = forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert String
"offlinerc" Bool
True forall a b. (a -> b) -> a -> b
$ IRCRWState -> Map String Bool
ircPersists IRCRWState
state' }
        LBState (ModuleT OfflineRCState LB) -> ModuleT OfflineRCState LB ()
writ (LBState (ModuleT OfflineRCState LB)
cur forall a. Num a => a -> a -> a
+ OfflineRCState
1)

unlockRC :: OfflineRC ()
unlockRC :: ModuleT OfflineRCState LB ()
unlockRC = forall (m :: * -> *) a.
MonadLBState m =>
(LBState m -> (LBState m -> m ()) -> m a) -> m a
withMS forall a b. (a -> b) -> a -> b
$ \ LBState (ModuleT OfflineRCState LB)
cur LBState (ModuleT OfflineRCState LB) -> ModuleT OfflineRCState LB ()
writ -> do
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (LBState (ModuleT OfflineRCState LB)
cur forall a. Eq a => a -> a -> Bool
== OfflineRCState
1) forall a b. (a -> b) -> a -> b
$ forall mod. String -> ModuleT mod LB ()
unregisterServer String
"offlinerc"
    LBState (ModuleT OfflineRCState LB) -> ModuleT OfflineRCState LB ()
writ (LBState (ModuleT OfflineRCState LB)
cur forall a. Num a => a -> a -> a
- OfflineRCState
1)