module Parser.Tests

import Core.Term
import Core.Check
import Core.Convert
import Core.Misc
import Core.Normalize
import Core.Value

import Control.Monad.RWS
import Control.Monad.Identity
import Control.Monad.Either

import Data.Fin

import Parser.Parse

%default total

convCheck : Term 0 -> Term 0 -> Either String (Bool, List String)
convCheck a b = resolve action
  where
    action : PI Bool
    action = do
      x <- eval ctx0 a
      y <- eval ctx0 b
      convert x y

{- λA. λx. x : ∏ (A : Type) → A → A -}
test_id : Either String (Bool, List String)
test_id = do
  ty <- parse0 "Π ( A : Type ) A → A"
  tr <- parse0 "λA.λx.x"
  typecheck tr ty

{- λA. λB. λf. λx. f x : ∏ (A : Type) ∏ (B : A → Type) ∏ (f : ∏ (x : A) B x) ∏ (x : A) B x -}
test_app : Either String (Bool, List String)
test_app = do
  ty <- parse0 "Π (A : Type) Π (B : A → Type) Π (f : Π (x : A) B x) Π (x : A) B x"
  tr <- parse0 "λA. λB. λf. λx. f x"
  typecheck tr ty

{- λf. f ≃ λf. λx. f x -}
eta_test : Either String (Bool, List String)
eta_test = do
  a <- parse0 "λf. f"
  b <- parse0 "λf. λx. f x"
  convCheck a b

additionty_test : Either String (Bool, List String)
additionty_test = do
  ty <- parse0 "ℕ → ℕ → ℕ"
  typecheck ty TType

addition_test : Either String (Bool, List String)
addition_test = do
  ty <- parse0 "ℕ → ℕ → ℕ"
  tr <- parse0 "ℕ-ind (λ_. ℕ → ℕ) (λx.x) (λn.λnp.λm. suc (np m))"
  typecheck tr ty

-- no, not that kind
unit_test : Either String (Bool, List String)
unit_test = do
  ty <- parse0 "⊤"
  tr <- parse0 "★"
  typecheck tr ty

absurd_test : Either String (Bool, List String)
absurd_test = do
  ty <- parse0 "Π(A : Type) ⊥ → A"
  tr <- parse0 "λA. ⊥-ind (λ_. A)"
  typecheck tr ty


pr1_test : Either String (Bool, List String)
pr1_test = do
  tr <- parse0 $ "let pr1 : Π (A : Type) Π (B : A → Type) (Σ (a : A) B a) → A"
                      ++ "≔ λA.λB. Σ-ind A B (λ_. A) (λa.λBa. a)"
                      ++ "in ★"
  typecheck tr TTop

pr1_pr2_test : Either String (Bool, List String)
pr1_pr2_test = do
  tr <- parse0 $ "let pr1 : Π (A : Type) Π (B : A → Type) (Σ (a : A) B a) → A"
                      ++ "≔ λA.λB. Σ-ind A B (λ_. A) (λa.λBa. a)"
                      ++ "in let pr2 : Π (A : Type) Π (B : A → Type) Π (s : Σ (a : A) B a) B (pr1 A B s)"
                      ++            "≔ λA.λB. Σ-ind A B (λs. B (pr1 A B s)) (λa.λBa. Ba)"
                      ++            "in ★"
  typecheck tr TTop