module Quox.Parser.Parser

import public Quox.Parser.Lexer
import public Quox.Parser.Syntax

import Data.Bool
import Data.Fin
import Data.Vect
import public Text.Parser
import Derive.Prelude

%language ElabReflection
%default total


public export
0 Grammar : Bool -> Type -> Type
Grammar = Core.Grammar () Token
%hide Core.Grammar


public export
data Error =
    LexError   Lexer.Error
  | ParseError (List1 (ParsingError Token))
%hide Lexer.Error
%runElab derive "Error" [Show]


export
lexParseWith : {c : Bool} -> Grammar c a -> String -> Either Error a
lexParseWith grm input = do
  toks <- mapFst LexError $ lex input
  bimap ParseError fst $ parse (grm <* eof) toks

export
withLoc : {c : Bool} -> FileName -> (Grammar c (Loc -> a)) -> Grammar c a
withLoc fname act = bounds act <&> \res =>
  if res.isIrrelevant then res.val noLoc
  else res.val $ makeLoc fname res.bounds

export
defLoc : FileName -> (Loc -> a) -> Grammar False a
defLoc fname f = position <&> f . makeLoc fname

export
unused : FileName -> Grammar False PatVar
unused fname = defLoc fname Unused


||| reserved token, like punctuation or keywords etc
export
res : (str : String) -> (0 _ : IsReserved str) => Grammar True ()
res str = terminal "expected \"\{str}\"" $ guard . (== Reserved str)

||| optional reserved token, e.g. trailing comma
export
optRes : (str : String) -> (0 _ : IsReserved str) => Grammar False ()
optRes str = ignore $ optional $ res str

||| reserved token, then commit
export
resC : (str : String) -> (0 _ : IsReserved str) => Grammar True ()
resC str = do res str; commit

||| reserved token or fatal error
export
needRes : (str : String) -> (0 _ : IsReserved str) => Grammar True ()
needRes str = resC str <|> fatalError "expected \"\{str}\""


private
terminalMatchN_ : String -> List (TTImp, TTImp) -> Elab (Grammar True a)
terminalMatchN_ what matches = do
  func <- check $ lam (lambdaArg `{x}) $
    iCase `(x) implicitFalse $
    map (\(l, r) => patClause l `(Just ~(r))) matches ++
      [patClause `(_) `(Nothing)]
  pure $ terminal "expected \{what}" func

private %macro
terminalMatchN : String -> List (TTImp, TTImp) -> Elab (Grammar True a)
terminalMatchN = terminalMatchN_

private %macro
terminalMatch : String -> TTImp -> TTImp -> Elab (Grammar True a)
terminalMatch what l r = terminalMatchN_ what [(l, r)]

||| tag without leading `'`
export
bareTag : Grammar True TagVal
bareTag = terminalMatchN "bare tag"
  [(`(Name t), `(toDotsP t)), (`(Str s), `(s))]

||| tag with leading quote
export
tag : Grammar True TagVal
tag = terminalMatch "tag" `(Tag t) `(t)

||| natural number
export
nat : Grammar True Nat
nat = terminalMatch "natural number" `(Nat n) `(n)

||| string literal
export
strLit : Grammar True String
strLit = terminalMatch "string literal" `(Str s) `(s)

||| single-token universe, like ★0 or Type1
export
universeTok : Grammar True Universe
universeTok = terminalMatch "universe" `(TYPE u) `(u)

export
super : Grammar True Nat
super = terminalMatch "superscript number or '^'" `(Sup n) `(n)

||| possibly-qualified name
export
qname : Grammar True PName
qname = terminalMatch "name" `(Name n) `(n)

||| unqualified name
export
baseName : Grammar True PBaseName
baseName = terminalMatch "unqualified name" `(Name (MakePName [<] b)) `(b)

||| dimension constant (0 or 1)
export
dimConst : Grammar True DimConst
dimConst = terminalMatchN "dimension constant"
  [(`(Nat 0), `(Zero)), (`(Nat 1), `(One))]

||| quantity (0, 1, or ω)
export
qtyVal : Grammar True Qty
qtyVal = terminalMatchN "quantity"
  [(`(Nat 0), `(Zero)), (`(Nat 1), `(One)), (`(Reserved "ω"), `(Any))]


||| optional superscript number
export
displacement : Grammar False (Maybe Universe)
displacement = optional super

||| quantity (0, 1, or ω)
export
qty : FileName -> Grammar True PQty
qty fname = withLoc fname [|PQ qtyVal|]

export
exactName : String -> Grammar True ()
exactName name = terminal "expected '\{name}'" $ \case
  Name (MakePName [<] x) => guard $ x == name
  _                      => Nothing


||| pattern var (unqualified name or _)
export
patVar : FileName -> Grammar True PatVar
patVar fname = withLoc fname $
  [|PV baseName|] <|> Unused <$ res "_"


||| dimension (without `@` prefix)
export
dim : FileName -> Grammar True PDim
dim fname = withLoc fname $ [|K dimConst|] <|> [|V baseName|]

||| dimension argument (with @)
export
dimArg : FileName -> Grammar True PDim
dimArg fname = do resC "@"; mustWork $ dim fname


delim : (o, c : String) -> (0 _ : IsReserved o) => (0 _ : IsReserved c) =>
        {k : Bool} -> Grammar k a -> Grammar True a
delim o c p = resC o *> p <* needRes c

-- this stuff is Like This (rather than just being delim + sepEndBy{1})
-- so that it checks for the close bracket before trying another list element,
-- giving (imo) a better error
parameters (o, c, s : String)
           {auto 0 _ : IsReserved o} {auto 0 _ : IsReserved c}
           {auto 0 _ : IsReserved s}
           (p : Grammar True a)
  private
  dsBeforeDelim, dsAfterDelim : Grammar True (List a)
  dsBeforeDelim = [] <$ resC c <|> resC s *> assert_total dsAfterDelim
  dsAfterDelim  = [] <$ resC c <|> [|p :: assert_total dsBeforeDelim|]

  export
  delimSep1 : Grammar True (List1 a)
  delimSep1 = resC o *> [|p ::: dsBeforeDelim|]

  export
  delimSep : Grammar True (List a)
  delimSep = resC o *> dsAfterDelim


||| enum type, e.g. `{a, b, c.d, "e f g"}`
export
enumType : Grammar True (List TagVal)
enumType = delimSep "{" "}" "," bareTag

||| e.g. `case1` or `case 1.`
export
caseIntro : FileName -> Grammar True PQty
caseIntro fname =
      withLoc fname (PQ Zero <$ res "case0")
  <|> withLoc fname (PQ One  <$ res "case1")
  <|> withLoc fname (PQ Any  <$ res "caseω")
  <|> do resC "case"
         qty fname <* needRes "." <|> defLoc fname (PQ One)

export
qtyPatVar : FileName -> Grammar True (PQty, PatVar)
qtyPatVar fname =
      [|(,) (qty fname) (needRes "." *> patVar fname)|]
  <|> [|(,) (defLoc fname $ PQ One) (patVar fname)|]


export
ptag : FileName -> Grammar True PTagVal
ptag fname = withLoc fname $ [|PT tag|]

public export
data PCasePat =
    PPair PatVar PatVar Loc
  | PTag  PTagVal Loc
  | PZero Loc
  | PSucc PatVar PQty PatVar Loc
  | PBox  PatVar Loc
%runElab derive "PCasePat" [Eq, Ord, Show]

export
Located PCasePat where
  (PPair _ _   loc).loc = loc
  (PTag  _     loc).loc = loc
  (PZero       loc).loc = loc
  (PSucc _ _ _ loc).loc = loc
  (PBox  _     loc).loc = loc

||| either `zero` or `0`
export
zeroPat : Grammar True ()
zeroPat = resC "zero" <|> terminal "expected '0'" (guard . (== Nat 0))

export
casePat : FileName -> Grammar True PCasePat
casePat fname = withLoc fname $
      delim "(" ")" [|PPair (patVar fname) (needRes "," *> patVar fname)|]
  <|> [|PTag (ptag fname)|]
  <|> PZero <$ zeroPat
  <|> do p  <- resC "succ" *> patVar fname
         ih <- resC "," *> qtyPatVar fname
           <|> [|(,) (defLoc fname $ PQ Zero) (unused fname)|]
         pure $ PSucc p (fst ih) (snd ih)
  <|> delim "[" "]" [|PBox (patVar fname)|]
  <|> fatalError "invalid pattern"

export
term : FileName -> Grammar True PTerm
-- defined after all the subterm parsers

||| box term `[t]` or type `[π.A]`
export
boxTerm : FileName -> Grammar True PTerm
boxTerm fname = withLoc fname $ do
  res "["; commit
  q <- optional $ qty fname <* res "."
  t <- mustWork $ assert_total term fname <* needRes "]"
  pure $ maybe (Box t) (\q => BOX q t) q

||| tuple term like `(a, b)`, or parenthesised single term.
||| allows terminating comma. more than two elements are nested on the right:
||| `(a, b, c, d) = (a, (b, (c, d)))`.
export
tupleTerm : FileName -> Grammar True PTerm
tupleTerm fname = withLoc fname $ do
  terms <- delimSep1 "(" ")" "," $ assert_total term fname
  pure $ \loc => foldr1 (\s, t => Pair s t loc) terms

export
universe1 : Grammar True Universe
universe1 = universeTok <|> res "★" *> option 0 super


public export
PCaseArm : Type
PCaseArm = (PCasePat, PTerm)

export
caseArm : FileName -> Grammar True PCaseArm
caseArm fname =
  [|(,) (casePat fname) (needRes "⇒" *> assert_total term fname)|]

export
checkCaseArms : Loc -> List PCaseArm -> Grammar False PCaseBody
checkCaseArms loc [] = pure $ CaseEnum [] loc
checkCaseArms loc ((PPair x y _, rhs) :: rest) =
  if null rest then pure $ CasePair (x, y) rhs loc
  else fatalError "unexpected pattern after pair"
checkCaseArms loc ((PTag tag _, rhs1) :: rest) = do
  let rest = for rest $ \case
        (PTag tag _, rhs) => Just (tag, rhs)
        _                 => Nothing
  maybe (fatalError "expected all patterns to be tags")
        (\rest => pure $ CaseEnum ((tag, rhs1) :: rest) loc) rest
checkCaseArms loc ((PZero _, rhs1) :: rest) = do
  let [(PSucc p q ih _, rhs2)] = rest
    | _ => fatalError "expected succ pattern after zero"
  pure $ CaseNat rhs1 (p, q, ih, rhs2) loc
checkCaseArms loc ((PSucc p q ih _, rhs1) :: rest) = do
  let [(PZero _, rhs2)] = rest
    | _ => fatalError "expected zero pattern after succ"
  pure $ CaseNat rhs2 (p, q, ih, rhs1) loc
checkCaseArms loc ((PBox x _, rhs) :: rest) =
  if null rest then pure $ CaseBox x rhs loc
  else fatalError "unexpected pattern after box"

export
caseBody : FileName -> Grammar True PCaseBody
caseBody fname = do
  body <- bounds $ delimSep "{" "}" ";" $ caseArm fname
  let loc = makeLoc fname body.bounds
  checkCaseArms loc body.val

export
caseReturn : FileName -> Grammar True (PatVar, PTerm)
caseReturn fname = do
  x   <- patVar fname <* resC "⇒" <|> unused fname
  ret <- assert_total term fname
  pure (x, ret)

export
caseTerm : FileName -> Grammar True PTerm
caseTerm fname = withLoc fname $ do
  qty <- caseIntro fname;                     commit
  head <- mustWork $ assert_total term fname; needRes "return"
  ret  <- mustWork $ caseReturn fname;        needRes "of"
  body <- mustWork $ caseBody fname
  pure $ Case qty head ret body


||| argument/atomic term: single-token terms, or those with delimiters
||| e.g. `[t]`. includes `case` because the end delimiter is the `}`.
export
termArg : FileName -> Grammar True PTerm
termArg fname = withLoc fname $
      [|TYPE universe1|]
  <|> IOState <$ res "IOState"
  <|> [|Enum enumType|]
  <|> [|Tag tag|]
  <|> const <$> boxTerm fname
  <|> NAT    <$ res "ℕ"
  <|> Nat 0  <$ res "zero"
  <|> [|Nat nat|]
  <|> STRING <$ res "String"
  <|> [|Str strLit|]
  <|> [|V qname displacement|]
  <|> const <$> caseTerm fname
  <|> const <$> tupleTerm fname

export
properTypeLine : FileName -> Grammar True (PatVar, PTerm)
properTypeLine fname = do
  resC "("
  i <- patVar fname <* resC "⇒" <|> unused fname
  t <- assert_total term fname <* needRes ")"
  pure (i, t)

export
typeLine : FileName -> Grammar True (PatVar, PTerm)
typeLine fname =
  properTypeLine fname <|> [|(,) (unused fname) (termArg fname)|]

||| optionally, two dimension arguments. if absent default to `@0 @1`
private
optDirection : FileName -> Grammar False (PDim, PDim)
optDirection fname = withLoc fname $ do
  dims <- optional [|(,) (dimArg fname) (dimArg fname)|]
  pure $ \loc => fromMaybe (K Zero loc, K One loc) dims

export
coeTerm : FileName -> Grammar True PTerm
coeTerm fname = withLoc fname $ do
  resC "coe"
  mustWork $ do
    line   <- typeLine fname
    (p, q) <- optDirection fname
    val    <- termArg fname
    pure $ Coe line p q val

public export
CompBranch : Type
CompBranch = (DimConst, PatVar, PTerm)

export
compBranch : FileName -> Grammar True CompBranch
compBranch fname =
  [|(,,) dimConst (patVar fname) (needRes "⇒" *> assert_total term fname)|]

private
checkCompTermBody : (PatVar, PTerm) -> PDim -> PDim -> PTerm -> PDim ->
                    CompBranch -> CompBranch -> Bounds ->
                    Grammar False (Loc -> PTerm)
checkCompTermBody a p q s r (e0, s0) (e1, s1) bounds =
  case (e0, e1) of
    (Zero, One)  => pure $ Comp a p q s r s0 s1
    (One,  Zero) => pure $ Comp a p q s r s1 s0
    (_,    _)    =>
      fatalLoc bounds "body of 'comp' needs one 0 case and one 1 case"

export
compTerm : FileName -> Grammar True PTerm
compTerm fname = withLoc fname $ do
  resC "comp"
  mustWork $ do
    a <- typeLine fname
    (p, q) <- optDirection fname
    s <- termArg fname; r <- dimArg fname
    bodyStart <- bounds $ needRes "{"
    s0 <- compBranch fname; needRes ";"
    s1 <- compBranch fname; optRes  ";"
    bodyEnd <- bounds $ needRes "}"
    let body = bounds $ mergeBounds bodyStart bodyEnd
    checkCompTermBody a p q s r s0 s1 body

export
splitUniverseTerm : FileName -> Grammar True PTerm
splitUniverseTerm fname =
  withLoc fname $ resC "★" *> [|TYPE $ option 0 $ nat <|> super|]
  -- some of this looks redundant, but when parsing a non-atomic term
  -- this branch will be taken first

export
eqTerm : FileName -> Grammar True PTerm
eqTerm fname = withLoc fname $
  resC "Eq" *> mustWork [|Eq (typeLine fname) (termArg fname) (termArg fname)|]

private
appArg : Loc -> PTerm -> Either PDim PTerm -> PTerm
appArg loc f (Left  p) = DApp f p loc
appArg loc f (Right s) = App  f s loc

||| a dimension argument with an `@` prefix, or
||| a term argument with no prefix
export
anyArg : FileName -> Grammar True (Either PDim PTerm)
anyArg fname = dimArg fname <||> termArg fname

export
resAppTerm : FileName -> (word : String) -> (0 _ : IsReserved word) =>
             (PTerm -> Loc -> PTerm) -> Grammar True PTerm
resAppTerm fname word f = withLoc fname $ do
  head <- withLoc fname $ resC word *> mustWork [|f (termArg fname)|]
  args <- many $ anyArg fname
  pure $ \loc => foldl (appArg loc) head args

export
succTerm : FileName -> Grammar True PTerm
succTerm fname = resAppTerm fname "succ" Succ

export
fstTerm : FileName -> Grammar True PTerm
fstTerm fname = resAppTerm fname "fst" Fst

export
sndTerm : FileName -> Grammar True PTerm
sndTerm fname = resAppTerm fname "snd" Snd

export
normalAppTerm : FileName -> Grammar True PTerm
normalAppTerm fname = withLoc fname $ do
  head <- termArg fname
  args <- many $ anyArg fname
  pure $ \loc => foldl (appArg loc) head args

||| application term `f x @y z`, or other terms that look like application
||| like `succ` or `coe`.
export
appTerm : FileName -> Grammar True PTerm
appTerm fname =
      coeTerm fname
  <|> compTerm fname
  <|> splitUniverseTerm fname
  <|> eqTerm fname
  <|> succTerm fname
  <|> fstTerm fname
  <|> sndTerm fname
  <|> normalAppTerm fname

export
infixEqTerm : FileName -> Grammar True PTerm
infixEqTerm fname = withLoc fname $ do
  l <- appTerm fname; commit
  rest <- optional $ res "≡" *>
    [|(,) (assert_total term fname) (needRes ":" *> appTerm fname)|]
  let u = Unused $ onlyStart l.loc
  pure $ \loc => maybe l (\rest => Eq (u, snd rest) l (fst rest) loc) rest

export
annTerm : FileName -> Grammar True PTerm
annTerm fname = withLoc fname $ do
  tm <- infixEqTerm fname; commit
  ty <- optional $ res "∷" *> assert_total term fname
  pure $ \loc => maybe tm (\ty => Ann tm ty loc) ty

export
lamTerm : FileName -> Grammar True PTerm
lamTerm fname = withLoc fname $ do
  k <- DLam <$ res "δ" <|> Lam <$ res "λ"
  mustWork $ do
    xs   <- some $ patVar fname;     needRes "⇒"
    body <- assert_total term fname; commit
    pure $ \loc => foldr (\x, s => k x s loc) body xs

-- [todo] fix the backtracking in e.g. (F x y z × B)
export
properBinders : FileName -> Grammar True (List1 PatVar, PTerm)
properBinders fname = assert_total $ do
  -- putting assert_total directly on `term`, in this one function,
  -- doesn't work. i cannot tell why
  res "("
  xs <- some $ patVar fname; resC ":"
  t  <- term fname;          needRes ")"
  pure (xs, t)

export
sigmaTerm : FileName -> Grammar True PTerm
sigmaTerm fname =
      (properBinders fname >>= continueDep)
  <|> (annTerm fname       >>= continueNondep)
where
  continueDep : (List1 PatVar, PTerm) -> Grammar True PTerm
  continueDep (names, fst) = withLoc fname $ do
    snd <- needRes "×" *> sigmaTerm fname
    pure $ \loc => foldr (\x, snd => Sig x fst snd loc) snd names

  cross : PTerm -> PTerm -> PTerm
  cross l r = let loc = extend' l.loc r.loc.bounds in
              Sig (Unused $ onlyStart l.loc) l r loc

  continueNondep : PTerm -> Grammar False PTerm
  continueNondep fst = do
    rest <- optional $ resC "×" *> sepBy1 (res "×") (annTerm fname)
    pure $ foldr1 cross $ fst ::: maybe [] toList rest

export
piTerm : FileName -> Grammar True PTerm
piTerm fname = withLoc fname $ do
  q   <- [|GivenQ $ qty fname <* resC "."|] <|> defLoc fname DefaultQ
  dom <- [|Dep $ properBinders fname|] <|> [|Nondep $ ndDom q fname|]
  cod <- optional $ do resC "→"; assert_total term fname <* commit
  when (needCod q dom && isNothing cod) $ fail "missing function type result"
  pure $ maybe (const $ toTerm dom) (makePi q dom) cod
where
  data PiQty = GivenQ PQty | DefaultQ Loc
  data PiDom = Dep (List1 PatVar, PTerm) | Nondep PTerm

  ndDom : PiQty -> FileName -> Grammar True PTerm
  ndDom (GivenQ   _) = termArg   -- ｢1.(List A)｣, not ｢1.List A｣
  ndDom (DefaultQ _) = sigmaTerm

  needCod : PiQty -> PiDom -> Bool
  needCod (DefaultQ _) (Nondep _) = False
  needCod _            _          = True

  toTerm : PiDom -> PTerm
  toTerm (Dep (_, s)) = s
  toTerm (Nondep s)   = s

  toQty : PiQty -> PQty
  toQty (GivenQ   qty) = qty
  toQty (DefaultQ loc) = PQ One loc

  toDoms : PQty -> PiDom -> List1 (PQty, PatVar, PTerm)
  toDoms qty (Dep (xs, s)) = [(qty, x, s) | x <- xs]
  toDoms qty (Nondep s)    = singleton (qty, Unused s.loc, s)

  makePi : PiQty -> PiDom -> PTerm -> Loc -> PTerm
  makePi q doms cod loc =
    foldr (\(q, x, s), t => Pi q x s t loc) cod $ toDoms (toQty q) doms


export
letIntro : FileName -> Grammar True (Maybe PQty)
letIntro fname =
      withLoc fname (Just . PQ Zero <$ res "let0")
  <|> withLoc fname (Just . PQ One  <$ res "let1")
  <|> withLoc fname (Just . PQ Any  <$ res "letω")
  <|> Nothing <$ resC "let"

private
letBinder : FileName -> Maybe PQty -> Grammar True (PQty, PatVar, PTerm)
letBinder fname mq = do
  qty  <- letQty fname mq
  x    <- patVar fname
  type <- optional $ resC ":" *> term fname
  rhs  <- resC "=" *> term fname
  pure (qty, x, makeLetRhs rhs type)
where
  letQty : FileName -> Maybe PQty -> Grammar False PQty
  letQty fname Nothing  = qty fname <* mustWork (resC ".") <|> defLoc fname (PQ One)
  letQty fname (Just q) = pure q

  makeLetRhs : PTerm -> Maybe PTerm -> PTerm
  makeLetRhs tm ty = maybe tm (\t => Ann tm t (extendL tm.loc t.loc)) ty

export
letTerm : FileName -> Grammar True PTerm
letTerm fname = withLoc fname $ do
  qty   <- letIntro fname
  binds <- sepEndBy1 (res ";") $ assert_total letBinder fname qty
  mustWork $ resC "in"
  body  <- assert_total term fname
  pure $ \loc => foldr (\b, s => Let b s loc) body binds

-- term : FileName -> Grammar True PTerm
term fname = lamTerm fname
         <|> piTerm fname
         <|> sigmaTerm fname
         <|> letTerm fname


export
attr : FileName -> Grammar True PAttr
attr fname = withLoc fname $ do
  resC "#["
  name <- baseName
  args <- many $ termArg fname
  mustWork $ resC "]"
  pure $ PA name args

export
findDups : List PAttr -> List String
findDups attrs =
  SortedSet.toList $ snd $ foldl check (empty, empty) attrs
where
  Seen = SortedSet String; Dups = SortedSet String
  check : (Seen, Dups) -> PAttr -> (Seen, Dups)
  check (seen, dups) (PA a _ _) =
    (insert a seen, if contains a seen then insert a dups else dups)

export
noDups : List PAttr -> Grammar False ()
noDups attrs = do
  let dups = findDups attrs
  when (not $ null dups) $
    fatalError "duplicate attribute names: \{joinBy "," dups}"

export
attrList : FileName -> Grammar False (List PAttr)
attrList fname = do
  res <- many $ attr fname
  noDups res $> res

public export
data AttrMatch a = Matched a | NoMatch String | Malformed String String

export
Functor AttrMatch where
  map f (Matched x)     = Matched $ f x
  map f (NoMatch s)     = NoMatch s
  map f (Malformed a e) = Malformed a e

export
(<|>) : AttrMatch a -> AttrMatch a -> AttrMatch a
Matched x     <|> _ = Matched x
NoMatch _     <|> y = y
Malformed a e <|> _ = Malformed a e

export
isFail : PAttr -> AttrMatch PFail
isFail (PA "fail" []        _) = Matched PFailAny
isFail (PA "fail" [Str s _] _) = Matched $ PFailMatch s
isFail (PA "fail" _ _) = Malformed "fail" "be absent or a string literal"
isFail a = NoMatch a.name

export
isMain : PAttr -> AttrMatch ()
isMain (PA "main" [] _) = Matched ()
isMain (PA "main" _  _) = Malformed "main" "have no arguments"
isMain a = NoMatch a.name

export
isScheme : PAttr -> AttrMatch String
isScheme (PA "compile-scheme" [Str s _] _) = Matched s
isScheme (PA "compile-scheme" _ _) =
  Malformed "compile-scheme" "be a string literal"
isScheme a = NoMatch a.name

export
matchAttr : String -> AttrMatch a -> Either String a
matchAttr _ (Matched x) = Right x
matchAttr d (NoMatch a) = Left "unrecognised \{d} attribute \{a}"
matchAttr _ (Malformed a s) = Left $ unlines
  ["invalid \{a} attribute", "(should \{s})"]

export
mkPDef : List PAttr -> PQty -> PBaseName -> PBody ->
         Either String (Loc -> PDefinition)
mkPDef attrs qty name body = do
  let start = MkPDef qty name body PSucceed False Nothing noLoc
  res <- foldlM addAttr start attrs
  pure $ \l => {loc_ := l} (the PDefinition res)
where
  data PDefAttr = DefFail PFail | DefMain | DefScheme String

  isDefAttr : PAttr -> Either String PDefAttr
  isDefAttr attr = matchAttr "definition" $
        DefFail   <$> isFail attr
    <|> DefMain   <$  isMain attr
    <|> DefScheme <$> isScheme attr

  addAttr : PDefinition -> PAttr -> Either String PDefinition
  addAttr def attr =
    case !(isDefAttr attr) of
      DefFail   f   => pure $ {fail := f} def
      DefMain       => pure $ {main := True} def
      DefScheme str => pure $ {scheme := Just str} def

export
mkPNamespace : List PAttr -> Mods -> List PDecl ->
               Either String (Loc -> PNamespace)
mkPNamespace attrs name decls = do
  let start = MkPNamespace name decls PSucceed noLoc
  res <- foldlM addAttr start attrs
  pure $ \l => {loc_ := l} (the PNamespace res)
where
  isNsAttr = matchAttr "namespace" . isFail

  addAttr : PNamespace -> PAttr -> Either String PNamespace
  addAttr ns attr = pure $ {fail := !(isNsAttr attr)} ns

||| `def` alone means `defω`; same for `postulate`
export
defIntro' : (bare, zero, omega : String) ->
            (0 _ : IsReserved bare) =>
            (0 _ : IsReserved zero) =>
            (0 _ : IsReserved omega) =>
            FileName -> Grammar True PQty
defIntro' bare zero omega fname =
      withLoc fname (PQ Zero <$ resC zero)
  <|> withLoc fname (PQ Any  <$ resC omega)
  <|> do pos <- bounds $ resC bare
         let any = PQ Any $ makeLoc fname pos.bounds
         option any $ qty fname <* needRes "."

export
defIntro : FileName -> Grammar True PQty
defIntro = defIntro' "def" "def0" "defω"

export
postulateIntro : FileName -> Grammar True PQty
postulateIntro = defIntro' "postulate" "postulate0" "postulateω"

export
postulate : FileName -> List PAttr -> Grammar True PDefinition
postulate fname attrs = withLoc fname $ do
  qty  <- postulateIntro fname
  name <- baseName
  type <- resC ":" *> mustWork (term fname)
  optRes ";"
  either fatalError pure $ mkPDef attrs qty name $ PPostulate type

export
concrete : FileName -> List PAttr -> Grammar True PDefinition
concrete fname attrs = withLoc fname $ do
  qty  <- defIntro fname
  name <- baseName
  type <- optional $ resC ":" *> mustWork (term fname)
  term <- needRes "=" *> mustWork (term fname)
  optRes ";"
  either fatalError pure $ mkPDef attrs qty name $ PConcrete type term

export
definition : FileName -> List PAttr -> Grammar True PDefinition
definition fname attrs =
  try (postulate fname attrs) <|> concrete fname attrs

export
nsname : Grammar True Mods
nsname = do ns <- qname; pure $ ns.mods :< ns.base


export
decl : FileName -> Grammar True PDecl

export
namespace_ : FileName -> List PAttr -> Grammar True PNamespace
namespace_ fname attrs = withLoc fname $ do
  ns    <- resC "namespace" *> nsname; needRes "{"
  decls <- nsInner
  either fatalError pure $ mkPNamespace attrs ns decls
where
  nsInner : Grammar True (List PDecl)
  nsInner = [] <$ resC "}"
        <|> [|(assert_total decl fname <* commit) :: assert_total nsInner|]

export
declBody : FileName -> List PAttr -> Grammar True PDecl
declBody fname attrs =
  [|PDef $ definition fname attrs|] <|> [|PNs $ namespace_ fname attrs|]

-- decl : FileName -> Grammar True PDecl
decl fname = attrList fname >>= declBody fname

export
load : FileName -> Grammar True PTopLevel
load fname = withLoc fname $
  resC "load" *> mustWork [|PLoad strLit|] <* optRes ";"

export
topLevel : FileName -> Grammar True PTopLevel
topLevel fname = load fname <|> [|PD $ decl fname|]

export
input : FileName -> Grammar False PFile
input fname = [] <$ eof
          <|> [|(topLevel fname <* commit) :: assert_total input fname|]

export
lexParseTerm : FileName -> String -> Either Error PTerm
lexParseTerm = lexParseWith . term

export
lexParseInput : FileName -> String -> Either Error PFile
lexParseInput = lexParseWith . input