module Main (main) where

import Logging
import FSM
import CR
import Syntax 
import KnowledgeBase
import CopFSM
import Graph

import CopInform ( informMessage )
import CopPlan   ( planMessage )
import CopStrategy ( mkVoteMsg, simpleCopStrategy )

import qualified RobberABMoveFun as Rob
import qualified CopSimpleMoveFun as SimpleCop

import Data.IORef               ( newIORef, readIORef, writeIORef, IORef )
import System.IO.Unsafe         ( unsafePerformIO )

name = "GDayImMrNiceGuy"

delay = genericDelay 3500

type EvilState = IORef (Maybe (Either FromPlan Plans))

evilState :: EvilState
evilState = unsafePerformIO $ newIORef Nothing
{-# NOINLINE evilState #-}

setPlans name = 
    do s <- readIORef evilState
       case s of
         Just (Left (FromPlan l)) ->
             let ps = searchPlans l
                 in writeIORef evilState (Just $ Right ps)
         _ -> return ()
    where searchPlans [] = []
          searchPlans ((FromMsgP name' ps) : rest)
              | name == name' = ps
              | otherwise     = searchPlans rest

evilCopStrategy =
    CopStrategy 
    { 
     csMkRegisterMsg   = \ name -> return $ Register name CopFoot
    , csStoreWorldSkel = csStoreWorldSkel simpleCopStrategy
    , csStoreWorld     = csStoreWorld simpleCopStrategy
    , csMkInformMsg    = csMkInformMsg simpleCopStrategy
    , csMkPlanMsg      = csMkPlanMsg simpleCopStrategy
    , csMkVoteMsg      = 
      \fp -> do liftIO $ writeIORef evilState (Just $ Left fp)
                csMkVoteMsg simpleCopStrategy fp
    , csMkMoveMsg       = 
      \vres -> do case vres of
                    NoWinner -> return ()
                    Winner n -> liftIO $ setPlans n
                  kb <- getKB
                  let dirty = case whoami kb of
                               MyRobber -> niceError ("I'm a cop, not a robber")
                               MyCop c -> if cop_dirty c == DirtyForSure
                                             then Dirty
                                             else NotDirty
                  m <- SimpleCop.moveFun 
                  info ("dirty: " ++ show dirty)
                  case m of
                    CopMove _ block accuse -> 
                      return (CopMove TurnCoat block accuse, dirty)
    , csDirtyStoreWorld      = 
      \w -> do kb <- getKB
               let kb' = updateKnowledge kb w
               setKB kb'
               Rob.preFun
    , csDirtyMkInformMsg     = delay (liftIO mkInformMsg)
    , csDirtyMkPlanMsg       = 
      \_ -> do moveMsg <- Rob.moveFun
               kb <- getKB
               let p = case moveMsg of
                         (Move loc _ name) ->
                           Plan name loc Robber (kb_worldCount kb)
               return $ PlanMsg [p]
    , csDirtyMkVoteMsg       = 
      \_ -> do kb <- getKB
               return $ VoteMsg [(kb_ownName kb)]
    , csDirtyHandleVoteRes   = 
      \_ -> return ()
    }

mkInformMsg = 
    do s <- readIORef evilState
       case s of
         Just (Right ps) ->
             let informs = map makeInform ps
                 in return $ InformMsg informs
         _  -> do warn "no plans available for evil cop!"
                  return $ InformMsg []
    where makeInform (Plan name loc pt wno) =
              Inform name loc pt wno 100

crState = 
    CRState 
    { 
     crCopStrat    = evilCopStrategy
    , crRobberStrat = niceError "no robber strategy!"
    , crKB = Nothing 
    }

main :: IO ()
main = do
    initLogging Ignore UseStderr
    flip runCR crState $ do
        initState <- mkStateInitial name
        runFSM initState