-- You can add more imports as you need them.
import Hearts.Types
import Cards

playCard :: PlayFunc
playCard _ hand trick prevTrick = ((pickCardAI hand trick prevTrick), "memory")

suit :: Card -> Suit
suit (Card s _) = s

playLead :: [Card] -> Card
playLead hand = playTwoClubsOrMin hand (head hand)
    where
        playTwoClubsOrMin [] smallest = smallest
        playTwoClubsOrMin (x:xs) smallest
            | x == Card Club Two = Card Club Two
            | x < smallest = playTwoClubsOrMin xs x
            | otherwise = playTwoClubsOrMin xs smallest

decidePlayFollowSuitOrPlayScore :: [Card] -> [(Card, PlayerId)] -> Maybe ([(Card, PlayerId)], String) -> Card
decidePlayFollowSuitOrPlayScore hand trick prevState = playFollowSuitOrScoreCard
    where
        followSuitCards = getFollowSuitCards hand trick
        playFollowSuitOrScoreCard = if (followSuitCards /= [])
                                    then (playFollowSuit followSuitCards trick prevState)
                                    else (playScore hand)

playScore :: [Card] -> Card
playScore hand = maximum $ spadeQueen ++ hearts ++ highestScore
    where
        spadeQueen = filter (\x -> x == (Card Spade Queen)) hand
        hearts = if (spadeQueen == [])
                    then filter (\x -> suit x == Heart) hand
                    else []
        highestScore = if (hearts == [])
                        then (hand)
                        else []

playFollowSuit :: [Card] -> [(Card, PlayerId)] -> Maybe ([(Card, PlayerId)], String) -> Card
playFollowSuit followSuitCards trick prevState = lessThanLeadOrMinMax
    where
        leadCard = trickLeadCard trick
        tryFollowSuitLessThanLead = getLessThanLeadCards followSuitCards leadCard
        lessThanLeadOrMinMax = if (tryFollowSuitLessThanLead == [])
                        then (getMinOrMaxDependingOnTurn followSuitCards trick prevState)
                        else maximum tryFollowSuitLessThanLead

trickLeadCard :: [(Card, PlayerId)] -> Card
trickLeadCard trick = fst $ last $ trick
-- trickLeadCard [] = error "should be covered in pickCardAI"

getFollowSuitCards :: [Card] -> [(Card, PlayerId)] -> [Card]
getFollowSuitCards hand trick = followSuitCards
    where
        leadCard = trickLeadCard trick
        followSuitCards = filter (\x -> suit x == suit leadCard) hand

getLessThanLeadCards :: [Card] -> Card -> [Card]
getLessThanLeadCards followSuitCards leadCard = lessThanLead
    where
        lessThanLead = filter (\x -> x < leadCard) followSuitCards

getMinOrMaxDependingOnTurn :: [Card] -> [(Card, PlayerId)] -> Maybe ([(Card, PlayerId)], String) -> Card
getMinOrMaxDependingOnTurn followSuitCards trick prevState = minOrMaxCard
    where
        minOrMaxCard = if (isLast (lengthPreviousTrick prevState) (length trick))
                        then (maximum followSuitCards)
                        else (minimum followSuitCards)

isLast :: Int -> Int -> Bool
isLast lenPrevTrick lenCurTrick
    | lenPrevTrick > lenCurTrick = False
    | otherwise = True

lengthPreviousTrick :: Maybe ([(Card, PlayerId)], String) -> Int
lengthPreviousTrick Nothing = 0
lengthPreviousTrick (Just (prevTrick, _)) = length prevTrick


pickCardAI :: [Card] -> [(Card, PlayerId)] -> Maybe ([(Card, PlayerId)], String) -> Card
pickCardAI hand trick prevState
    | trick == [] = playLead hand
    | otherwise = decidePlayFollowSuitOrPlayScore hand trick prevState