module Commons where

import Data.List.Utils (split)
import GHC.IO.Handle (isEOF)
import Data.Char (digitToInt, isDigit)
import Data.List (sortOn)


data Hand = Hand { values :: [Int], bid :: Int } deriving Show
data HandValue = HandValue { hand :: Hand, value :: Int } deriving Show


parseValues :: String -> [Int]
parseValues (v: t) | isDigit v = digitToInt v: parseValues t
                   | v == 'T'  = 10:           parseValues t
                   | v == 'J'  = 11:           parseValues t
                   | v == 'Q'  = 12:           parseValues t
                   | v == 'K'  = 13:           parseValues t
                   | v == 'A'  = 14:           parseValues t
parseValues [] = []

parseHand :: String -> Hand
parseHand handRaw = let valuesRaw: bidRaw: _ = split " " handRaw
                    in Hand {values = parseValues valuesRaw, bid = read bidRaw}

parse :: IO [Hand]
parse = do done <- isEOF
           if done
              then return []
              else do line <- getLine
                      let hand = parseHand line
                      otherHands <- parse
                      return $ hand: otherHands


getHandValueTypeFromSorted :: [Int] -> Int
getHandValueTypeFromSorted [a, b, c, d, e] | a == e                                           = 6
                                           | a == d || b == e                                 = 5
                                           | a == c && d == e || a == b && c == e             = 4
                                           | a == c || b == d || c == e                       = 3
                                           | a == b && (c == d || d == e) || b == c && d == e = 2
                                           | a == b || b == c || c == d || d == e             = 1
                                           | otherwise                                        = 0

getHandSecondValue :: [Int] -> Int
getHandSecondValue [a, b, c, d, e] = 100 * (100 * (100 * (100 * a + b) + c) + d) + e

sortHandValues :: [HandValue] -> [HandValue]
sortHandValues = sortOn value

getWinningsFromSorted :: Int -> [Hand] -> Int
getWinningsFromSorted _ [] = 0
getWinningsFromSorted i (hh: t) = i * bid hh + getWinningsFromSorted (i + 1) t