module Main ( main ) where

import Data.Poker
import Data.Poker.Internal

import Control.Monad.ST
import Data.Array.ST
import Data.Array.Base
import Foreign.C
import System.IO.Unsafe

import Criterion.Main
import Criterion.Config



main :: IO ()
main = defaultMain benchmarks


benchmarks :: [Benchmark]
benchmarks =
    [ bgroup "Enumerate"
        [ bench "C" (whnf countHands_c exampleMask)
        , bench "Haskell" (whnf countHands_hs exampleMask)
        , bench "Haskell+fold" (whnf countHands_fold_hs exampleMask)
        ]
    , bgroup "Enumerate+evaluate"
        [ bench "C" (whnf measureEval_c exampleMask)
        , bench "Haskell" (whnf measureEval_hs exampleMask) ]
    , bgroup "HaskellOnly"
        [ bench "ConsecutiveHandValues" (whnf distHandValue exampleMask) ]
    ]
  where
    exampleMask = read "[Ah, Ac]"







countHands_hs :: CardSet -> Int
countHands_hs dead = runSTUArray (do
    ref <- newArray (0,0) 0
    let worker _ = do
            n <- unsafeRead ref 0
            unsafeWrite ref 0 (n+1)
    enumerateFiveCards dead worker
    return ref) ! 0

countHands_fold_hs :: CardSet -> Int
countHands_fold_hs dead = foldlFiveCards (const (+1)) 0 dead


measureEval_hs :: CardSet -> ()
measureEval_hs dead = runST (do
    let worker community = numericalHandValue_n 7 (community `union` dead) `seq` do
            return ()
    enumerateFiveCards dead worker)



foreign import ccall unsafe "hs_count_hands" c_count_hands :: StdDeck_CardMask -> CInt
countHands_c :: CardSet -> Int
countHands_c (CardSet m) =
  fromIntegral (c_count_hands m)

foreign import ccall unsafe "hs_measure_eval" c_measure_eval :: StdDeck_CardMask -> IO ()
measureEval_c :: CardSet -> ()
measureEval_c (CardSet m) =
  unsafePerformIO (c_measure_eval m)