{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Main
  ( main,
  )
where

import Data.ByteString.Lazy.Internal (ByteString)
import Data.Morpheus.Core
  ( defaultConfig,
    parseRequest,
    parseRequestWith,
    parseSchema,
    render,
  )
import Data.Morpheus.Internal.Ext
  ( toEither,
  )
import Data.Morpheus.Types.IO (GQLRequest)
import Data.Morpheus.Types.Internal.AST (GQLError, Schema, VALID)
import Relude (Either, Functor (fmap), IO, NonEmpty, map, (.))
import Test.Morpheus
  ( FileUrl,
    cd,
    deepScan,
    mainTest,
    mkUrl,
    scan,
    testQuery,
    testQueryRendering,
    testQueryValidation,
    testSchema,
  )
import Test.Tasty
  ( TestTree,
  )

runQueryTest :: FileUrl -> TestTree
runQueryTest = testQuery (toEither . parseRequest)

runSchemaTest :: FileUrl -> TestTree
runSchemaTest = testSchema (toEither . parseSchema)

runRenderingTest :: FileUrl -> [FileUrl] -> [TestTree]
runRenderingTest url = map (testQueryRendering (parseQuery, toEither . parseSchema) url)

runQueryValidationTest :: FileUrl -> [FileUrl] -> [TestTree]
runQueryValidationTest url = map (testQueryValidation (parseQuery, toEither . parseSchema) url)

parseQuery :: Schema VALID -> GQLRequest -> Either (NonEmpty GQLError) ByteString
parseQuery schema =
  toEither
    . fmap render
    . parseRequestWith defaultConfig schema

main :: IO ()
main =
  mainTest
    "Core tests"
    [ scan runQueryTest (cd (mkUrl "query") "parsing"),
      scan runSchemaTest (mkUrl "schema"),
      deepScan runQueryValidationTest (cd (mkUrl "query") "validation"),
      deepScan runRenderingTest (mkUrl "rendering")
    ]