{-# LANGUAGE DataKinds #-} -- For using P.viewGrammar
{-# LANGUAGE FlexibleContexts #-} -- For using P.Grammar Char
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeApplications #-}
module Golden.Parser where

import Control.Monad (Monad(..))
import Data.Either (Either(..))
import Data.Function (($))
import Data.Functor ((<$>))
import Data.Int (Int)
import Data.Semigroup (Semigroup(..))
import Data.String (IsString(..))
import Data.Text.IO (readFile)
import Test.Tasty
import Test.Tasty.Golden
import Text.Show (Show(..))
import System.IO.Unsafe (unsafePerformIO)
import System.FilePath ((<.>), (</>), dropExtensions, takeBaseName)
import qualified Data.List as List
import qualified System.IO.Error as IO
import qualified System.Directory as IO
import qualified Control.Exception as IO

import Golden.Utils
import Parser

goldens :: TestTree
goldens = testGroup "Parser" $
  (\f -> List.zipWith f parsers [1::Int ..]) $ \(P p) g ->
  let parserDir = "test/Golden/Parser/G"<>show g in
  let inputs =
        ((parserDir </>) <$>) $
        List.sort $
        List.filter (List.isSuffixOf ".input.txt") $
        unsafePerformIO $
          IO.catchIOError
            (IO.listDirectory parserDir)
            (\exn ->
              if IO.isDoesNotExistError exn
              then return []
              else IO.throwIO exn
            ) in
  testGroup ("G"<>show g) $ (<$> inputs) $ \inp ->
    goldenVsStringDiff (takeBaseName (dropExtensions inp)) goldenDiff
      (dropExtensions inp<.>"expected.txt") $ do
      input <- readFile inp
      return $ fromString $
        case p input of
          Left err -> show err
          Right a -> show a