module Client where

import Eval
import Lambda
import AI
import GoalTransform

import System.IO
import System.Environment
import Control.Monad

import qualified Data.Array.IO as A

readMove :: Turn Move
readMove = do
	lr <- liftIO getLine
	sf <- liftIO getLine
	st <- liftIO getLine
	if (lr == "1") then (do
			let f = read sf :: Card
			let t = read st :: Int
			return $ MoveLeft f t
		) else (do
			let f = read sf :: Int
			let t = read st :: Card
			return $ MoveRight f t
		)

stepClient :: Turn ()
stepClient = readMove >>= runMove

stepAI :: Turn Goal -> Turn ()
stepAI ai = do
	try (do
			goal <- ai
			move <- moveGoal goal
			liftIO $ printMove move
			runMove move
		) (\s -> do
			liftIO $ hPutStrLn stderr $ "Error calculating move"
			game <- getGame
			ownfields <- liftIO $ A.getAssocs (fields $ proponent game)
			let (a, _):_ = filter (\(_, (_, v)) -> v > 0) ownfields
			liftIO $ hPutStrLn stderr $ "=> I " ++ show a
			liftIO $ printMove (MoveLeft Card_I a)
			runMove (MoveLeft Card_I a)
		)

run :: Turn Goal -> Bool -> IO ()
run ai firstPlayer = do
		hSetBuffering stdin NoBuffering
		hSetBuffering stdout NoBuffering
		game <- initGame
		runTurn _loop1 game
		return ()
	where
		_loop1 :: Turn ()
		_loop1 = do
			when (firstPlayer) (stepAI ai)
			_loop
		_loop :: Turn ()
		_loop = do
			stepClient
			stepAI ai
			_loop


getArgsFirstPlayer :: IO Bool
getArgsFirstPlayer = do
	arg:_ <- getArgs
	return $ arg == "0"

main = getArgsFirstPlayer >>= run aimove