import OAI.MathematicalPhysics.RapidForcing.ExprCoding

namespace OAI

section

open Encodable Denumerable Function Nat.Partrec
namespace RapidForcing.EffectiveArithmetic

attribute [fun_prop] Computable.option_getD
  Primrec.list_length Primrec.list_reverse Primrec.list_head? Primrec.list_tail
  Primrec.list_range

@[fun_prop] lemma primrec_list_cons {A : Type} [Primcodable A] :
    Primrec (fun p : A × List A => p.1 :: p.2) := Primrec.list_cons

lemma computable_list_casesOn {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
    {f : A → List B} {g : A → S} {h : A → B × List B → S}
    (hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
    Computable (fun a => List.casesOn (motive := fun _ => S) (f a) (g a) fun b l => h a (b, l)) := by
  have hd : Computable (fun a => (f a).head?) := Primrec.list_head?.to_comp.comp hf
  have ht : Computable (fun a => (f a).tail) := Primrec.list_tail.to_comp.comp hf
  exact (Computable.option_casesOn hd hg
    (hh.comp Computable.fst (Computable.snd.pair (ht.comp Computable.fst))).to₂).of_eq
      (fun a => by cases hfa : f a <;> simp [hfa])

lemma computable_nat_iterate {A S : Type} [Primcodable A] [Primcodable S]
    {f : A → ℕ} {g : A → S} {h : A → S → S}
    (hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
    Computable (fun a => (h a)^[f a] (g a)) := by
  exact (Computable.nat_rec hf hg
    ((hh.comp Computable.fst (Computable.snd.comp Computable.snd)).to₂)).of_eq
    (fun a => by induction f a <;> simp [Function.iterate_succ_apply', *])

lemma computable_list_foldl {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
    {f : A → List B} {g : A → S} {h : A → S × B → S}
    (hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
    Computable (fun a => (f a).foldl (fun s b => h a (s, b)) (g a)) := by
  let G (a : A) (v : S × List B) : S × List B :=
    List.casesOn v.2 v fun b l => (h a (v.1, b), l)
  have hG : Computable₂ G := computable_list_casesOn
    (Computable.snd.comp Computable.snd) Computable.snd
    ((hh.comp (Computable.fst.comp Computable.fst)
      (((Computable.fst.comp Computable.snd).comp Computable.fst).pair (Computable.fst.comp Computable.snd))).pair
      (Computable.snd.comp Computable.snd)).to₂
  have F := computable_nat_iterate (Computable.list_length.comp hf) (hg.pair hf) hG
  have he (a : A) (n : ℕ) (l : List B) (x : S) :
      (G a)^[n] (x, l) = ((l.take n).foldl (fun s b => h a (s, b)) x, l.drop n) := by
    induction n generalizing l x with
    | zero => rfl
    | succ n ih => cases l <;> simp [iterate_succ, comp_apply, G, ih]
  exact (Computable.fst.comp F).of_eq (fun a => by rw [he]; simp)

lemma computable_list_foldr {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
    {f : A → List B} {g : A → S} {h : A → B × S → S}
    (hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
    Computable (fun a => (f a).foldr (fun b s => h a (b, s)) (g a)) := by
  exact (computable_list_foldl (Computable.list_reverse.comp hf) hg
    (hh.comp Computable.fst ((Computable.snd.pair Computable.fst).comp Computable.snd)).to₂).of_eq
      (fun a => by rw [List.foldl_reverse])

lemma computable_list_rec {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
    {f : A → List B} {g : A → S} {h : A → B × List B × S → S}
    (hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
    Computable (fun a => List.recOn (motive := fun _ => S) (f a) (g a) fun b l s => h a (b, l, s)) := by
  have hstep : Computable (fun v : A × B × List B × S =>
      (v.2.1 :: v.2.2.1, h v.1 (v.2.1, v.2.2.1, v.2.2.2))) :=
    (Computable.list_cons.comp (Computable.fst.comp Computable.snd)
      (Computable.fst.comp (Computable.snd.comp Computable.snd))).pair hh
  have hr := computable_list_foldr hf ((Computable.const ([] : List B)).pair hg) hstep.to₂
  apply (Computable.snd.comp hr).of_eq
  intro a
  have haux (l : List B) :
      l.foldr (fun b p => (b :: p.1, h a (b, p.1, p.2))) ([], g a) =
        (l, List.recOn (motive := fun _ => S) l (g a) fun b l s => h a (b, l, s)) := by
    induction l <;> simp [*]
  rw [haux]

end RapidForcing.EffectiveArithmetic

namespace RapidForcing.EffectiveProfile.Expr
open EffectiveArithmetic
local instance recursiveCodeDecidableEq : DecidableEq Code :=
  Encodable.decidableEqOfEncodable Code

lemma computable_recOn {A S : Type} [Primcodable A] [Primcodable S]
    {e : A → Expr} (he : Computable e)
    {c : A → ℚ → S} (hc : Computable₂ c)
    {l r : A → GluePoly → S} (hl : Computable₂ l) (hr : Computable₂ r)
    {d : A → ℕ → S} (hd : Computable₂ d)
    {a m : A → Expr × Expr × S × S → S} (ha : Computable₂ a) (hm : Computable₂ m) :
    Computable (fun x => Expr.recOn (motive := fun _ => S) (e x) (c x) (l x) (r x) (d x)
      (fun e₁ e₂ v₁ v₂ => a x (e₁, e₂, v₁, v₂))
      (fun e₁ e₂ v₁ v₂ => m x (e₁, e₂, v₁, v₂))) := by
  let z := fun x => c x 0
  let pr := fun (x : A) (p : Code × Code × S × S) =>
    if p.1 = .zero then c x ((decode (encode p.2.1)).getD 0)
    else if p.1 = .succ then l x ((decode (encode p.2.1)).getD [])
    else if p.1 = .left then r x ((decode (encode p.2.1)).getD [])
    else d x (encode p.2.1)
  let co := fun (x : A) (p : Code × Code × S × S) =>
    a x (fromCode p.1, fromCode p.2.1, p.2.2.1, p.2.2.2)
  let pc := fun (x : A) (p : Code × Code × S × S) =>
    m x (fromCode p.1, fromCode p.2.1, p.2.2.1, p.2.2.2)
  have hz : Computable z := hc.comp Computable.id (Computable.const 0)
  have hpr : Computable₂ pr := by
    unfold pr Computable₂
    apply computable_ite (by fun_prop) (hc.comp Computable.fst (by fun_prop))
    apply computable_ite (by fun_prop) (hl.comp Computable.fst (by fun_prop))
    exact computable_ite (by fun_prop) (hr.comp Computable.fst (by fun_prop))
      (hd.comp Computable.fst (by fun_prop))
  have hco : Computable₂ co := ha.comp Computable.fst (by fun_prop)
  have hpc : Computable₂ pc := hm.comp Computable.fst (by fun_prop)
  have H := Code.computable_recOn (primrec_toCode.to_comp.comp he) hz hz hz hz
    hpr hco hpc (rf := fun x _ => z x) (hz.comp Computable.fst).to₂
  apply H.of_eq
  intro x
  have hh (b : Code) : Code.recOn b (z x) (z x) (z x) (z x)
      (fun c₁ c₂ v₁ v₂ => pr x (c₁, c₂, v₁, v₂))
      (fun c₁ c₂ v₁ v₂ => co x (c₁, c₂, v₁, v₂))
      (fun c₁ c₂ v₁ v₂ => pc x (c₁, c₂, v₁, v₂)) (fun _ _ => z x) =
      Expr.recOn (motive := fun _ => S) (fromCode b) (c x) (l x) (r x) (d x)
        (fun e₁ e₂ v₁ v₂ => a x (e₁, e₂, v₁, v₂))
        (fun e₁ e₂ v₁ v₂ => m x (e₁, e₂, v₁, v₂)) := by
    induction b <;> simp_all only [fromCode, pr, co, pc, z]
    split_ifs <;> rfl
  simpa only [fromCode_toCode] using hh (toCode (e x))

end RapidForcing.EffectiveProfile.Expr

end

end OAI