import OAI.Computability.SpaceSimulation.OneTape.Trial
import OAI.Computability.SpaceSimulation.OneTape.Sizes

namespace OAI

namespace Fifths.Single
open Entry Cost Fifths.Comp
variable {X I U : Type} (M : Single X)

def choiceSite (T a : ℕ) : Site :=
  let k := K T
  { T := T, k := k, positive := K_pos _
    left := ⟨a%(k*k),Nat.mod_lt _ (Nat.mul_pos (K_pos _) (K_pos _))⟩ }

theorem choice_at {T : ℕ} (a : Fin (K T * K T)) :
    choiceSite T a.val = Site.mk T (K T) (K_pos T) a := by
  have h : (choiceSite T a.val).left.val = a.val :=
    Nat.mod_eq_of_lt a.isLt
  exact congrArg (Site.mk T (K T) (K_pos T)) (Fin.ext h)

/-- Capped evaluator. All offsets, workspace reused. -/
theorem cappedRegister (A : M.Sym) (d : ℕ)
    {x : I → List X} {S T a : I → ℕ}
    (q : Comp x S a T) (h : Scaled S (fun i => Cost.bound d (T i)))
    (l : ∃ B, ∀ i, M.Gives A (x i) (T i) (B*(S i+1))) :
    Tells x S a (fun i => M.outcome (x i) (T i)) := by
  let n : I → ℕ := fun i => K (T i) * K (T i)
  let w := fun i j => choiceSite (T i) j
  let f := fun i j => M.complete (x i) (w i j)
  have u := Cost.ofT q
  have v : Comp x S a n := u.mul u
  have g : ∀ {U : Type} (r : U → I) {e o : U → ℕ},
      ReComp x S r e (fun i => a (r i)) →
      ReComp x S r e o →
      ReComp x S r e (fun i => (f (r i) (o i)).toNat) ∧
      Tells (fun i => x (r i)) (fun i => S (r i)) e
        (fun i => M.readout (x (r i)) (w (r i) (o i))) := by
    intro U r e o p l₀
    let W := fun i => w (r i) (o i)
    let X' := fun i => x (r i)
    let S' := fun i => S (r i)
    have est := M.estimate W X' d (fun _ => rfl)
    have c : M.Kit A X' S' e W :=
      { ofCap := p.trans (q.pull r)
        ofK := p.trans (u.pull r)
        ofPosition := l₀.mod (p.trans (v.pull r))
        budget := est.1.up (h.pull r)
        access := by obtain ⟨B,l⟩ := l; exact ⟨B,fun i => l (r i)⟩ }
    exact c.solves (est.2.trans (h.pull r))

  have k := scanPick f v (fun e p q =>
    (g (fun i : Before n => i.val.1) p q).1)

  have p i : f i (Scan.pick (f i) (n i)) = true := by
    obtain ⟨a,h⟩ := M.some_complete (x i) (T i) _ (K_pos _) (bigK _)
    apply (Scan.pick_spec _ _ ?_).2
    exact ⟨a.val,a.isLt,by rw [← choice_at] at h; exact h⟩
  refine Comp.congr ((g id (Comp.refl q.source) k).2) (fun i => ?_)
  exact congrArg code (M.if_complete _ _ (p i))

theorem capFits (d : ℕ) (T : I → ℕ) :
    Fits (fun i => Cost.bound d (T i)) T := by
  let S := fun i => Cost.bound d (T i)
  exact (Scaled.refl S).of_le (fun i => Nat.le_trans (Nat.le_succ _) (lg_le d (T i)))

theorem stable (x : List X) {t u}
    (p : (M.outcome x t).2) (q : (M.outcome x u).2) :
    M.outcome x t = M.outcome x u := by
  have h (t u : ℕ) (p : (M.outcome x t).2 = true) (q : t ≤ u) :
      M.outcome x u = M.outcome x t := by
    nth_rw 1 [show u=t+(u-t) by omega]
    unfold outcome
    rw [M.absorbed x p (u-t)]
  cases le_total t u with
  | inl r => exact (h t u p r).symm
  | inr r => exact h u t q r

/-- Unknown-time branch. Keep predicate is computed by a fully
charged invocation; `n` below is a proof index for the represented
call trajectory, not a program input. -/
theorem noCapRegister (A : M.Sym) (d c : ℕ)
    {x : I → List X} {t : I → ℕ}
    (h : ∀ i, (M.outcome (x i) (t i)).2 = true)
    (p : ∀ i T, T ≥ 2 → M.Gives A (x i) T (c*(Cost.bound d T+1))) :
    Tells x (fun i => Cost.bound d (t i+2)) (fun _ => 0)
      (fun i => M.outcome (x i) (t i)) := by
  classical
  let S i := Cost.bound d (t i+2)
  let cap (j : ℕ) := j+2
  let m i j := (M.outcome (x i) (cap j)).2 = true
  have l i : m i (t i) := by
    change (M.outcome (x i) (t i+2)).2 = true
    unfold outcome
    rw [M.absorbed (x i) (h i) 2]
    exact h i
  have v i : ∃ j, m i j := ⟨_,l i⟩
  let n i := Nat.find (v i)
  have b i : n i ≤ t i := Nat.find_min' (v i) (l i)
  have g i : m i (n i) := Nat.find_spec (v i)
  have fS : Fits S (fun i => t i+2) := capFits d (fun i => t i+2)
  have c' : ∀ {U : Type} (r : U → I) {a u : U → ℕ},
      ReComp x S r a (fun i => cap (u i)) → (∀ i, u i ≤ t (r i)) →
      Tells (fun i => x (r i)) (fun i => S (r i)) a
        (fun i => M.outcome (x (r i)) (cap (u i))) := by
    intro U r a u h l
    have j (i : U) : Cost.bound d (cap (u i)) ≤ S (r i) :=
      bound_mono d (Nat.add_le_add_right (l i) _)
    exact M.cappedRegister A d h ((Scaled.refl _).of_le j)
      ⟨c, fun i => (p (r i) (cap (u i)) (by unfold cap; omega)).mono
        (Nat.mul_le_mul_left _ (Nat.add_le_add_right (j i) _))⟩
  have w : Comp x S (fun _ => cap 0) (fun i => cap (n i)) := by
    apply Comp.loop n (fun _ j => cap j)
    · let f : Before n → I := fun i => i.1.1
      have e : Comp (fun i => x (f i)) (fun i => S (f i))
          (fun (i : Before n) => cap i.1.2) (fun i => cap i.1.2) :=
        Comp.refl ((fS.pull f).mono (fun i =>
          Nat.add_le_add_right (i.2.le.trans (b _)) _))
      exact e.plus1 -- cap(j+1)
    · let f : Through n → I := fun i => i.1.1
      let s := fun (i : Through n) => i.1.2
      have z (i : Through n) : s i ≤ t (f i) := i.2.trans (b _)
      have v₁ : Comp (fun i => x (f i)) (fun i => S (f i))
          (fun i => cap (s i)) (fun i => cap (s i)) := Comp.refl
        ((fS.pull f).mono (fun i => Nat.add_le_add_right (z i) _))
      apply (Entry.finite_map (fun v : M.Outcome => (!v.2).toNat) (c' f v₁ z)).congr
      intro i
      have w : s i ≤ n (f i) := i.2
      change (!(M.outcome (x (f i)) (cap (s i))).2).toNat =
        (decide (s i < n (f i))).toNat
      rcases w.lt_or_eq with e|e
      · have y := Nat.find_min (v (f i)) e
        change (M.outcome _ _).2 ≠ true at y
        simp [e,Bool.eq_false_iff.mpr y]
      · rw [e, g (f i)]
        simp
  have j := c' id w b
  refine (Comp.trans (Comp.constant (Fits.const S 0) (cap 0)) j).congr
    (fun i => congrArg code (M.stable (x i) (g i) (h i)))
end Fifths.Single

end OAI