{-# LANGUAGE PackageImports #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Main (main) where

import Prelude ()
import Prelude.Compat

import Blaze.ByteString.Builder (toLazyByteString)
import Blaze.ByteString.Builder.Char.Utf8 (fromString)
import Control.DeepSeq (NFData(rnf))
import Criterion.Main
import Data.Maybe (fromMaybe)
import qualified "aeson-benchmarks" Data.Aeson as A
import qualified "aeson-benchmarks" Data.Aeson.Text as A
import qualified "aeson-benchmarks" Data.Aeson.Parser.Internal as I
import qualified "aeson" Data.Aeson as B
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BL
import qualified Data.Text.Lazy          as TL
import qualified Data.Text.Lazy.Builder  as TLB
import qualified Data.Text.Lazy.Encoding as TLE
import qualified Text.JSON as J

instance (NFData v) => NFData (J.JSObject v) where
  rnf o = rnf (J.fromJSObject o)

instance NFData J.JSValue where
  rnf J.JSNull = ()
  rnf (J.JSBool b) = rnf b
  rnf (J.JSRational a b) = rnf a `seq` rnf b `seq` ()
  rnf (J.JSString s) = rnf (J.fromJSString s)
  rnf (J.JSArray lst) = rnf lst
  rnf (J.JSObject o) = rnf o

decodeJ :: String -> J.JSValue
decodeJ s =
  case J.decodeStrict s of
    J.Ok v -> v
    J.Error _ -> error "fail to parse via JSON"

decodeA :: BL.ByteString -> A.Value
decodeA s = fromMaybe (error "fail to parse via Aeson") $ A.decode s

decodeA' :: BL.ByteString -> A.Value
decodeA' s = fromMaybe (error "fail to parse via Aeson") $ A.decode' s

decodeAS :: BS.ByteString -> A.Value
decodeAS s = fromMaybe (error "fail to parse via Aeson") $ A.decodeStrict' s

decodeB :: BL.ByteString -> B.Value
decodeB s = fromMaybe (error "fail to parse via Aeson") $ B.decode s

decodeBS :: BS.ByteString -> B.Value
decodeBS s = fromMaybe (error "fail to parse via Aeson") $ B.decodeStrict' s

decodeIP :: BL.ByteString -> A.Value
decodeIP s = fromMaybe (error "fail to parse via Parser.decodeWith") $
    I.decodeWith I.jsonEOF A.fromJSON s

encodeJ :: J.JSValue -> BL.ByteString
encodeJ = toLazyByteString . fromString . J.encode

encodeToText :: A.Value -> TL.Text
encodeToText = TLB.toLazyText . A.encodeToTextBuilder . A.toJSON

encodeViaText :: A.Value -> BL.ByteString
encodeViaText = TLE.encodeUtf8 . encodeToText

main :: IO ()
main = do
  let enFile = "json-data/twitter100.json"
      jpFile = "json-data/jp100.json"
  enA <- BL.readFile enFile
  enS <- BS.readFile enFile
  enJ <- readFile enFile
  jpA <- BL.readFile jpFile
  jpS <- BS.readFile jpFile
  jpJ <- readFile jpFile
  defaultMain [
      bgroup "decode" [
        bgroup "en" [
          bench "aeson/lazy"     $ nf decodeA enA
        , bench "aeson/strict"   $ nf decodeA' enA
        , bench "aeson/stricter" $ nf decodeAS enS
        , bench "aeson/hackage"  $ nf decodeB enA
        , bench "aeson/hackage'" $ nf decodeBS enS
        , bench "aeson/parser"   $ nf decodeIP enA
        , bench "json"           $ nf decodeJ enJ
        ]
      , bgroup "jp" [
          bench "aeson"          $ nf decodeA jpA
        , bench "aeson/stricter" $ nf decodeAS jpS
        , bench "aeson/hackage"  $ nf decodeB jpA
        , bench "json"           $ nf decodeJ jpJ
        ]
      ]
    , bgroup "encode" [
        bgroup "en" [
          bench "aeson-to-bytestring" $ nf A.encode (decodeA enA)
        , bench "aeson-via-text-to-bytestring" $ nf encodeViaText (decodeA enA)
        , bench "aeson-to-text" $ nf encodeToText (decodeA enA)
        , bench "json"  $ nf encodeJ (decodeJ enJ)
        ]
      , bgroup "jp" [
          bench "aeson-to-bytestring" $ nf A.encode (decodeA jpA)
        , bench "aeson-via-text-to-bytestring" $ nf encodeViaText (decodeA jpA)
        , bench "aeson-to-text" $ nf encodeToText (decodeA jpA)
        , bench "json"  $ nf encodeJ (decodeJ jpJ)
        ]
      ]
    ]