module Network.IRC.Fun.Bot.Internal.Nicks
( channelIsTracked
, startTrackingAll
, startTrackingChannel
, startTrackingChannels
, stopTrackingAll
, stopTrackingChannel
, stopTrackingChannels
, isInChannel
, presence
, addMember
, changeNick
, addChannel
, removeMemberOnce
, removeMember
, removeChannel
, removeChannels
)
where
import Control.Monad (unless)
import Control.Monad.Trans.RWS
import qualified Data.HashMap.Lazy as M
import Data.Maybe (fromMaybe)
import Network.IRC.Fun.Bot.Internal.Chat (putIrc)
import Network.IRC.Fun.Bot.Internal.State
import Network.IRC.Fun.Bot.Internal.Types
import qualified Network.IRC.Fun.Client.NickTracker as NT
import Network.IRC.Fun.Messages.TypeAliases (ChannelName)
import Network.IRC.Fun.Messages.Types (Message (NamesMessage))
enable :: ChannelState -> ChannelState
enable cstate = cstate { chanTracking = True }
disable :: ChannelState -> ChannelState
disable cstate = cstate { chanTracking = False }
channelIsTracked :: String -> Session e s Bool
channelIsTracked chan = do
chans <- getChans
return $ fromMaybe False $ fmap chanTracking $ M.lookup chan chans
startTrackingAll :: Session e s ()
startTrackingAll = do
chans <- getChans
let chansD = [chan | (chan, ChannelState False _) <- M.toList chans]
chansAllE = M.map enable chans
putChans chansAllE
unless (null chansD) $ putIrc $ NamesMessage chansD Nothing
startTrackingChannel :: String -> Session e s ()
startTrackingChannel chan = do
chans <- getChans
case M.lookup chan chans of
Just cstate -> unless (chanTracking cstate) $ do
let chansE = M.insert chan (cstate { chanTracking = True }) chans
putChans chansE
putIrc $ NamesMessage [chan] Nothing
Nothing -> return ()
startTrackingChannels :: [String] -> Session e s ()
startTrackingChannels chans = do
chanmapAll <- getChans
let given = M.fromList (zip chans (repeat ()))
chanmapG = chanmapAll `M.intersection` given
chanmapD = M.filter (not . chanTracking) chanmapG
chansD = M.keys chanmapD
chanmapE = M.map enable chanmapD
chanmapAllE = chanmapE `M.union` chanmapAll
putChans chanmapAllE
putIrc $ NamesMessage chansD Nothing
stopTrackingAll :: Session e s ()
stopTrackingAll =
modify $ \ bstate -> bstate
{ tracker = NT.newNetwork
, chanstate = M.map disable $ chanstate bstate
}
stopTrackingChannel :: String -> Session e s ()
stopTrackingChannel chan =
modify $ \ bstate -> bstate
{ tracker = NT.removeChannel chan $ tracker bstate
, chanstate = M.adjust disable chan $ chanstate bstate
}
stopTrackingChannels :: [String] -> Session e s ()
stopTrackingChannels chans =
modify $ \ bstate -> bstate
{ tracker = NT.removeChannels chans $ tracker bstate
, chanstate =
let chanmap = chanstate bstate
chanmapE = M.filter chanTracking chanmap
chanmapD = M.map disable chanmapE
in chanmapD `M.union` chanmap
}
isInChannel :: String -> String -> Session e s Bool
nick `isInChannel` chan = do
nt <- gets tracker
return $ NT.isInChannel nick chan nt
presence :: String -> Session e s [ChannelName]
presence nick = do
nt <- gets tracker
return $ NT.presence nick nt
addMember :: String -> String -> Session e s ()
addMember chan nick = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.addToChannel chan nick
changeNick :: String -> String -> Session e s ()
changeNick old new = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.changeNick old new
addChannel :: String -> [String] -> Session e s ()
addChannel chan nicks = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.addChannel chan nicks
removeMemberOnce :: String -> String -> Session e s ()
removeMemberOnce chan nick = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.removeFromChannel chan nick
removeMember :: String -> Session e s ()
removeMember nick = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.removeFromNetwork nick
removeChannel :: String -> Session e s ()
removeChannel chan = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.removeChannel chan
removeChannels :: [String] -> Session e s ()
removeChannels chans = modify $ \ s -> s { tracker = f $ tracker s }
where
f = NT.removeChannels chans