{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE TypeApplications #-}
module Golden.Splice where

import Data.Either (Either(..))
import Data.Function (($))
import Data.Functor ((<$>))
import Data.Int (Int)
import Data.Text (Text)
import Data.Semigroup (Semigroup(..))
import System.FilePath ((</>), (<.>))
import System.IO (IO)
import Test.Tasty
import Text.Show (Show(..))
import qualified Data.List as List
import qualified Language.Haskell.TH as TH
import qualified Language.Haskell.TH.Syntax as TH
import Symantic.Parser (ParsingError, optimizeMachine, generateCode)

--import Build_symantic_parser
import Golden.Splice.Utils
import qualified Grammar

goldens :: TestTree
goldens = testGroup "Splice" $
  {-[
    let spliceFile = "test/Golden/Splice/"</>"G"<>show g<.>"hs" in
    withResource
      (writeFile (rootDir</>spliceFile) $ List.unlines
        [ "module Golden.Splice.G"<>show g<>" where"
        , "import Data.Text (Text)"
        , "import qualified Symantic.Parser as P"
        , "import qualified Data.IORef as IORef"
        , "import qualified Language.Haskell.TH.Syntax as TH"
        , "import qualified Grammar"
        , ""
        , "splice = $$(TH.Code (do"
            -- This is for 'TH.Name's to match with the ones in
            -- 'viewGrammar' and 'viewMachine', which ease debugging.
        , "  TH.qRunIO (IORef.writeIORef TH.counter 0)"
        , "  TH.examineCode (P.runParser @Text Grammar.g"<>show g<>")"
        , "  ))"
        ])
      (\() -> do
        rmFile (rootDir</>spliceFile)
        rmFile (rootDir</>spliceFile-<.>"hi")
        rmFile (rootDir</>spliceFile-<.>"o")
        rmFile (rootDir</>spliceFile-<.>"p_hi")
        rmFile (rootDir</>spliceFile-<.>"p_o"))
      (\_io -> testSplice spliceFile)
  | g <- [1::Int .. List.length Grammar.grammars]
  ]-}
  [ coverSplice splice $ "test/Golden/Splice/"</>"G"<>show g<.>"expected"<.>"txt"
  | (g, S splice) <- List.zip [1::Int ..] splices
  ]

data S inp = forall a. S (IO (TH.TExp (inp -> Either (ParsingError inp) a)))
splices :: [S Text]
splices = (<$> Grammar.grammars) $ \(Grammar.G g) -> S $ TH.runQ $ do
  mach <- TH.qRunIO $ optimizeMachine g
  TH.examineCode $ generateCode mach