module Quox.Equal

import Quox.BoolExtra
import public Quox.Typing
import Data.Maybe
import Quox.EffExtra
import Quox.FreeVars

%default total


public export
EqModeState : Type -> Type
EqModeState = State EqMode

public export
Equal : List (Type -> Type)
Equal = [ErrorEff, DefsReader, NameGen]

public export
EqualInner : List (Type -> Type)
EqualInner = [ErrorEff, NameGen, EqModeState]


export %inline
mode : Has EqModeState fs => Eff fs EqMode
mode = get


parameters (loc : Loc) (ctx : EqContext n)
  private %inline
  clashT : Term 0 n -> Term 0 n -> Term 0 n -> Eff EqualInner a
  clashT ty s t = throw $ ClashT loc ctx !mode ty s t

  private %inline
  clashTy : Term 0 n -> Term 0 n -> Eff EqualInner a
  clashTy s t = throw $ ClashTy loc ctx !mode s t

  private %inline
  wrongType : Term 0 n -> Term 0 n -> Eff EqualInner a
  wrongType ty s = throw $ WrongType loc ctx ty s


public export %inline
sameTyCon : (s, t : Term d n) ->
            (0 ts : So (isTyConE s)) => (0 tt : So (isTyConE t)) =>
            Bool
sameTyCon (TYPE    {}) (TYPE    {}) = True
sameTyCon (TYPE    {}) _            = False
sameTyCon (IOState {}) (IOState {}) = True
sameTyCon (IOState {}) _            = False
sameTyCon (Pi      {}) (Pi      {}) = True
sameTyCon (Pi      {}) _            = False
sameTyCon (Sig     {}) (Sig     {}) = True
sameTyCon (Sig     {}) _            = False
sameTyCon (Enum    {}) (Enum    {}) = True
sameTyCon (Enum    {}) _            = False
sameTyCon (Eq      {}) (Eq      {}) = True
sameTyCon (Eq      {}) _            = False
sameTyCon (NAT     {}) (NAT     {}) = True
sameTyCon (NAT     {}) _            = False
sameTyCon (STRING  {}) (STRING  {}) = True
sameTyCon (STRING  {}) _            = False
sameTyCon (BOX     {}) (BOX     {}) = True
sameTyCon (BOX     {}) _            = False
sameTyCon (E       {}) (E       {}) = True
sameTyCon (E       {}) _            = False


||| true if a type is known to be empty.
|||
||| * a pair is empty if either element is.
||| * `{}` is empty.
||| * `[π.A]` is empty if `A` is.
||| * that's it.
public export covering
isEmpty : Definitions -> EqContext n -> SQty -> Term 0 n ->
          Eff EqualInner Bool
isEmpty defs ctx sg ty0 = do
  Element ty0 nc <- whnf defs ctx sg ty0.loc ty0
  let Left  y = choose $ isTyConE ty0
    | Right n => pure False
  case ty0 of
    TYPE {} => pure False
    IOState {} => pure False
    Pi {arg, res, _} => pure False
    Sig {fst, snd, _} =>
      isEmpty defs ctx sg fst `orM`
      isEmpty defs (extendTy0 snd.name fst ctx) sg snd.term
    Enum {cases, _} =>
      pure $ null cases
    Eq {} => pure False
    NAT {} => pure False
    STRING {} => pure False
    BOX {ty, _} => isEmpty defs ctx sg ty
    E _ => pure False

||| true if a type is known to be a subsingleton purely by its form.
||| a subsingleton is a type with only zero or one possible values.
||| equality/subtyping accepts immediately on values of subsingleton types.
|||
||| * a function type is a subsingleton if its codomain is,
|||   or if its domain is empty.
||| * a pair type is a subsingleton if both its elements are.
||| * equality types are subsingletons because of uip.
||| * an enum type is a subsingleton if it has zero or one tags.
||| * a box type is a subsingleton if its content is
public export covering
isSubSing : Definitions -> EqContext n -> SQty -> Term 0 n ->
            Eff EqualInner Bool
isSubSing defs ctx sg ty0 = do
  Element ty0 nc <- whnf defs ctx sg ty0.loc ty0
  let Left  y = choose $ isTyConE ty0
    | Right n => pure False
  case ty0 of
    TYPE {} => pure False
    IOState {} => pure False
    Pi {arg, res, _} =>
      isEmpty defs ctx sg arg `orM`
      isSubSing defs (extendTy0 res.name arg ctx) sg res.term
    Sig {fst, snd, _} =>
      isSubSing defs ctx sg fst `andM`
      isSubSing defs (extendTy0 snd.name fst ctx) sg snd.term
    Enum {cases, _} =>
      pure $ length (SortedSet.toList cases) <= 1
    Eq {} => pure True
    NAT {} => pure False
    STRING {} => pure False
    BOX {ty, _} => isSubSing defs ctx sg ty
    E _ => pure False


||| the left argument if the current mode is `Super`; otherwise the right one.
private %inline
bigger : Has EqModeState fs => (left, right : Lazy a) -> Eff fs a
bigger l r = gets $ \case Super => l; _ => r


export
ensureTyCon : Has ErrorEff fs =>
              (loc : Loc) -> (ctx : EqContext n) -> (t : Term 0 n) ->
              Eff fs (So (isTyConE t))
ensureTyCon loc ctx t = case nchoose $ isTyConE t of
  Left  y => pure y
  Right n => throw $ NotType loc (toTyContext ctx) (t // shift0 ctx.dimLen)


namespace Term
  ||| `compare0 ctx ty s t` compares `s` and `t` at type `ty`, according to
  ||| the current variance `mode`.
  |||
  ||| ⚠ **assumes that `s`, `t` have already been checked against `ty`**. ⚠
  export covering %inline
  compare0 : Definitions -> EqContext n -> SQty -> (ty, s, t : Term 0 n) ->
             Eff EqualInner ()

namespace Elim
  ||| compare two eliminations according to the given variance `mode`.
  |||
  ||| ⚠ **assumes that they have both been typechecked, and have
  ||| equal types.** ⚠
  export covering %inline
  compare0 : Definitions -> EqContext n -> SQty -> (e, f : Elim 0 n) ->
             Eff EqualInner (Term 0 n)

||| compares two types, using the current variance `mode` for universes.
||| fails if they are not types, even if they would happen to be equal.
export covering %inline
compareType : Definitions -> EqContext n -> (s, t : Term 0 n) ->
              Eff EqualInner ()


private
0 NotRedexEq : {isRedex : RedexTest tm} -> CanWhnf tm isRedex =>
               Definitions -> EqContext n -> SQty -> Pred (tm 0 n)
NotRedexEq defs ctx sg t = NotRedex defs (toWhnfContext ctx) sg t

namespace Term
  private covering
  compare0' : (defs : Definitions) -> (ctx : EqContext n) -> (sg : SQty) ->
              (ty, s, t : Term 0 n) ->
              (0 _ : NotRedexEq defs ctx SZero ty) =>
              (0 _ : So (isTyConE ty)) =>
              (0 _ : NotRedexEq defs ctx sg s) =>
              (0 _ : NotRedexEq defs ctx sg t) =>
              Eff EqualInner ()
  compare0' defs ctx sg (TYPE {}) s t = compareType defs ctx s t

  compare0' defs ctx sg ty@(IOState {}) s t =
    --   Γ ⊢ e = f ⇒ IOState
    -- ----------------------
    --   Γ ⊢ e = f ⇐ IOState
    --
    -- (no canonical values, ofc)
    case (s, t) of
      (E e, E f) => ignore $ Elim.compare0 defs ctx sg e f
      (E _, _)   => wrongType t.loc ctx ty t
      _          => wrongType s.loc ctx ty s

  compare0' defs ctx sg ty@(Pi {qty, arg, res, _}) s t = local_ Equal $
    --              Γ ⊢ A empty
    -- -------------------------------------------
    --  Γ ⊢ (λ x ⇒ s) = (λ x ⇒ t) ⇐ (π·x : A) → B
    if !(isEmpty defs ctx sg arg) then pure () else
    case (s, t) of
      --           Γ, x : A ⊢ s = t ⇐ B
      -- -------------------------------------------
      --  Γ ⊢ (λ x ⇒ s) = (λ x ⇒ t) ⇐ (π·x : A) → B
      (Lam b1 {}, Lam b2 {}) =>
        compare0 defs ctx' sg res.term b1.term b2.term

      --       Γ, x : A ⊢ s = e x ⇐ B
      -- -----------------------------------
      --  Γ ⊢ (λ x ⇒ s) = e ⇐ (π·x : A) → B
      (E e,      Lam b {}) => eta s.loc e b
      (Lam b {}, E e)      => eta s.loc e b

      (E e, E f) => ignore $ Elim.compare0 defs ctx sg e f

      (Lam {}, t) => wrongType t.loc ctx ty t
      (E _,    t) => wrongType t.loc ctx ty t
      (s,      _) => wrongType s.loc ctx ty s
  where
    ctx' : EqContext (S n)
    ctx' = extendTy qty res.name arg ctx

    toLamBody : Elim d n -> Term d (S n)
    toLamBody e = E $ App (weakE 1 e) (BVT 0 e.loc) e.loc

    eta : Loc -> Elim 0 n -> ScopeTerm 0 n -> Eff EqualInner ()
    eta loc e (S _ (N _)) = clashT loc ctx ty s t
    eta _   e (S _ (Y b)) = compare0 defs ctx' sg res.term (toLamBody e) b

  compare0' defs ctx sg ty@(Sig {fst, snd, _}) s t = local_ Equal $
    case (s, t) of
      --  Γ ⊢ s₁ = t₁ ⇐ A     Γ ⊢ s₂ = t₂ ⇐ B{s₁/x}
      -- --------------------------------------------
      --     Γ ⊢ (s₁, t₁) = (s₂,t₂) ⇐ (x : A) × B
      --
      -- [todo] η for π ≥ 0 maybe
      (Pair sFst sSnd {}, Pair tFst tSnd {}) => do
        compare0 defs ctx sg fst sFst tFst
        compare0 defs ctx sg (sub1 snd (Ann sFst fst fst.loc)) sSnd tSnd

      (E e, E f) => ignore $ Elim.compare0 defs ctx sg e f

      (E e,            Pair fst snd _) => eta s.loc e fst snd
      (Pair fst snd _, E f)            => eta s.loc f fst snd

      (Pair {}, t) => wrongType t.loc ctx ty t
      (E _,     t) => wrongType t.loc ctx ty t
      (s,       _) => wrongType s.loc ctx ty s
  where
    eta : Loc -> Elim 0 n -> Term 0 n -> Term 0 n -> Eff EqualInner ()
    eta loc e s t =
      case sg of
        SZero => do
          compare0 defs ctx sg fst                          (E $ Fst e e.loc) s
          compare0 defs ctx sg (sub1 snd (Ann s fst s.loc)) (E $ Snd e e.loc) t
        SOne => clashT loc ctx ty s t

  compare0' defs ctx sg ty@(Enum cases _) s t = local_ Equal $
    -- η for empty & singleton enums
    if length (SortedSet.toList cases) <= 1 then pure () else
    case (s, t) of
      -- --------------------
      --  Γ ⊢ 't = 't ⇐ {ts}
      --
      -- t ∈ ts is in the typechecker, not here, ofc
      (Tag t1 {}, Tag t2 {}) => unless (t1 == t2) $ clashT s.loc ctx ty s t
      (E e,       E f)       => ignore $ Elim.compare0 defs ctx sg e f

      (Tag {}, E _)    => clashT s.loc ctx ty s t
      (E _,    Tag {}) => clashT s.loc ctx ty s t

      (Tag {}, t) => wrongType t.loc ctx ty t
      (E _,    t) => wrongType t.loc ctx ty t
      (s,      _) => wrongType s.loc ctx ty s

  compare0' _ _ _ (Eq {}) _ _ =
    -- ✨ uip ✨
    --
    -- ----------------------------
    --  Γ ⊢ e = f ⇐ Eq [i ⇒ A] s t
    pure ()

  compare0' defs ctx sg nat@(NAT {}) s t = local_ Equal $
    case (s, t) of
      -- ---------------
      --  Γ ⊢ n = n ⇐ ℕ
      (Nat x {}, Nat y {}) => unless (x == y) $ clashT s.loc ctx nat s t

      --      Γ ⊢ s = t ⇐ ℕ
      -- -------------------------
      --  Γ ⊢ succ s = succ t ⇐ ℕ
      (Succ s'   {}, Succ t'   {}) => compare0 defs ctx sg nat s' t'
      (Nat (S x) {}, Succ t'   {}) => compare0 defs ctx sg nat (Nat x s.loc) t'
      (Succ s'   {}, Nat (S y) {}) => compare0 defs ctx sg nat s' (Nat y t.loc)

      (E e, E f) => ignore $ Elim.compare0 defs ctx sg e f

      (Nat 0 {}, Succ  {}) => clashT s.loc ctx nat s t
      (Nat 0 {}, E _)      => clashT s.loc ctx nat s t
      (Succ  {}, Nat 0 {}) => clashT s.loc ctx nat s t
      (Succ  {}, E _)      => clashT s.loc ctx nat s t
      (E _,      Nat 0 {}) => clashT s.loc ctx nat s t
      (E _,      Succ  {}) => clashT s.loc ctx nat s t

      (Nat  {}, t) => wrongType t.loc ctx nat t
      (Succ {}, t) => wrongType t.loc ctx nat t
      (E _,     t) => wrongType t.loc ctx nat t
      (s,       _) => wrongType s.loc ctx nat s

  compare0' defs ctx sg str@(STRING {}) s t = local_ Equal $
    case (s, t) of
      (Str x _, Str y _) => unless (x == y) $ clashT s.loc ctx str s t

      (E e, E f) => ignore $ Elim.compare0 defs ctx sg e f

      (Str {}, E _) => clashT s.loc ctx str s t
      (E _, Str {}) => clashT s.loc ctx str s t

      (Str {}, _) => wrongType t.loc ctx str t
      (E _,    _) => wrongType t.loc ctx str t
      _           => wrongType s.loc ctx str s

  compare0' defs ctx sg bty@(BOX q ty {}) s t = local_ Equal $
    case (s, t) of
      --     Γ ⊢ s = t ⇐ A
      -- -----------------------
      --  Γ ⊢ [s] = [t] ⇐ [π.A]
      (Box s _, Box t _) => compare0 defs ctx sg ty s t

      --   Γ ⊢ s = (case1 e return A of {[x] ⇒ x}) ⇐ A
      -- -----------------------------------------------
      --            Γ ⊢ [s] = e ⇐ [ρ.A]
      (Box s loc, E f)       => eta s f
      (E e,       Box t loc) => eta t e

      (E e, E f) => ignore $ Elim.compare0 defs ctx sg e f

      (Box {}, _) => wrongType t.loc ctx bty t
      (E   _,  _) => wrongType t.loc ctx bty t
      _           => wrongType s.loc ctx bty s
  where
    eta : Term 0 n -> Elim 0 n -> Eff EqualInner ()
    eta s e = do
      nm <- mnb "inner" e.loc
      let e = CaseBox One e (SN ty) (SY [< nm] (BVT 0 nm.loc)) e.loc
      compare0 defs ctx sg ty s (E e)

  compare0' defs ctx sg ty@(E _) s t = do
    -- a neutral type can only be inhabited by neutral values
    -- e.g. an abstract value in an abstract type, bound variables, …
    let E e = s | _ => wrongType s.loc ctx ty s
        E f = t | _ => wrongType t.loc ctx ty t
    ignore $ Elim.compare0 defs ctx sg e f


private covering
compareType' : (defs : Definitions) -> (ctx : EqContext n) ->
               (s, t : Term 0 n) ->
               (0 _ : NotRedexEq defs ctx SZero s) => (0 _ : So (isTyConE s)) =>
               (0 _ : NotRedexEq defs ctx SZero t) => (0 _ : So (isTyConE t)) =>
               (0 _ : So (sameTyCon s t)) =>
               Eff EqualInner ()
-- equality is the same as subtyping, except with the
-- "≤" in the TYPE rule being replaced with "="
compareType' defs ctx a@(TYPE k {}) (TYPE l {}) =
  --        𝓀 ≤ ℓ
  -- ----------------------
  --  Γ ⊢ Type 𝓀 <: Type ℓ
  expectModeU a.loc !mode k l

compareType' defs ctx a@(IOState {}) (IOState {}) =
  -- Γ ⊢ IOState <: IOState
  pure ()

compareType' defs ctx (Pi {qty = sQty, arg = sArg, res = sRes, loc})
                      (Pi {qty = tQty, arg = tArg, res = tRes, _}) = do
  --   Γ ⊢ A₁ :> A₂    Γ, x : A₁ ⊢ B₁ <: B₂
  -- ----------------------------------------
  --  Γ ⊢ (π·x : A₁) → B₁ <: (π·x : A₂) → B₂
  expectEqualQ loc sQty tQty
  local flip $ compareType defs ctx sArg tArg -- contra
  compareType defs (extendTy0 sRes.name sArg ctx) sRes.term tRes.term

compareType' defs ctx (Sig {fst = sFst, snd = sSnd, _})
                      (Sig {fst = tFst, snd = tSnd, _}) = do
  --  Γ ⊢ A₁ <: A₂    Γ, x : A₁ ⊢ B₁ <: B₂
  -- --------------------------------------
  --   Γ ⊢ (x : A₁) × B₁ <: (x : A₂) × B₂
  compareType defs ctx sFst tFst
  compareType defs (extendTy0 sSnd.name sFst ctx) sSnd.term tSnd.term

compareType' defs ctx (Eq {ty = sTy, l = sl, r = sr, _})
                      (Eq {ty = tTy, l = tl, r = tr, _}) = do
  --            Γ ⊢ A₁‹ε/i› <: A₂‹ε/i›
  --  Γ ⊢ l₁ = l₂ : A₁‹𝟎/i›    Γ ⊢ r₁ = r₂ : A₁‹𝟏/i›
  -- ------------------------------------------------
  --    Γ ⊢ Eq [i ⇒ A₁] l₁ r₂ <: Eq [i ⇒ A₂] l₂ r₂
  compareType defs (extendDim sTy.name Zero ctx) sTy.zero tTy.zero
  compareType defs (extendDim sTy.name One  ctx) sTy.one  tTy.one
  ty <- bigger sTy tTy
  local_ Equal $ do
    Term.compare0 defs ctx SZero ty.zero sl tl
    Term.compare0 defs ctx SZero ty.one  sr tr

compareType' defs ctx s@(Enum tags1 {}) t@(Enum tags2 {}) = do
  -- ------------------
  --  Γ ⊢ {ts} <: {ts}
  --
  -- no subtyping based on tag subsets, since that would need
  -- a runtime coercion
  unless (tags1 == tags2) $ clashTy s.loc ctx s t

compareType' defs ctx (NAT {}) (NAT {}) =
  -- ------------
  --  Γ ⊢ ℕ <: ℕ
  pure ()

compareType' defs ctx (STRING {}) (STRING {}) =
  -- ------------
  --  Γ ⊢ String <: String
  pure ()

compareType' defs ctx (BOX pi a loc) (BOX rh b {}) = do
  expectEqualQ loc pi rh
  compareType defs ctx a b

compareType' defs ctx (E e) (E f) = do
  -- no fanciness needed here cos anything other than a neutral
  -- has been inlined by whnf
  ignore $ Elim.compare0 defs ctx SZero e f


private
lookupFree : Has ErrorEff fs =>
             Definitions -> EqContext n -> Name -> Universe -> Loc ->
             Eff fs (Term 0 n)
lookupFree defs ctx x u loc =
  case lookup x defs of
    Nothing => throw $ NotInScope loc x
    Just d  => pure $ d.typeWithAt [|Z|] ctx.termLen u


export
typecaseTel : (k : TyConKind) -> BContext (arity k) -> Universe ->
              CtxExtension d n (arity k + n)
typecaseTel k xs u = case k of
  KTYPE => [<]
  KIOState => [<]
  -- A : ★ᵤ, B : 0.A → ★ᵤ
  KPi =>
    let [< a, b] = xs in
    [< (Zero, a, TYPE u a.loc),
       (Zero, b, Arr Zero (BVT 0 b.loc) (TYPE u b.loc) b.loc)]
  KSig =>
    let [< a, b] = xs in
    [< (Zero, a, TYPE u a.loc),
       (Zero, b, Arr Zero (BVT 0 b.loc) (TYPE u b.loc) b.loc)]
  KEnum => [<]
  -- A₀ : ★ᵤ, A₁ : ★ᵤ, A : (A₀ ≡ A₁ : ★ᵤ), L : A₀, R : A₀
  KEq =>
    let [< a0, a1, a, l, r] = xs in
    [< (Zero, a0, TYPE u a0.loc),
       (Zero, a1, TYPE u a1.loc),
       (Zero, a,  Eq0 (TYPE u a.loc) (BVT 1 a.loc) (BVT 0 a.loc) a.loc),
       (Zero, l,  BVT 2 l.loc),
       (Zero, r,  BVT 2 r.loc)]
  KNat => [<]
  KString => [<]
  -- A : ★ᵤ
  KBOX => let [< a] = xs in [< (Zero, a, TYPE u a.loc)]


namespace Elim
  private data InnerErr : Type where

  private
  InnerErrEff : Type -> Type
  InnerErrEff = StateL InnerErr (Maybe Error)

  private
  EqualElim : List (Type -> Type)
  EqualElim = InnerErrEff :: EqualInner

  private covering
  computeElimTypeE : (defs : Definitions) -> (ctx : EqContext n) ->
                     (sg : SQty) ->
                     (e : Elim 0 n) -> (0 ne : NotRedexEq defs ctx sg e) =>
                     Eff EqualElim (Term 0 n)
  computeElimTypeE defs ectx sg e = lift $
    computeElimType defs (toWhnfContext ectx) sg e

  private
  putError : Has InnerErrEff fs => Error -> Eff fs ()
  putError err = modifyAt InnerErr (<|> Just err)

  private
  try : Eff EqualInner () -> Eff EqualElim ()
  try act = lift $ catch putError $ lift act {fs' = EqualElim}

  private covering %inline
  clashE : (defs : Definitions) -> (ctx : EqContext n) -> (sg : SQty) ->
           (e, f : Elim 0 n) -> (0 nf : NotRedexEq defs ctx sg f) =>
           Eff EqualElim (Term 0 n)
  clashE defs ctx sg e f = do
    putError $ ClashE e.loc ctx !mode e f
    computeElimTypeE defs ctx sg f


  ||| compare two type-case branches, which came from the arms of the given
  ||| kind. `ret` is the return type of the case expression, and `u` is the
  ||| universe the head is in.
  private covering
  compareArm : Definitions -> EqContext n -> (k : TyConKind) ->
               (ret : Term 0 n) -> (u : Universe) ->
               (b1, b2 : Maybe (TypeCaseArmBody k 0 n)) ->
               (def : Term 0 n) ->
               Eff EqualElim ()
  compareArm {b1 = Nothing, b2 = Nothing, _} = pure ()
  compareArm defs ctx k ret u b1 b2 def = do
    let def   = SN def
        left  = fromMaybe def b1; right = fromMaybe def b2
        names = (fromMaybe def $ b1 <|> b2).names
    try $ compare0 defs (extendTyN (typecaseTel k names u) ctx)
                   SZero (weakT (arity k) ret) left.term right.term

  private covering
  compare0Inner : Definitions -> EqContext n -> (sg : SQty) ->
                  (e, f : Elim 0 n) -> Eff EqualElim (Term 0 n)

  private covering
  compare0Inner' : (defs : Definitions) -> (ctx : EqContext n) -> (sg : SQty) ->
                   (e, f : Elim 0 n) ->
                   (0 ne : NotRedexEq defs ctx sg e) ->
                   (0 nf : NotRedexEq defs ctx sg f) ->
                   Eff EqualElim (Term 0 n)

  compare0Inner' defs ctx sg e@(F {}) f _ _ = do
    if e == f then computeElimTypeE defs ctx sg f
              else clashE defs ctx sg e f

  compare0Inner' defs ctx sg e@(B {}) f _ _ = do
    if e == f then computeElimTypeE defs ctx sg f
              else clashE defs ctx sg e f

  --  Ψ | Γ ⊢ e = f ⇒ π.(x : A) → B
  --  Ψ | Γ ⊢ s = t ⇐ A
  -- -------------------------------
  --  Ψ | Γ ⊢ e s = f t ⇒ B[s∷A/x]
  compare0Inner' defs ctx sg (App e s eloc) (App f t floc) ne nf = do
    ety <- compare0Inner defs ctx sg e f
    (_, arg, res) <- expectPi defs ctx sg eloc ety
    try $ Term.compare0 defs ctx sg arg s t
    pure $ sub1 res $ Ann s arg s.loc
  compare0Inner' defs ctx sg e'@(App {}) f' ne nf =
    clashE defs ctx sg e' f'

  --  Ψ | Γ ⊢ e = f ⇒ (x : A) × B
  --  Ψ | Γ, 0.p : (x : A) × B ⊢ Q = R
  --  Ψ | Γ, x : A, y : B ⊢ s = t ⇐ Q[((x, y) ∷ (x : A) × B)/p]
  -- -----------------------------------------------------------
  --    Ψ | Γ ⊢ caseπ e return Q of { (x, y) ⇒ s }
  --          = caseπ f return R of { (x, y) ⇒ t } ⇒ Q[e/p]
  compare0Inner' defs ctx sg (CasePair epi e eret ebody eloc)
                             (CasePair fpi f fret fbody floc) ne nf =
    local_ Equal $ do
      ety <- compare0Inner defs ctx sg e f
      (fst, snd) <- expectSig defs ctx sg eloc ety
      let [< x, y] = ebody.names
      try $ do
        compareType defs (extendTy0 eret.name ety ctx) eret.term fret.term
        Term.compare0 defs
          (extendTyN [< (epi, x, fst), (epi, y, snd.term)] ctx) sg
          (substCasePairRet ebody.names ety eret)
          ebody.term fbody.term
        expectEqualQ e.loc epi fpi
      pure $ sub1 eret e
  compare0Inner' defs ctx sg e'@(CasePair {}) f' ne nf =
    clashE defs ctx sg e' f'

  --  Ψ | Γ ⊢ e = f ⇒ (x : A) × B
  -- ------------------------------
  --  Ψ | Γ ⊢ fst e = fst f ⇒ A
  compare0Inner' defs ctx sg (Fst e eloc) (Fst f floc) ne nf =
    local_ Equal $ do
      ety <- compare0Inner defs ctx sg e f
      fst <$> expectSig defs ctx sg eloc ety
  compare0Inner' defs ctx sg e@(Fst {}) f _ _ =
    clashE defs ctx sg e f

  --  Ψ | Γ ⊢ e = f ⇒ (x : A) × B
  -- ------------------------------------
  --  Ψ | Γ ⊢ snd e = snd f ⇒ B[fst e/x]
  compare0Inner' defs ctx sg (Snd e eloc) (Snd f floc) ne nf =
    local_ Equal $ do
      ety <- compare0Inner defs ctx sg e f
      (_, tsnd) <- expectSig defs ctx sg eloc ety
      pure $ sub1 tsnd (Fst e eloc)
  compare0Inner' defs ctx sg e@(Snd {}) f _ _ =
    clashE defs ctx sg e f

  --  Ψ | Γ ⊢ e = f ⇒ {𝐚s}
  --  Ψ | Γ, x : {𝐚s} ⊢ Q = R
  --  Ψ | Γ ⊢ sᵢ = tᵢ ⇐ Q[𝐚ᵢ∷{𝐚s}]
  -- --------------------------------------------------
  --  Ψ | Γ ⊢ caseπ e return Q of { '𝐚ᵢ ⇒ sᵢ }
  --        = caseπ f return R of { '𝐚ᵢ ⇒ tᵢ } ⇒ Q[e/x]
  compare0Inner' defs ctx sg (CaseEnum epi e eret earms eloc)
                             (CaseEnum fpi f fret farms floc) ne nf =
    local_ Equal $ do
      ety <- compare0Inner defs ctx sg e f
      try $
        compareType defs (extendTy0 eret.name ety ctx) eret.term fret.term
      for_ (SortedMap.toList earms) $ \(t, l) => do
        let Just r = lookup t farms
          | Nothing => putError $ TagNotIn floc t (fromList $ keys farms)
        let t' = Ann (Tag t l.loc) ety l.loc
        try $ Term.compare0 defs ctx sg (sub1 eret t') l r
      try $ expectEqualQ eloc epi fpi
      pure $ sub1 eret e
  compare0Inner' defs ctx sg e@(CaseEnum {}) f _ _ = clashE defs ctx sg e f

  --  Ψ | Γ ⊢ e = f ⇒ ℕ
  --  Ψ | Γ, x : ℕ ⊢ Q = R
  --  Ψ | Γ ⊢ s₀ = t₀ ⇐ Q[(0 ∷ ℕ)/x]
  --  Ψ | Γ, x : ℕ, y : Q ⊢ s₁ = t₁ ⇐ Q[(succ x ∷ ℕ)/x]
  -- -----------------------------------------------------
  --  Ψ | Γ ⊢ caseπ e return Q of { 0 ⇒ s₀; x, π.y ⇒ s₁ }
  --        = caseπ f return R of { 0 ⇒ t₀; x, π.y ⇒ t₁ }
  --        ⇒ Q[e/x]
  compare0Inner' defs ctx sg (CaseNat epi epi' e eret ezer esuc eloc)
                             (CaseNat fpi fpi' f fret fzer fsuc floc) ne nf =
    local_ Equal $ do
      ety <- compare0Inner defs ctx sg e f
      let [< p, ih] = esuc.names
      try $ do
        compareType defs (extendTy0 eret.name ety ctx) eret.term fret.term
        Term.compare0 defs ctx sg
          (sub1 eret (Ann (Zero ezer.loc) (NAT ezer.loc) ezer.loc))
          ezer fzer
        Term.compare0 defs
          (extendTyN [< (epi, p, NAT p.loc), (epi', ih, eret.term)] ctx) sg
          (substCaseSuccRet esuc.names eret) esuc.term fsuc.term
        expectEqualQ e.loc epi  fpi
        expectEqualQ e.loc epi' fpi'
      pure $ sub1 eret e
  compare0Inner' defs ctx sg e@(CaseNat {}) f _ _ = clashE defs ctx sg e f

  --  Ψ | Γ ⊢ e = f ⇒ [ρ. A]
  --  Ψ | Γ, x : [ρ. A] ⊢ Q = R
  --  Ψ | Γ, x : A ⊢ s = t ⇐ Q[([x] ∷ [ρ. A])/x]
  -- --------------------------------------------------
  --  Ψ | Γ ⊢ caseπ e return Q of { [x] ⇒ s }
  --        = caseπ f return R of { [x] ⇒ t } ⇒ Q[e/x]
  compare0Inner' defs ctx sg (CaseBox epi e eret ebody eloc)
                             (CaseBox fpi f fret fbody floc) ne nf =
    local_ Equal $ do
      ety <- compare0Inner defs ctx sg e f
      (q, ty) <- expectBOX defs ctx sg eloc ety
      try $ do
        compareType defs (extendTy0 eret.name ety ctx) eret.term fret.term
        Term.compare0 defs (extendTy (epi * q) ebody.name ty ctx) sg
          (substCaseBoxRet ebody.name ety eret)
          ebody.term fbody.term
        expectEqualQ eloc epi fpi
      pure $ sub1 eret e
  compare0Inner' defs ctx sg e@(CaseBox {}) f _ _ = clashE defs ctx sg e f

  -- (no neutral dim apps in a closed dctx)
  compare0Inner' _ _ _ (DApp _ (K {}) _) _ ne _ =
    void $ absurd $ noOr2 $ noOr2 ne
  compare0Inner' _ _ _ _ (DApp _ (K {}) _) _ nf =
    void $ absurd $ noOr2 $ noOr2 nf

  --  Ψ | Γ ⊢ s <: t : B
  -- --------------------------------
  --  Ψ | Γ ⊢ (s ∷ A) <: (t ∷ B) ⇒ B
  --
  -- and similar for :> and A
  compare0Inner' defs ctx sg (Ann s a _) (Ann t b _) _ _ = do
    ty <- bigger a b
    try $ Term.compare0 defs ctx sg ty s t
    pure ty

  --  Ψ | Γ ⊢ A‹p₁/𝑖› <: B‹p₂/𝑖›
  --  Ψ | Γ ⊢ A‹q₁/𝑖› <: B‹q₂/𝑖›
  --  Ψ | Γ ⊢ s <: t ⇐ B‹p₂/𝑖›
  -- -----------------------------------------------------------
  --  Ψ | Γ ⊢ coe [𝑖 ⇒ A] @p₁ @q₁ s
  --       <: coe [𝑖 ⇒ B] @p₂ @q₂ t ⇒ B‹q₂/𝑖›
  compare0Inner' defs ctx sg (Coe ty1 p1 q1 val1 _)
                             (Coe ty2 p2 q2 val2 _) ne nf = do
    let ty1p = dsub1 ty1 p1; ty2p = dsub1 ty2 p2
        ty1q = dsub1 ty1 q1; ty2q = dsub1 ty2 q2
    (ty_p, ty_q) <- bigger (ty1p, ty1q) (ty2p, ty2q)
    try $ do
      compareType defs ctx ty1p ty2p
      compareType defs ctx ty1q ty2q
      Term.compare0 defs ctx sg ty_p val1 val2
    pure $ ty_q
  compare0Inner' defs ctx sg e@(Coe {}) f _ _ = clashE defs ctx sg e f

  -- (no neutral compositions in a closed dctx)
  compare0Inner' _ _ _ (Comp {r = K {}, _}) _ ne _ = void $ absurd $ noOr2 ne
  compare0Inner' _ _ _ (Comp {r = B i _, _}) _ _ _ = absurd i
  compare0Inner' _ _ _ _ (Comp {r = K {}, _}) _ nf = void $ absurd $ noOr2 nf

  -- (type case equality purely structural)
  compare0Inner' defs ctx sg (TypeCase ty1 ret1 arms1 def1 eloc)
                             (TypeCase ty2 ret2 arms2 def2 floc) ne _ =
    case sg `decEq` SZero of
      Yes Refl => local_ Equal $ do
        ety <- compare0Inner defs ctx SZero ty1 ty2
        u   <- expectTYPE defs ctx SZero eloc ety
        try $ do
          compareType defs ctx ret1 ret2
          compareType defs ctx def1 def2
        for_ allKinds $ \k =>
          compareArm defs ctx k ret1 u
            (lookupPrecise k arms1) (lookupPrecise k arms2) def1
        pure ret1
      No _ => do
        putError $ ClashQ eloc sg.qty Zero
        computeElimTypeE defs ctx sg $ TypeCase ty1 ret1 arms1 def1 eloc
  compare0Inner' defs ctx sg e@(TypeCase {}) f _ _ = clashE defs ctx sg e f

  --     Ψ | Γ ⊢ s <: f ⇐ A
  -- --------------------------
  --  Ψ | Γ ⊢ (s ∷ A) <: f ⇒ A
  --
  -- and vice versa
  compare0Inner' defs ctx sg (Ann s a _) f _ _ = do
    try $ Term.compare0 defs ctx sg a s (E f)
    pure a
  compare0Inner' defs ctx sg e (Ann t b _) _ _ = do
    try $ Term.compare0 defs ctx sg b (E e) t
    pure b
  compare0Inner' defs ctx sg e@(Ann {}) f _ _ =
    clashE defs ctx sg e f

  compare0Inner defs ctx sg e f = do
    Element e ne <- whnf defs ctx sg e.loc e
    Element f nf <- whnf defs ctx sg f.loc f
    ty <- compare0Inner' defs ctx sg e f ne nf
    if !(lift $ isSubSing defs ctx sg ty) && isJust !(getAt InnerErr)
       then putAt InnerErr Nothing
       else modifyAt InnerErr $ map $ WhileComparingE ctx !mode sg e f
    pure ty


namespace Term
  compare0 defs ctx sg ty s t =
    wrapErr (WhileComparingT ctx !mode sg ty s t) $ do
      Element ty' _ <- whnf defs ctx SZero ty.loc ty
      Element s'  _ <- whnf defs ctx sg s.loc  s
      Element t'  _ <- whnf defs ctx sg t.loc  t
      tty <- ensureTyCon ty.loc ctx ty'
      compare0' defs ctx sg ty' s' t'

namespace Elim
  compare0 defs ctx sg e f = do
    (ty, err) <- runStateAt InnerErr Nothing $ compare0Inner defs ctx sg e f
    maybe (pure ty) throw err

compareType defs ctx s t = do
  Element s' _ <- whnf defs ctx SZero s.loc s
  Element t' _ <- whnf defs ctx SZero t.loc t
  ts <- ensureTyCon s.loc ctx s'
  tt <- ensureTyCon t.loc ctx t'
  st <- either pure (const $ clashTy s.loc ctx s' t') $
        nchoose $ sameTyCon s' t'
  compareType' defs ctx s' t'


parameters (loc : Loc) (ctx : TyContext d n)
  parameters (mode : EqMode)
    private
    fromInner : Eff EqualInner a -> Eff Equal a
    fromInner = lift . map fst . runState mode

    private
    eachFace : Applicative f => FreeVars d ->
               (EqContext n -> DSubst d 0 -> f ()) -> f ()
    eachFace fvs act =
      for_ (splits loc ctx.dctx fvs) $ \th =>
        act (makeEqContext ctx th) th

    private
    CompareAction : Nat -> Nat -> Type
    CompareAction d n =
      Definitions -> EqContext n -> DSubst d 0 -> Eff EqualInner ()

    private
    runCompare : FreeVars d -> CompareAction d n -> Eff Equal ()
    runCompare fvs act = fromInner $ eachFace fvs $ act !(askAt DEFS)

    private
    fdvAll : HasFreeDVars t => List (t d n) -> FreeVars d
    fdvAll = let Val d = ctx.dimLen in foldMap (fdvWith [|d|] ctx.termLen)

    namespace Term
      export covering
      compare : SQty -> (ty, s, t : Term d n) -> Eff Equal ()
      compare sg ty s t = runCompare (fdvAll [ty, s, t]) $ \defs, ectx, th =>
        compare0 defs ectx sg (ty // th) (s // th) (t // th)

      export covering
      compareType : (s, t : Term d n) -> Eff Equal ()
      compareType s t = runCompare (fdvAll [s, t]) $ \defs, ectx, th =>
        compareType defs ectx (s // th) (t // th)

    namespace Elim
      ||| you don't have to pass the type in but the arguments must still be
      ||| of the same type!!
      export covering
      compare : SQty -> (e, f : Elim d n) -> Eff Equal ()
      compare sg e f = runCompare (fdvAll [e, f]) $ \defs, ectx, th =>
        ignore $ compare0 defs ectx sg (e // th) (f // th)

  namespace Term
    export covering %inline
    equal, sub, super : SQty -> (ty, s, t : Term d n) -> Eff Equal ()
    equal = compare Equal
    sub   = compare Sub
    super = compare Super

    export covering %inline
    equalType, subtype, supertype : (s, t : Term d n) -> Eff Equal ()
    equalType = compareType Equal
    subtype   = compareType Sub
    supertype = compareType Super

  namespace Elim
    export covering %inline
    equal, sub, super : SQty -> (e, f : Elim d n) -> Eff Equal ()
    equal = compare Equal
    sub   = compare Sub
    super = compare Super