import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.RegisterControl
import OAI.Combinatorics.MatchingCount.Machines.TreeTyped

namespace OAI

namespace MatchingFPRAS.TreeTyped
open TreeData TreeMachine RegisterProc TreeFunction

variable {A B : Type} [Codec A] [Codec B]
namespace Fold
open RegisterControl (Instr Runs Effect)

inductive Point where | loop | check | splitHead | pushTail | pushArgs | body | popTail | rebuild | halt
  deriving DecidableEq, Inhabited
instance : Fintype Point := ⟨{.loop,.check,.splitHead,.pushTail,.pushArgs,.body,.popTail,.rebuild,.halt},by
  intro p; cases p <;> simp⟩
def code (P : Proc (K Reg)) : Point → RegisterControl.Instr Reg Point
  | .loop => .call (TreeFunction.split 1 0 (by decide)) .check
  | .check => .branch 1 .halt .splitHead
  | .splitHead => .call (TreeFunction.split 3 1 (by decide)) .pushTail
  | .pushTail => .call (TreeFunction.cons 1 2 (by decide)) .pushArgs
  | .pushArgs => .call (TreeFunction.cons 3 0 (by decide)) .body
  | .body => .call P .popTail
  | .popTail => .call (TreeFunction.split 1 2 (by decide)) .rebuild
  | .rebuild => .call (TreeFunction.cons 1 0 (by decide)) .loop
  | .halt => .halt

def heads (a b r s : Data) : Env Reg := Function.update (env b r s) 3 a
lemma splitHeads (a b r s : Data) :
    Exec (TreeFunction.split 3 1 (by decide)) (encodeEnv (env b (.cons a r) s)) (encodeEnv (heads a b r s))
      (2*TreeFunction.size a+5) := by
  have hh := split_exec (env b (.cons a r) s) 3 1 (by decide) () a r rfl
  have he : putPair (env b (.cons a r) s) 3 1 a r=heads a b r s := by
    funext i; fin_cases i <;> simp [heads,putPair,env]
  rw [he] at hh
  convert hh using 1
  all_goals try rfl
  simp [TreeFunction.size,env,TreeData.encode]
  omega
lemma pushTail (a b r s : Data) :
    Exec (TreeFunction.cons 1 2 (by decide)) (encodeEnv (heads a b r s)) (encodeEnv (heads a b .nil (.cons r s)))
      (2*TreeFunction.size r+3) := by
  have hh := cons_exec (heads a b r s) 1 2 (by decide) ()
  have he : putPair (heads a b r s) 1 2 .nil (.cons (heads a b r s 1) (heads a b r s 2))=
      heads a b .nil (.cons r s) := by
    funext i; fin_cases i <;> simp [heads,putPair,env]
  rw [he] at hh
  exact hh
lemma pushArgs (a b r s : Data) :
    Exec (TreeFunction.cons 3 0 (by decide)) (encodeEnv (heads a b .nil (.cons r s)))
      (encodeEnv (env (.cons a b) .nil (.cons r s))) (2*TreeFunction.size a+3) := by
  have hh := cons_exec (heads a b .nil (.cons r s)) 3 0 (by decide) ()
  have he : putPair (heads a b .nil (.cons r s)) 3 0 .nil
      (.cons (heads a b .nil (.cons r s) 3) (heads a b .nil (.cons r s) 0))=
      env (.cons a b) .nil (.cons r s) := by
    funext i; fin_cases i <;> simp [heads,putPair,env]
  rw [he] at hh
  exact hh

def cost (f : A×B → B) (t : A×B → ℕ) : List A → B → ℕ
  | [],_ => 10
  | a::as,b => t (a,b)+6*TreeFunction.size (encode a)+8*TreeFunction.size (encode as)+34+cost f t as (f (a,b))

lemma runs {f : A×B → B} (F : Realizer f) (as : List A) (b : B) (s : Data) :
    Runs (code F.program) (some Point.loop) (env (encode (as,b)) .nil s)
      (env (encode (as.foldl (fun b a=>f (a,b)) b)) .nil s) (cost f F.cost as b) := by
  induction as generalizing b with
  | nil =>
    have hh : Runs (code F.program) (some Point.halt) (env (encode b) .nil s) (env (encode b) .nil s) 1 :=
      Runs.step _ _ _ _ _ 0 1 (Effect.halt _) (Runs.done _)
    have hc : Runs (code F.program) (some Point.check) (env (encode b) .nil s) (env (encode b) .nil s) 2 :=
      Runs.step _ _ _ _ _ 1 1 (Effect.nilBranch _ 1 _ _ rfl) hh
    have hs:=split10 .nil (encode b) .nil s
    have hs' : Exec (TreeFunction.split 1 0 (by decide)) (encodeEnv (env (encode (([] : List A),b)) .nil s))
        (encodeEnv (env (encode b) .nil s)) 7 := by simpa [size_nil,encode_prod,encode_list_nil] using hs
    exact Runs.step _ _ _ _ _ 2 8 (Effect.call _ _ _ _ 7 hs') hc
  | cons a as ih =>
    let z:=as.foldl (fun b a=>f (a,b)) (f (a,b))
    let sa:=TreeFunction.size (encode a)
    let sr:=TreeFunction.size (encode as)
    let rest:=cost f F.cost as (f (a,b))
    have hr := ih (f (a,b))
    have h1:=cons10 (encode (f (a,b))) (encode as) s
    have hreb : Runs (code F.program) (some Point.rebuild) (env (encode (f (a,b))) (encode as) s)
        (env (encode z) .nil s) ((2*sr+4)+rest) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h1) hr
    have h2 := (split12 (encode (f (a,b))) .nil (encode as) s).mono
      (show TreeFunction.size Data.nil+2*TreeFunction.size (encode as)+4 ≤ 2*sr+5 by
        change 1+2*sr+4 ≤ 2*sr+5
        omega)
    have hpop : Runs (code F.program) (some Point.popTail) (env (encode (f (a,b))) .nil (.cons (encode as) s))
        (env (encode z) .nil s) ((2*sr+6)+((2*sr+4)+rest)) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h2) hreb
    have h3:=F.correct (a,b) (.cons (encode as) s)
    have hbody : Runs (code F.program) (some Point.body) (env (encode (a,b)) .nil (.cons (encode as) s))
        (env (encode z) .nil s) ((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest))) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h3) hpop
    have h4:=pushArgs (encode a) (encode b) (encode as) s
    have ha : Runs (code F.program) (some Point.pushArgs) (heads (encode a) (encode b) .nil (.cons (encode as) s))
        (env (encode z) .nil s) ((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest)))) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h4) hbody
    have h5:=pushTail (encode a) (encode b) (encode as) s
    have ht : Runs (code F.program) (some Point.pushTail) (heads (encode a) (encode b) (encode as) s)
        (env (encode z) .nil s) ((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest))))) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h5) ha
    have h6:=splitHeads (encode a) (encode b) (encode as) s
    have hsh : Runs (code F.program) (some Point.splitHead) (env (encode b) (encode (a::as)) s)
        (env (encode z) .nil s) ((2*sa+6)+((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest)))))) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h6) ht
    have hc : Runs (code F.program) (some Point.check) (env (encode b) (encode (a::as)) s)
        (env (encode z) .nil s) (1+((2*sa+6)+((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest))))))) :=
      Runs.step _ _ _ _ _ _ 1 (Effect.consBranch _ 1 _ _ (encode a) (encode as) rfl) hsh
    have h7 := (split10 (encode (a::as)) (encode b) .nil s).mono
      (show TreeFunction.size Data.nil+2*TreeFunction.size (encode (a::as))+4 ≤ 2*TreeFunction.size (encode (a::as))+5 by
        change 1+2*TreeFunction.size (encode (a::as))+4 ≤ 2*TreeFunction.size (encode (a::as))+5
        omega)
    have hl : Runs (code F.program) (some Point.loop) (env (encode (a::as,b)) .nil s)
        (env (encode z) .nil s) ((2*TreeFunction.size (encode (a::as))+6)+(1+((2*sa+6)+((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest)))))))) :=
      Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h7) hc
    convert hl using 1
    all_goals try rfl
    simp only [cost,encode_list_cons,size_cons,sa,sr,rest]
    ring
end Fold

def fold {f : A×B → B} (F : Realizer f) : Realizer (fun ab : List A×B=>ab.1.foldl (fun b a=>f (a,b)) ab.2) where
  program := RegisterControl.compile (Fold.code F.program)
  cost := fun ab=>Fold.cost f F.cost ab.1 ab.2
  correct := fun ab s=>RegisterControl.compile_exec _ _ _ _ (Fold.runs F ab.1 ab.2 s)
end MatchingFPRAS.TreeTyped

end OAI