import OAI.Computability.DegreeRigidity.Effective.CodingLocations

namespace OAI

namespace TuringRigidity.CodingSplitSearch
open Encodable PrefixComputability CodingLocations

abbrev Witness := (List Bool × (ℕ × Bool)) × (ℕ × (ℕ × ℕ))

def finiteTrial (d : Nat.Partrec.Code) (base : List Bool) (L : List ℕ) (w : Witness) : Option ℕ :=
  let a := d.evaln w.2.2.1 (Nat.pair (encode L) (Nat.pair (encode w.1.1) w.2.1))
  let b := d.evaln w.2.2.2 (Nat.pair (encode L) (Nat.pair (encode (w.1.1.set w.1.2.1 w.1.2.2)) w.2.1))
  if w.1.2.1 < w.1.1.length ∧ a ≠ none ∧ b ≠ none ∧ a.getD 0 ≠ b.getD 0
  then some (base.length + w.1.2.1) else none

theorem finiteTrial_primrec (d : Nat.Partrec.Code) (base : List Bool) : Primrec₂ (finiteTrial d base) := by
  let hL : Primrec (fun z : List ℕ × Witness => z.1) := Primrec.fst
  let hu : Primrec (fun z : List ℕ × Witness => z.2.1.1) := Primrec.fst.comp (Primrec.fst.comp Primrec.snd)
  let hi : Primrec (fun z : List ℕ × Witness => z.2.1.2.1) := Primrec.fst.comp (Primrec.snd.comp (Primrec.fst.comp Primrec.snd))
  let hb : Primrec (fun z : List ℕ × Witness => z.2.1.2.2) := Primrec.snd.comp (Primrec.snd.comp (Primrec.fst.comp Primrec.snd))
  let hn : Primrec (fun z : List ℕ × Witness => z.2.2.1) := Primrec.fst.comp (Primrec.snd.comp Primrec.snd)
  let ht₀ : Primrec (fun z : List ℕ × Witness => z.2.2.2.1) := Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))
  let ht₁ : Primrec (fun z : List ℕ × Witness => z.2.2.2.2) := Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))
  let hu' := Primrec.list_set.comp hu (hi.pair hb)
  let ha₀ := Nat.Partrec.Code.primrec_evaln.comp
    ((ht₀.pair (Primrec.const d)).pair
      (Primrec₂.natPair.comp (Primrec.encode.comp hL) (Primrec₂.natPair.comp (Primrec.encode.comp hu) hn)))
  let ha₁ := Nat.Partrec.Code.primrec_evaln.comp
    ((ht₁.pair (Primrec.const d)).pair
      (Primrec₂.natPair.comp (Primrec.encode.comp hL) (Primrec₂.natPair.comp (Primrec.encode.comp hu') hn)))
  exact Primrec.ite ((Primrec.nat_lt.comp hi (Primrec.list_length.comp hu)).and
    (((Primrec.eq.comp ha₀ (Primrec.const none)).not).and
      (((Primrec.eq.comp ha₁ (Primrec.const none)).not).and
        (Primrec.eq.comp (Primrec.option_getD_default.comp ha₀)
          (Primrec.option_getD_default.comp ha₁)).not)))
    (Primrec.option_some.comp (Primrec.nat_add.comp (Primrec.const base.length) hi))
    (Primrec.const none)

def trial (Y : Oracle) (d : Nat.Partrec.Code) (base : List Bool) (z : ℕ) : Option ℕ :=
  finiteTrial d base (oraclePrefix (fun n => CommonIdeal.bit (Y n)) (Nat.unpair z).1)
    ((decode (α := Witness) (Nat.unpair z).2).getD default)

theorem trial_recursive (Y : Oracle) (d : Nat.Partrec.Code) (base : List Bool) :
    Nat.RecursiveIn {oracleFunction Y} (fun z => Part.some (encode (trial Y d base z))) := by
  have hpre := total_comp (prefix_recursive (fun n => CommonIdeal.bit (Y n)))
    (total_primrec (Primrec.fst.comp Primrec.unpair))
  have hw := total_primrec (O := {oracleFunction Y}) (Primrec.snd.comp Primrec.unpair)
  have hrun := total_primrec (O := {oracleFunction Y}) (Primrec.encode.comp
    ((finiteTrial_primrec d base).comp
      (Primrec.option_getD_default.comp (Primrec.decode.comp (Primrec.fst.comp Primrec.unpair)))
      (Primrec.option_getD_default.comp (Primrec.decode.comp (Primrec.snd.comp Primrec.unpair)))))
  exact (total_comp hrun (total_pair hpre hw)).of_eq (fun z => by simp [trial])

theorem trial_sound (Y : Oracle) (e : OracleCode) (base : List Bool)
    (d : Nat.Partrec.Code)
    (hd : ∀ L w, d.eval (Nat.pair (encode L) w) = CommonIdeal.finiteRun e base L w)
    (z m : ℕ) (h : m ∈ trial Y d base z) : SplittingLocation Y e base m := by
  let L := oraclePrefix (fun n => CommonIdeal.bit (Y n)) (Nat.unpair z).1
  let w := ((decode (α := Witness) (Nat.unpair z).2).getD default)
  change m ∈ finiteTrial d base L w at h
  dsimp only [finiteTrial] at h
  split at h
  next hg =>
    have hm : m = base.length + w.1.2.1 := (Option.mem_some_iff.mp h).symm
    let a := d.evaln w.2.2.1 (Nat.pair (encode L) (Nat.pair (encode w.1.1) w.2.1))
    let b := d.evaln w.2.2.2 (Nat.pair (encode L) (Nat.pair (encode (w.1.1.set w.1.2.1 w.1.2.2)) w.2.1))
    have ha : a.getD 0 ∈ a := by
      cases ha' : a with
      | none => exact False.elim (hg.2.1 ha')
      | some v => simp
    have hb : b.getD 0 ∈ b := by
      cases hb' : b with
      | none => exact False.elim (hg.2.2.1 hb')
      | some v => simp
    have hva := Nat.Partrec.Code.evaln_sound ha
    have hvb := Nat.Partrec.Code.evaln_sound hb
    rw [hd] at hva hvb
    have hA := (CommonIdeal.finiteRun_approximates Y e base (encode w.1.1) w.2.1).1
      (Nat.unpair z).1 (a.getD 0) hva
    have hB := (CommonIdeal.finiteRun_approximates Y e base
      (encode (w.1.1.set w.1.2.1 w.1.2.2)) w.2.1).1 (Nat.unpair z).1 (b.getD 0) hvb
    rw [hm]
    refine ⟨base ++ w.1.1, w.1.2.2, w.2.1, a.getD 0, b.getD 0,
      List.prefix_append _ _, by omega, by simp; omega, hg.2.2.2, ?_, ?_⟩
    · simpa [BorelGeneric.word] using hA
    · simpa [BorelGeneric.word, List.set_append_right] using hB
  next hg => simp at h

theorem trial_complete (Y : Oracle) (e : OracleCode) (base : List Bool)
    (d : Nat.Partrec.Code)
    (hd : ∀ L w, d.eval (Nat.pair (encode L) w) = CommonIdeal.finiteRun e base L w)
    {m : ℕ} (hm : SplittingLocation Y e base m) : ∃ z, m ∈ trial Y d base z := by
  obtain ⟨s, b, n, a, c, ⟨u, rfl⟩, hbase, hms, hac, ha, hc⟩ := hm
  let i := m - base.length
  have hmi : m = base.length + i := by omega
  have hi : i < u.length := by simp only [List.length_append] at hms; omega
  have hc' : c ∈ CommonIdeal.run Y e (base ++ u.set i b) n := by
    simpa [List.set_append_right _ _ hbase] using hc
  have hau : a ∈ CommonIdeal.run Y e (base ++ BorelGeneric.word (encode u)) n := by
    simpa [BorelGeneric.word] using ha
  have hcu : c ∈ CommonIdeal.run Y e (base ++ BorelGeneric.word (encode (u.set i b))) n := by
    simpa [BorelGeneric.word] using hc'
  obtain ⟨M₀, hM₀⟩ := (CommonIdeal.finiteRun_approximates Y e base (encode u) n).2 a hau
  obtain ⟨M₁, hM₁⟩ := (CommonIdeal.finiteRun_approximates Y e base (encode (u.set i b)) n).2 c hcu
  let M := max M₀ M₁
  have hfa := hM₀ M (Nat.le_max_left _ _)
  have hfc := hM₁ M (Nat.le_max_right _ _)
  dsimp only at hfa hfc
  rw [← hd] at hfa hfc
  obtain ⟨t₀, ht₀⟩ := Nat.Partrec.Code.evaln_complete.mp hfa
  obtain ⟨t₁, ht₁⟩ := Nat.Partrec.Code.evaln_complete.mp hfc
  let w : Witness := ((u, i, b), (n, t₀, t₁))
  refine ⟨Nat.pair M (encode w), ?_⟩
  have ht₀' := Option.mem_def.mp ht₀
  have ht₁' := Option.mem_def.mp ht₁
  simp only [UniformOracle.oraclePrefix] at ht₀' ht₁'
  simp [trial, finiteTrial, oraclePrefix, w, ht₀', ht₁', hi, hac, hmi]

theorem splittingLocations_enumerable (Y : Oracle) (e : OracleCode) (base : List Bool) :
    ∃ E : ℕ → Option ℕ,
      Nat.RecursiveIn {oracleFunction Y} (fun z => Part.some (encode (E z))) ∧
      ∀ m, SplittingLocation Y e base m ↔ ∃ z, m ∈ E z := by
  obtain ⟨d, hd⟩ := CommonIdeal.finiteRun_code e base
  refine ⟨trial Y d base, trial_recursive Y d base, ?_⟩
  intro m
  exact ⟨trial_complete Y e base d hd, fun ⟨z, hz⟩ => trial_sound Y e base d hd z m hz⟩

end TuringRigidity.CodingSplitSearch

end OAI