{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE BangPatterns #-}

import Data.Attoparsec.ByteString as AB
import Data.Attoparsec.Text as AT
import Replace.Attoparsec.ByteString as RB
import Replace.Attoparsec.Text as RT
import Criterion.Main
import Criterion.Types
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
import qualified Data.ByteString.Builder as B.Builder
import qualified Data.Text as T
-- import qualified Data.Text.Lazy as TL
import Data.Void

fooStringM :: String
fooStringM = Prelude.take 1000000 $ cycle "       foo" -- a million bytes of foos
-- fooString10K :: String
-- fooString10K = take 10000 fooStringM
-- fooString100K :: String
-- fooString100K = take 100000 fooStringM

fooByteStringM :: B.ByteString
fooByteStringM = BL.toStrict fooByteStringLM
fooByteString10K :: B.ByteString
fooByteString10K = B.take 10000 fooByteStringM
fooByteString100K :: B.ByteString
fooByteString100K = B.take 100000 fooByteStringM

fooByteStringLM :: BL.ByteString
fooByteStringLM = B.Builder.toLazyByteString $ B.Builder.string8 fooStringM
-- fooByteStringL10K :: BL.ByteString
-- fooByteStringL10K = BL.take 10000 fooByteStringLM
-- fooByteStringL100K :: BL.ByteString
-- fooByteStringL100K = BL.take 100000 fooByteStringLM

fooTextM :: T.Text
fooTextM = T.pack fooStringM
fooText10K :: T.Text
fooText10K = T.take 10000 fooTextM
fooText100K :: T.Text
fooText100K = T.take 100000 fooTextM

-- fooTextLM :: TL.Text
-- fooTextLM = TL.pack fooStringM
-- fooTextL10K :: TL.Text
-- fooTextL10K = TL.take 10000 fooTextLM
-- fooTextL100K :: TL.Text
-- fooTextL100K = TL.take 100000 fooTextLM

main :: IO ()
main = defaultMainWith (defaultConfig
            { reportFile = Just "criterion-report.html"
            , resamples = 100
            })
--     [ bgroup "String"
--         [ bench "sepCap 10,000" $ whnf
--             (parseMaybe (sepCap (chunk "foo" :: Parsec Void String String)))
--             fooString10K
--         , bench "streamEdit 10,000" $ whnf
--             (streamEdit (chunk "foo" :: Parsec Void String String) (const "bar"))
--             fooString10K
--         , bench "sepCap 100,000" $ whnf
--             (parseMaybe (sepCap (chunk "foo" :: Parsec Void String String)))
--             fooString100K
--         , bench "streamEdit 100,000" $ whnf
--             (streamEdit (chunk "foo" :: Parsec Void String String) (const "bar"))
--             fooString100K
--         , bench "sepCap 1,000,000" $ whnf
--             (parseMaybe (sepCap (chunk "foo" :: Parsec Void String String)))
--             fooStringM
--         , bench "streamEdit 1,000,000" $ whnf
--             (streamEdit (chunk "foo" :: Parsec Void String String) (const "bar"))
--             fooStringM
--         ]
    [ bgroup "ByteString.Strict"
        [ bench "sepCap 10,000" $ whnf
            (AB.parseOnly (RB.sepCap (AB.string "foo" )))
            fooByteString10K
        , bench "streamEdit 10,000" $ whnf
            (RB.streamEdit (AB.string "foo") (const "bar"))
            fooByteString10K
        , bench "sepCap 100,000" $ whnf
            (AB.parseOnly (RB.sepCap (AB.string "foo")))
            fooByteString100K
        , bench "streamEdit 100,000" $ whnf
            (RB.streamEdit (AB.string "foo") (const "bar"))
            fooByteString100K
        , bench "sepCap 1,000,000" $ whnf
            (AB.parseOnly (RB.sepCap (AB.string "foo")))
            fooByteStringM
        , bench "streamEdit 1,000,000" $ whnf
            (RB.streamEdit (AB.string "foo") (const "bar"))
            fooByteStringM
        ]
    -- , bgroup "ByteString.Lazy"
    --     [ bench "sepCap 10,000" $ whnf
    --         (parseMaybe (sepCap (chunk "foo" :: Parsec Void BL.ByteString BL.ByteString)))
    --         fooByteStringL10K
    --     , bench "streamEdit 10,000" $ whnf
    --         (streamEdit (chunk "foo" :: Parsec Void BL.ByteString BL.ByteString) (const "bar"))
    --         fooByteStringL10K
    --     , bench "sepCap 100,000" $ whnf
    --         (parseMaybe (sepCap (chunk "foo" :: Parsec Void BL.ByteString BL.ByteString)))
    --         fooByteStringL100K
    --     , bench "streamEdit 100,000" $ whnf
    --         (streamEdit (chunk "foo" :: Parsec Void BL.ByteString BL.ByteString) (const "bar"))
    --         fooByteStringL100K
    --     , bench "sepCap 1,000,000" $ whnf
    --         (parseMaybe (sepCap (chunk "foo" :: Parsec Void BL.ByteString BL.ByteString)))
    --         fooByteStringLM
    --     , bench "streamEdit 1,000,000" $ whnf
    --         (streamEdit (chunk "foo" :: Parsec Void BL.ByteString BL.ByteString) (const "bar"))
    --         fooByteStringLM
    --     ]
    , bgroup "Text.Strict"
        [ bench "sepCap 10,000" $ whnf
            (AT.parseOnly (RT.sepCap (AT.string "foo")))
            fooText10K
        , bench "streamEdit 10,000" $ whnf
            (RT.streamEdit (AT.string "foo") (const "bar"))
            fooText10K
        , bench "sepCap 100,000" $ whnf
            (AT.parseOnly (RT.sepCap (AT.string "foo")))
            fooText100K
        , bench "streamEdit 100,000" $ whnf
            (RT.streamEdit (AT.string "foo") (const "bar"))
            fooText100K
        , bench "sepCap 1,000,000" $ whnf
            (AT.parseOnly (RT.sepCap (AT.string "foo")))
            fooTextM
        , bench "streamEdit 1,000,000" $ whnf
            (RT.streamEdit (AT.string "foo") (const "bar"))
            fooTextM
        ]
    --, bgroup "Text.Lazy"
    --    [ bench "sepCap 10,000" $ whnf
    --        (parseMaybe (sepCap (chunk "foo" :: Parsec Void TL.Text TL.Text)))
    --        fooTextL10K
    --    , bench "streamEdit 10,000" $ whnf
    --        (streamEdit (chunk "foo" :: Parsec Void TL.Text TL.Text) (const "bar"))
    --        fooTextL10K
    --    , bench "sepCap 100,000" $ whnf
    --        (parseMaybe (sepCap (chunk "foo" :: Parsec Void TL.Text TL.Text)))
    --        fooTextL100K
    --    , bench "streamEdit 100,000" $ whnf
    --        (streamEdit (chunk "foo" :: Parsec Void TL.Text TL.Text) (const "bar"))
    --        fooTextL100K
    --    , bench "sepCap 1,000,000" $ whnf
    --        (parseMaybe (sepCap (chunk "foo" :: Parsec Void TL.Text TL.Text)))
    --        fooTextLM
    --    , bench "streamEdit 1,000,000" $ whnf
    --        (streamEdit (chunk "foo" :: Parsec Void TL.Text TL.Text) (const "bar"))
    --        fooTextLM
    --    ]
    ]