/- Copyright (c) Joseph Rotella, 2023.  All rights reserved.
Authors: Joseph Rotella, Ryan Edmonds -/
import Std.Data.List.Basic
import Lean

open Lean Widget

inductive BExpr
| const : Bool → BExpr
| var : String → BExpr
| and : BExpr → BExpr → BExpr
| or : BExpr → BExpr → BExpr
| implies : BExpr → BExpr → BExpr
| not : BExpr → BExpr
| iff : BExpr → BExpr → BExpr
deriving Repr, DecidableEq, Inhabited

instance : ToString BExpr :=
let rec toString
| .const true => "⊤"
| .const false => "⊥"
| .var x => x
| .and p q => "(" ++ toString p ++ " ∧ " ++ toString q ++ ")"
| .or p q => "(" ++ toString p ++ " ∨ " ++ toString q ++ ")"
| .implies p q => "(" ++ toString p ++ " → " ++ toString q ++ ")"
| .not p => "¬" ++ toString p
| .iff p q => "(" ++ toString p ++ " ↔ " ++ toString q ++ ")"
⟨toString⟩

def getVars : BExpr → List String
| .var x => [x]
| .and p q | .or p q | .implies p q | .iff p q => getVars p ++ getVars q
| .not p => getVars p
| .const _ => []

def subst : BExpr → String → Bool → BExpr
| .var x, s, b => if x = s then .const b else .var x
| .and p q, s, b => .and (subst p s b) (subst q s b)
| .or p q, s, b => .or (subst p s b) (subst q s b)
| .implies p q, s, b => .implies (subst p s b) (subst q s b)
| .iff p q, s, b => .iff (subst p s b) (subst q s b)
| .not p, s, b => .not (subst p s b)
| .const v, _, _ => .const v

def substAll (asgns : List (String × Bool)) (e : BExpr) : BExpr :=
  asgns.foldl (λ | acc, (v, b) => subst acc v b) e

def eval : BExpr → Option Bool
| .const b => some b
| .and p q => do (← eval p) && (← eval q)
| .or p q => do (← eval p) || (← eval q)
| .implies p q => do (not (← eval p)) || (← eval q)
| .not p => do not (← eval p)
| .var _ => none
| .iff p q => do (← eval p) == (← eval q)

def generateSubExprs : BExpr → List BExpr
| .const _ => [] -- we don't need to examine truth vals of ⊤/⊥
| .var x => [.var x]
| e@(.or p q) | e@(.and p q) | e@(.implies p q) | e@(.iff p q) =>
  generateSubExprs p ++ generateSubExprs q ++ [e]
| .not p => generateSubExprs p ++ [.not p]

def permuteVarVals : List String → List (List (String × Bool)) := λ vs =>
  let count := 2 ^ vs.length
  let rec helper : Nat → List (List (String × Bool))
  | 0 => []
  | .succ n =>
    vs.mapIdx (λ (i : Nat) (v : String) =>
      (v, decide $ ((count - n.succ) >>> i) % 2 = 0))
    :: helper n
  helper count

def List.uniqueAux {α} [DecidableEq α] : List α → List α → List α
| [], acc => acc.reverse
| x :: xs, acc => if x ∈ acc then uniqueAux xs acc else uniqueAux xs (x :: acc)

def List.unique {α} [DecidableEq α] (xs : List α) := uniqueAux xs []

def prefixVars : List BExpr → List BExpr × List BExpr
| [] => ([], [])
| e@(.var _) :: tt =>
    let (restV, restC) := prefixVars tt
    (e::restV, restC)
| e :: tt =>
    let (restV, restC) := prefixVars tt
    (restV, e::restC)

-- TODO: don't use imperative things that can crash and burn (`get!`)
def truthTable (e : BExpr) : List (List (String × Bool)) :=
  let vars := getVars e
  let (BVars, VExps) := prefixVars ((generateSubExprs e).unique)
  let subBExprs := BVars.append VExps
  let allAsgns := permuteVarVals vars.unique
  allAsgns.map (λ asgns =>
    subBExprs
    |> List.map (λ e => (toString e, e))
    |> List.map (λ | (s, e) => (s, substAll asgns e))
    |> List.map (λ | (s, e) => (s, (eval e).get!))
  )

def htmlOfTable : List (List (String × Bool)) → String :=
λ t =>
  -- Hacky workaround
  if h1 : t = [] then "" else
  "<table cellpadding=\"5\""
      ++ "style=\"border:1px solid gray; border-collapse: collapse\">"
  ++ "<thead><tr>"
  ++ List.foldl (λ acc p => acc ++ "<th style=\"border:1px solid gray\">"
                                ++ toString p.1 ++ "</th>") "" (t.head h1)
  ++ "</tr></thead><tbody>"
  ++ List.foldl (λ acc r =>
      acc ++ "<tr>"
          ++ r.foldl (λ acc p =>
          let txt := toString p.2
          let bg := if txt = "true" then "limegreen" else "lightcoral"
          acc ++ "<td style=\"border:1px solid gray; background-color:"
              ++ bg ++ "\">" ++ toString p.2 ++ "</td>") "" ++ "</tr>") "" t
  ++ "</tbody></table>"

def mkTableWidget (t : List (List (String × Bool))) :
    UserWidgetDefinition where
  name := "Truth Table"
  javascript :=  "
    import * as React from 'react';
    export default function(props) {
      return React.createElement('div', {dangerouslySetInnerHTML: {__html: '"
        ++ htmlOfTable t
        ++ "'}})
    }"

def null := Lean.Json.null

syntax (name := truthTableCommand) "#truth_table" term : command

partial def bExprOfPropTerm :
  TSyntax `term → Elab.Command.CommandElabM (TSyntax `term)
| `(($P)) => bExprOfPropTerm P
| `($P ∧ $Q) => do `(.and ($(← bExprOfPropTerm P)) ($(← bExprOfPropTerm Q)))
| `($P ∨ $Q) => do `(.or ($(← bExprOfPropTerm P)) ($(← bExprOfPropTerm Q)))
| `($P → $Q) => do `(.implies ($(← bExprOfPropTerm P)) ($(← bExprOfPropTerm Q)))
| `($P ↔ $Q) => do `(.iff ($(← bExprOfPropTerm P)) ($(← bExprOfPropTerm Q)))
| `(¬ $P) => do `(.not ($(← bExprOfPropTerm P)))
| `(True) => do `(.const true)
| `(False) => do `(.const false)
-- We don't need this, but its breaking things may indicate a Lean bug
-- | `(¬ ($P)) => do `(.not ($(← bExprOfPropTerm P)))
| p =>
  let vnm := p.raw.getId.toString

  match p.raw.isIdent with
  | false => throwError ("Illegal Expression " ++ (toString p.raw))
  | true => `(.var $(Syntax.mkStrLit vnm))

-- TODO: This approach should be more robust, but it doesn't appear that Lean 4
-- currently supports antiquotations of `Expr`s out of the box, and adding the
-- `quote4` dependency could create even more headaches.
-- partial def bExprOfPropTerm : Expr → Elab.TermElabM (TSyntax `term)
-- | .app nm e' => do
--   -- This is inadequate -- `nm` might actually be an application itself
--   -- (consider `Or (And P Q) R`)
--   let isNot : Bool ← Meta.isExprDefEq nm (.const `Not [.succ .zero])
--   if isNot
--   then `(BExpr.not ($(← bExprOfPropTerm e')))
--   else
--     let isAnd : Bool ← Meta.isExprDefEq nm (.const `And [.succ .zero])
--     sorry
-- | _ => sorry

@[command_elab «truthTableCommand»] private unsafe def elabTableWidget :
  Elab.Command.CommandElab :=
  open Lean Lean.Elab Command Term in λ
  | stx@`(#truth_table $prop) => do
    let ident ← mkFreshIdent stx
    let decl := Lean.Syntax.getId ident
    let ident := mkIdent decl

    -- let tbStx : Lean.TSyntax `term ← Lean.Elab.Command.runTermElabM (λ _ =>
    --   do bExprOfPropTerm (← Lean.Elab.Term.elabType prop))


    elabDeclaration (←
      `(@[widget] def $ident :=
        mkTableWidget (truthTable $(← bExprOfPropTerm prop)))
      -- `(@[widget] def $ident := mkTableWidget (truthTable $tbStx)))
    )

    let null_stx ← `(Json.null)
    let props : Json ← runTermElabM fun _ =>
      Term.evalTerm Json (mkConst ``Json) null_stx
    saveWidgetInfo decl props stx
  | _ => throwUnsupportedSyntax