{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeApplications #-}
module Golden where

import Control.Arrow (left)
import Control.Monad (Monad(..))
import Data.Either (Either(..))
import Data.Function (($), (.))
import Data.Functor ((<$>))
import Data.Locale
import Data.Semigroup (Semigroup(..))
import Data.String (String)
import System.FilePath (FilePath)
import System.IO (IO)
import Text.Show (Show(..))
import qualified Data.ByteString.Lazy as BSL
import qualified Data.List as List
import qualified Data.Map.Strict as Map
import qualified Data.Text as Text
import qualified Data.Text.Lazy          as TL
import qualified Data.Text.Lazy.Encoding as TL
import qualified Data.TreeSeq.Strict as TreeSeq
import qualified Text.Blaze.Html.Renderer.Utf8 as Blaze
import qualified Text.Megaparsec as P

import Test.Tasty
import Test.Tasty.Golden

-- * Golden testing utilities
testGolden :: TestName -> TestName -> IO (Either String BSL.ByteString) -> TestTree
testGolden inputFile expectedExt =
	goldenVsStringDiff inputFile diffGolden (inputFile <> expectedExt)
	 . (>>= unLeft)

diffGolden :: FilePath -> FilePath -> [String]
diffGolden ref new = ["diff", "-u", ref, new]

unLeft :: Either String BSL.ByteString -> IO BSL.ByteString
unLeft = \case
 Left err -> return $ TL.encodeUtf8 $ TL.pack err
 Right a  -> return a

-- * All golden tests
goldensIO :: IO TestTree
goldensIO = do
	inputFiles <- List.sort <$> findByExtension [".args"] "test/Golden"
	return $
		testGroup "Args"
		 [ goldensRead inputFiles
		 ]

-- * Tests
readArgs :: FilePath -> IO (Either String [String])
readArgs inputFile =
	Right .
	List.lines .
	TL.unpack .
	TL.decodeUtf8 <$>
	BSL.readFile inputFile

goldensRead :: [FilePath] -> TestTree
goldensRead inputFiles =
	testGroup "Read"
	 [ testGolden inputFile ".args.read" $
		readArgs inputFile >>= \args ->
			return $
				TL.encodeUtf8
				 . TL.pack
				 . TCT.runPretty 0
				 <$> args
	 | inputFile <- inputFiles
	 ]