{-# LANGUAGE CPP, OverloadedStrings #-}

{-# OPTIONS_GHC -fno-warn-orphans #-}

module Actions where

import Control.Concurrent

import qualified Data.Set as Set

import qualified Data.Sequence as Seq

import qualified Data.List as L

import qualified Control.Exception as Exception

import System.Log.Logger

import Control.Monad

import Data.Time

import Data.Maybe

import Control.Monad.Reader

import Control.Monad.State.Strict

import qualified Data.ByteString.Char8 as B

import Control.DeepSeq

import Data.Unique

import Control.Arrow

import Control.Exception

import System.Process

import Network.Socket

-----------------------------

#if defined(OFFICIAL_SERVER)

import OfficialServer.GameReplayStore

#endif

import CoreTypes

import Utils

import ClientIO

import ServerState

import Consts

import ConfigFile

import EngineInteraction

data Action =

    AnswerClients ![ClientChan] ![B.ByteString]

    | SendServerMessage

    | SendServerVars

    | MoveToRoom RoomIndex

    | MoveToLobby B.ByteString

    | RemoveTeam B.ByteString

    | SendTeamRemovalMessage B.ByteString

    | RemoveRoom

    | FinishGame

    | UnreadyRoomClients

    | JoinLobby

    | ProtocolError B.ByteString

    | Warning B.ByteString

    | NoticeMessage Notice

    | ByeClient B.ByteString

    | KickClient ClientIndex

    | KickRoomClient ClientIndex

    | BanClient NominalDiffTime B.ByteString ClientIndex

    | BanIP B.ByteString NominalDiffTime B.ByteString

    | BanList

    | Unban B.ByteString

    | ChangeMaster

    | RemoveClientTeams ClientIndex

    | ModifyClient (ClientInfo -> ClientInfo)

    | ModifyClient2 ClientIndex (ClientInfo -> ClientInfo)

    | ModifyRoomClients (ClientInfo -> ClientInfo)

    | ModifyRoom (RoomInfo -> RoomInfo)

    | ModifyServerInfo (ServerInfo -> ServerInfo)

    | AddRoom B.ByteString B.ByteString

    | SendUpdateOnThisRoom

    | CheckRegistered

    | ClearAccountsCache

    | ProcessAccountInfo AccountInfo

    | AddClient ClientInfo

    | DeleteClient ClientIndex

    | PingAll

    | StatsAction

    | RestartServer

    | AddNick2Bans B.ByteString B.ByteString UTCTime

    | AddIP2Bans B.ByteString B.ByteString UTCTime

    | CheckBanned

    | SaveReplay

type CmdHandler = [B.ByteString] -> Reader (ClientIndex, IRnC) [Action]

instance NFData Action where

    rnf (AnswerClients chans msg) = chans `deepseq` msg `deepseq` ()

    rnf a = a `seq` ()

instance NFData B.ByteString

instance NFData (Chan a)

othersChans :: StateT ServerState IO [ClientChan]

othersChans = do

    cl <- client's id

    ri <- clientRoomA

    liftM (map sendChan . filter (/= cl)) $ roomClientsS ri

processAction :: Action -> StateT ServerState IO ()

processAction (AnswerClients chans msg) =

    io $ mapM_ (`writeChan` (msg `deepseq` msg)) (chans `deepseq` chans)

processAction SendServerMessage = do

    chan <- client's sendChan

    protonum <- client's clientProto

    si <- liftM serverInfo get

    let message = if protonum < latestReleaseVersion si then

            serverMessageForOldVersions si

            else

            serverMessage si

    processAction $ AnswerClients [chan] ["SERVER_MESSAGE", message]

processAction SendServerVars = do

    chan <- client's sendChan

    si <- gets serverInfo

    io $ writeChan chan ("SERVER_VARS" : vars si)

    where

        vars si = [

            "MOTD_NEW", serverMessage si,

            "MOTD_OLD", serverMessageForOldVersions si,

            "LATEST_PROTO", showB $ latestReleaseVersion si

            ]

processAction (ProtocolError msg) = do

    chan <- client's sendChan

    processAction $ AnswerClients [chan] ["ERROR", msg]

processAction (Warning msg) = do

    chan <- client's sendChan

    processAction $ AnswerClients [chan] ["WARNING", msg]

processAction (NoticeMessage n) = do

    chan <- client's sendChan

    processAction $ AnswerClients [chan] ["NOTICE", showB . fromEnum $ n]

processAction (ByeClient msg) = do

    (Just ci) <- gets clientIndex

    ri <- clientRoomA

    chan <- client's sendChan

    clNick <- client's nick

    loggedIn <- client's logonPassed

    when (ri /= lobbyId) $ do

        processAction $ MoveToLobby ("quit: " `B.append` msg)

        return ()

    clientsChans <- liftM (Prelude.map sendChan . Prelude.filter logonPassed) $! allClientsS

    io $

        infoM "Clients" (show ci ++ " quits: " ++ B.unpack msg)

    when loggedIn $ processAction $ AnswerClients clientsChans ["LOBBY:LEFT", clNick, msg]

    mapM processAction

        [

        AnswerClients [chan] ["BYE", msg]

        , ModifyClient (\c -> c{nick = "", logonPassed = False}) -- this will effectively hide client from others while he isn't deleted from list

        ]

    s <- get

    put $! s{removedClients = ci `Set.insert` removedClients s}

processAction (DeleteClient ci) = do

    io $ debugM "Clients"  $ "DeleteClient: " ++ show ci

    rnc <- gets roomsClients

    io $ removeClient rnc ci

    s <- get

    put $! s{removedClients = ci `Set.delete` removedClients s}

    sp <- gets (shutdownPending . serverInfo)

    cls <- allClientsS

    io $ when (sp && null cls) $ throwIO ShutdownException

processAction (ModifyClient f) = do

    (Just ci) <- gets clientIndex

    rnc <- gets roomsClients

    io $ modifyClient rnc f ci

    return ()

processAction (ModifyClient2 ci f) = do

    rnc <- gets roomsClients

    io $ modifyClient rnc f ci

    return ()

processAction (ModifyRoomClients f) = do

    rnc <- gets roomsClients

    ri <- clientRoomA

    roomClIDs <- io $ roomClientsIndicesM rnc ri

    io $ mapM_ (modifyClient rnc f) roomClIDs

processAction (ModifyRoom f) = do

    rnc <- gets roomsClients

    ri <- clientRoomA

    io $ modifyRoom rnc f ri

    return ()

processAction (ModifyServerInfo f) = do

    modify (\s -> s{serverInfo = f $ serverInfo s})

    si <- gets serverInfo

    io $ writeServerConfig si

processAction (MoveToRoom ri) = do

    (Just ci) <- gets clientIndex

    rnc <- gets roomsClients

    io $ do

        modifyClient rnc (\cl -> cl{teamsInGame = 0, isReady = False, isMaster = False, isInGame = False}) ci

        modifyRoom rnc (\r -> r{playersIn = playersIn r + 1}) ri

        moveClientToRoom rnc ri ci

    chans <- liftM (map sendChan) $ roomClientsS ri

    clNick <- client's nick

    processAction $ AnswerClients chans ["JOINED", clNick]

processAction (MoveToLobby msg) = do

    (Just ci) <- gets clientIndex

    ri <- clientRoomA

    rnc <- gets roomsClients

    playersNum <- io $ room'sM rnc playersIn ri

    master <- client's isMaster

--    client <- client's id

    clNick <- client's nick

    chans <- othersChans

    if master then

        if playersNum > 1 then

            mapM_ processAction [ChangeMaster, NoticeMessage AdminLeft, RemoveClientTeams ci, AnswerClients chans ["LEFT", clNick, msg]]

            else

            processAction RemoveRoom

        else

        mapM_ processAction [RemoveClientTeams ci, AnswerClients chans ["LEFT", clNick, msg]]

    -- when not removing room

    ready <- client's isReady

    when (not master || playersNum > 1) . io $ do

        modifyRoom rnc (\r -> r{

                playersIn = playersIn r - 1,

                readyPlayers = if ready then readyPlayers r - 1 else readyPlayers r

                }) ri

        moveClientToLobby rnc ci

processAction ChangeMaster = do

    (Just ci) <- gets clientIndex

    proto <- client's clientProto

    ri <- clientRoomA

    rnc <- gets roomsClients

    newMasterId <- liftM (last . filter (/= ci)) . io $ roomClientsIndicesM rnc ri

    newMaster <- io $ client'sM rnc id newMasterId

    oldRoomName <- io $ room'sM rnc name ri

    oldMaster <- client's nick

    thisRoomChans <- liftM (map sendChan) $ roomClientsS ri

    let newRoomName = if proto < 42 then nick newMaster else oldRoomName

    mapM_ processAction [

        ModifyRoom (\r -> r{masterID = newMasterId

                , name = newRoomName

                , isRestrictedJoins = False

                , isRestrictedTeams = False

                , readyPlayers = if isReady newMaster then readyPlayers r else readyPlayers r + 1})

        , ModifyClient2 newMasterId (\c -> c{isMaster = True, isReady = True})

        , AnswerClients [sendChan newMaster] ["ROOM_CONTROL_ACCESS", "1"]

        , AnswerClients thisRoomChans ["WARNING", "New room admin is " `B.append` nick newMaster]

        , AnswerClients thisRoomChans ["CLIENT_FLAGS", "-h", oldMaster]

        , AnswerClients thisRoomChans ["CLIENT_FLAGS", "+hr", nick newMaster]

        ]

    newRoom' <- io $ room'sM rnc id ri

    chans <- liftM (map sendChan) $! sameProtoClientsS proto

    processAction $ AnswerClients chans ("ROOM" : "UPD" : oldRoomName : roomInfo (nick newMaster) newRoom')

processAction (AddRoom roomName roomPassword) = do

    Just clId <- gets clientIndex

    rnc <- gets roomsClients

    proto <- client's clientProto

    n <- client's nick

    let rm = newRoom{

            masterID = clId,

            name = roomName,

            password = roomPassword,

            roomProto = proto

            }

    rId <- io $ addRoom rnc rm

    processAction $ MoveToRoom rId

    chans <- liftM (map sendChan) $! sameProtoClientsS proto

    mapM_ processAction [

      AnswerClients chans ("ROOM" : "ADD" : roomInfo n rm{playersIn = 1})

        ]

processAction RemoveRoom = do

    Just clId <- gets clientIndex

    rnc <- gets roomsClients

    ri <- io $ clientRoomM rnc clId

    roomName <- io $ room'sM rnc name ri

    others <- othersChans

    proto <- client's clientProto

    chans <- liftM (map sendChan) $! sameProtoClientsS proto

    mapM_ processAction [

            AnswerClients chans ["ROOM", "DEL", roomName],

            AnswerClients others ["ROOMABANDONED", roomName]

        ]

    io $ removeRoom rnc ri

processAction SendUpdateOnThisRoom = do

    Just clId <- gets clientIndex

    proto <- client's clientProto

    rnc <- gets roomsClients

    ri <- io $ clientRoomM rnc clId

    rm <- io $ room'sM rnc id ri

    n <- io $ client'sM rnc nick (masterID rm)

    chans <- liftM (map sendChan) $! sameProtoClientsS proto

    processAction $ AnswerClients chans ("ROOM" : "UPD" : name rm : roomInfo n rm)

processAction UnreadyRoomClients = do

    ri <- clientRoomA

    roomPlayers <- roomClientsS ri

    pr <- client's clientProto

    mapM_ processAction [

        AnswerClients (map sendChan roomPlayers) $ notReadyMessage pr . map nick . filter (not . isMaster) $ roomPlayers

        , ModifyRoomClients (\cl -> cl{isReady = isMaster cl})

        , ModifyRoom (\r -> r{readyPlayers = 1})

        ]

    where

        notReadyMessage p nicks = if p < 38 then "NOT_READY" : nicks else "CLIENT_FLAGS" : "-r" : nicks

processAction FinishGame = do

    rnc <- gets roomsClients

    ri <- clientRoomA

    thisRoomChans <- liftM (map sendChan) $ roomClientsS ri

    answerRemovedTeams <- io $

         room'sM rnc (map (\t -> AnswerClients thisRoomChans ["REMOVE_TEAM", t]) . leftTeams . fromJust . gameInfo) ri

    mapM_ processAction $

        SaveReplay

        : ModifyRoom

            (\r -> r{

                gameInfo = Nothing,

                readyPlayers = 0

                }

            )

        : UnreadyRoomClients

        : SendUpdateOnThisRoom

        : answerRemovedTeams

processAction (SendTeamRemovalMessage teamName) = do

    chans <- othersChans

    mapM_ processAction [

        AnswerClients chans ["EM", rmTeamMsg],

        ModifyRoom (\r -> r{

                gameInfo = liftM (\g -> g{

                    teamsInGameNumber = teamsInGameNumber g - 1

                    , roundMsgs = roundMsgs g Seq.|> rmTeamMsg

                }) $ gameInfo r

            })

        ]

    rnc <- gets roomsClients

    ri <- clientRoomA

    gi <- io $ room'sM rnc gameInfo ri

    when (isJust gi && 0 == teamsInGameNumber (fromJust gi)) $

        processAction FinishGame

    where

        rmTeamMsg = toEngineMsg $ 'F' `B.cons` teamName

processAction (RemoveTeam teamName) = do

    rnc <- gets roomsClients

    ri <- clientRoomA

    inGame <- io $ room'sM rnc (isJust . gameInfo) ri

    chans <- othersChans

    mapM_ processAction $

        ModifyRoom (\r -> r{

            teams = Prelude.filter (\t -> teamName /= teamname t) $ teams r

            , gameInfo = liftM (\g -> g{leftTeams = teamName : leftTeams g}) $ gameInfo r

            })

        : SendUpdateOnThisRoom

        : AnswerClients chans ["REMOVE_TEAM", teamName]

        : [SendTeamRemovalMessage teamName | inGame]

processAction (RemoveClientTeams clId) = do

    rnc <- gets roomsClients

    removeTeamActions <- io $ do

        clNick <- client'sM rnc nick clId

        rId <- clientRoomM rnc clId

        roomTeams <- room'sM rnc teams rId

        return . Prelude.map (RemoveTeam . teamname) . Prelude.filter (\t -> teamowner t == clNick) $ roomTeams

    mapM_ processAction removeTeamActions

processAction CheckRegistered = do

    (Just ci) <- gets clientIndex

    n <- client's nick

    h <- client's host

    p <- client's clientProto

    uid <- client's clUID

    haveSameNick <- liftM (not . null . tail . filter (\c -> caseInsensitiveCompare (nick c) n)) allClientsS

    if haveSameNick then

        if p < 38 then

            mapM_ processAction [ByeClient "Nickname is already in use", removeNick]

            else

            mapM_ processAction [NoticeMessage NickAlreadyInUse, removeNick]

        else

        do

        db <- gets (dbQueries . serverInfo)

        io $ writeChan db $ CheckAccount ci (hashUnique uid) n h

        return ()

   where

       removeNick = ModifyClient (\c -> c{nick = ""})

processAction ClearAccountsCache = do

    dbq <- gets (dbQueries . serverInfo)

    io $ writeChan dbq ClearCache

    return ()

processAction (ProcessAccountInfo info) =

    case info of

        HasAccount passwd isAdmin -> do

            chan <- client's sendChan

            mapM_ processAction [AnswerClients [chan] ["ASKPASSWORD"], ModifyClient (\c -> c{webPassword = passwd, isAdministrator = isAdmin})]

        Guest ->

            processAction JoinLobby

        Admin -> do

            mapM_ processAction [ModifyClient (\cl -> cl{isAdministrator = True}), JoinLobby]

            chan <- client's sendChan

            processAction $ AnswerClients [chan] ["ADMIN_ACCESS"]

processAction JoinLobby = do

    chan <- client's sendChan

    clientNick <- client's nick

    isAuthenticated <- liftM (not . B.null) $ client's webPassword

    isAdmin <- client's isAdministrator

    loggedInClients <- liftM (Prelude.filter logonPassed) $! allClientsS

    let (lobbyNicks, clientsChans) = unzip . L.map (nick &&& sendChan) $ loggedInClients

    let authenticatedNicks = L.map nick . L.filter (not . B.null . webPassword) $ loggedInClients

    let adminsNicks = L.map nick . L.filter isAdministrator $ loggedInClients

    let clFlags = B.concat . L.concat $ [["u" | isAuthenticated], ["a" | isAdmin]]

    mapM_ processAction . concat $ [

        [AnswerClients clientsChans ["LOBBY:JOINED", clientNick]]

        , [AnswerClients [chan] ("LOBBY:JOINED" : clientNick : lobbyNicks)]

        , [AnswerClients [chan] ("CLIENT_FLAGS" : "+u" : authenticatedNicks) | not $ null authenticatedNicks]

        , [AnswerClients [chan] ("CLIENT_FLAGS" : "+a" : adminsNicks) | not $ null adminsNicks]

        , [AnswerClients (chan : clientsChans) ["CLIENT_FLAGS",  B.concat["+" , clFlags], clientNick] | not $ B.null clFlags]

        , [ModifyClient (\cl -> cl{logonPassed = True})]

        , [SendServerMessage]

        ]

processAction (KickClient kickId) = do

    modify (\s -> s{clientIndex = Just kickId})

    clHost <- client's host

    currentTime <- io getCurrentTime

    mapM_ processAction [

        AddIP2Bans clHost "60 seconds cooldown after kick" (addUTCTime 60 currentTime),

        ByeClient "Kicked"

        ]

processAction (BanClient seconds reason banId) = do

    modify (\s -> s{clientIndex = Just banId})