{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE NoPolyKinds #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}

module Repr.Tree.Read.Test where

import Test.Tasty
import Test.Tasty.HUnit
import Control.Monad (Monad(..))
import Control.Monad.IO.Class (MonadIO(..))
import Control.Applicative (Applicative(..), Const(..))
import Data.Bool (Bool(..))
import Data.Either (Either(..))
import Data.Eq (Eq(..))
import Data.Function (($), (.), id)
import Data.Functor (Functor(..), (<$>))
import Data.Monoid ((<>))
import Data.String (String)
import Data.Int (Int)
import Data.Text (Text)
import qualified Data.Text as Text
import Data.Text.Buildable (Buildable(..))
import Data.Text.Lazy.Builder as Build
import Text.Read (Read, reads)
import Text.Show (Show(..))
import Prelude (error, print, IO, undefined, succ)
import GHC.Prim (Constraint)
import Data.Proxy (Proxy(..))

import Hcompta.Expr.Lit
import Hcompta.Expr.Bool
import Hcompta.Expr.Fun
import Hcompta.Expr.Dup
import qualified Expr.Dup.Test as Dup
import Hcompta.Repr
import Hcompta.Type

tests :: TestTree
tests = testGroup "Read" $
	{-let (==>) (tree::Tree) expected@(text::Text) =
		fun_lit_bool_from (Proxy::Proxy (Type_Fun_Lit_Bool_End repr)) tree $ \ty repr ->
			case ty of
			 Type_Fun_Next (Type_Litkkk)
		case  of
		 Left err -> testCase (show expected) $ "" @?= "Error: " <> err
		 Right (expr_write {-`Dup` expr_meta-}) ->
			testGroup (show expected)
			 [ testCase "Text" $ Build.toLazyText (repr_text_write expr_write) @?= text
			 -- , testCase "Meta" $ repr_meta expr_meta >>= (@?= meta)
			 ] in
 [ Tree "And" [Tree "Bool" [Tree "True"], Tree "Bool" [Tree "False"]]
   ==> "True & False"
 ]-}
 []
{-
	let (==>) tree expected@(text, meta) =
		case fromTree tree of
		 Left err -> testCase (show expected) $ "" @?= "Error: " <> err
		 Right (expr_write `Dup` expr_meta) ->
			testGroup (show expected)
			 [ testCase "text" $ Build.toLazyText (repr_text_write expr_write) @?= text
			 , testCase "meta" $ repr_meta expr_meta >>= (@?= meta)
			 ] in
 [ testGroup "Dup"
	 [ Dup.e1 ==> ("True & !(True & True)", False)
	 -- , Dup.e2 ==> ("", False)
	 ]
 ]
-}