module PlayAsWhite where

import State

import Data.Tree (Tree, unfoldTree, flatten)
import Move
import Data.Function (on)
import Data.List (sortBy)

-- import Data.List
-- import Debug.Trace (trace)
makeMove :: State -> Lookahead -> Moves
makeMove (State s b t m w b2 w1 b1) l = (greedyBot (legalMovesTree (State s b t m w b2 w1 b1)))



--      2 -> legalMoves (State s b t m w b2 w1 b1)
--      4 -> legalMoves (State s b t m w b2 w1 b1) ++ legalMoves (State s b t m w b2 w1 b1)

-- ((firstMove s)) ++ (secondMove(performSingleMove s (firstMove s) ))
--     where
--         firstMove :: State -> Move
--         firstMove s = case (legalMoves s) of
--             x: xs -> [x]
--             x -> [x]
--
--         secondMove :: State -> Move
--         secondMove s = case (legalMoves s) of
--             x: xs -> [x]
--             x -> [x]


--   | primesUnder (l * l) < 0 = []
--   | otherwise =
--     concat $ replicate 4 $ reverse [(x, y) | x <- [0 .. 24], y <- [1 .. 6]]

legalMoveBot :: State -> Moves
legalMoveBot s = case (legalMoves s) of
    [] -> []
    x:xs -> x : legalMoveBot (performSingleMove s (x))

greedyBot :: Tree (State, Move) -> [(State, Move)]
greedyBot treeOfLegalOptions = lowestState (flatten treeOfLegalOptions)

differenceInPips :: (State , Move) -> Int
differenceInPips ((State s b t m wP bP wS bS), move) = abs (wP - bP)

lowestState :: [(State, Move)] -> [(State, Move)]
lowestState listOfLegalStates  = sortBy (compare `on` differenceInPips) listOfLegalStates


primesUnder :: Int -> Int
primesUnder n = length $ filterPrime [2 .. n]
  where
    filterPrime [] = []
    filterPrime (p:xs) = p : filterPrime [x | x <- xs, x `mod` p /= 0]