import OAI.Computability.SpaceSimulation.Register.Loop
import OAI.Computability.SpaceSimulation.Stack.Count

namespace OAI

namespace Fifths
namespace Comp
variable {X I : Type} {x : I → List X} {S a b : I → ℕ}
open Bin

theorem ticks (inc : Bool) (h : Fits S a) : Comp x S a
    (fun i => if inc then a i + 1 else a i - 1) := by
  let k : Unit ⊕ Unit := .inl ()
  let t : Unit ⊕ Unit := .inr ()
  refine checkSized (SM.carry inc k t) h (fun i B p => ?_)
  let v := singleton Unit (a i)
  have r : v.ok B := Store.ok_extra.mpr (file_ok.mpr
    (le_trans (Nat.le_succ _) p))
  have l : (v.st k).length + (v.st t).length + 1 ≤ B := by
    change (a i).bits.length + 0 + 1 ≤ B
    simpa only [Nat.add_zero, Nat.size_eq_bits_len] using p
  have e := SM.exec_carry (i := files (x i)) inc k t (by simp [k,t]) r l
  have g : SM.carried v inc k t =
      singleton Unit (if inc then a i+1 else a i-1) := by
    unfold SM.carried
    rw [show v.set t [] = v from Store.set_self v t]
    rw [show v.st t = [] from rfl, List.reverse_nil, List.nil_append,
      show v.st k = (a i).bits from rfl]
    cases inc
    · rw [tick_dec]; exact singleton_set _ _ _
    · rw [tick_inc]; exact singleton_set _ _ _
  rw [g] at e
  exact e

theorem plus1 (h : Comp x S a b) : Comp x S a (fun i => b i + 1) :=
  h.trans (ticks true h.target)
theorem minus1 (h : Comp x S a b) : Comp x S a (fun i => b i - 1) :=
  h.trans (ticks false h.target)

def notZero (n : ℕ) : Bool := n != 0

theorem notZero_eq (n : ℕ) : n.bits.head?.isSome = notZero n := by
  by_cases h : n = 0
  · subst n; simp [notZero]
  have e : n.bits ≠ [] := by simpa using h
  cases v : n.bits with
  | nil => contradiction
  | cons a b => simp [notZero,h]

theorem testnz (h : Comp x S a b) :
    Comp x S a (fun i => (notZero (b i)).toNat) := by
  refine h.trans ?_
  let k : Unit ⊕ Unit := .inl ()
  let M (c : Bool) : SM X Empty (Unit ⊕ Unit) Unit :=
    (SM.clear k).seq (SM.prepend k c.toNat.bits)
  refine checkSized ((SM.peek (fun _ s => (s k).isSome)).bind M)
    h.target (fun i B p => ?_)
  let v := singleton Unit (b i)
  have o : v.ok B := Store.ok_extra.mpr (file_ok.mpr (le_trans (Nat.le_succ _) p))
  have eqn := (show (v.see k).isSome = notZero (b i) from notZero_eq _)
  refine SM.exec_bind _ _ (y := notZero (b i))
    (show (SM.peek _).Exec (files (x i)) B v v _ from eqn ▸ SM.exec_peek o) ?_
  have e := SM.exec_clear (i := files (x i)) k o
  have g (c : Bool) : (M c).Exec (files (x i)) B v
      (singleton Unit c.toNat) () := by
    have j : B ≥ 1 := by omega
    have u := SM.exec_prepend (i := files (x i)) k c.toNat.bits e.endOk
      (by cases c <;> simp [j])
    simp only [Store.set_same,List.append_nil,Store.set_set] at u
    rw [show k = .inl () from rfl,singleton_set] at u
    exact SM.exec_seq e u
  exact g _

/-- Accumulating loop. PC logic keeps the original argument, a
remaining count, a current index, and the accumulator. Time for the
counted loop is not charged. -/
theorem fold {n : I → ℕ} (v : I → ℕ → ℕ) (cnt : Comp x S a n)
    (ini : Comp x S a (fun i => v i 0))
    (sizes : Fits (fun i : Through n => S i.1.1) (fun i => v i.1.1 i.1.2))
    (advance : ∀ e : Before n → ℕ,
      Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e (fun i => a i.1.1) →
      Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e (fun i => i.1.2) →
      Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e (fun i => v i.1.1 i.1.2) →
      Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) e
        (fun i => v i.1.1 (i.1.2+1))) :
    Comp x S a (fun i => v i (n i)) := by
  let z : I → ℕ → ℕ :=
    fun i j => Bin.pair (a i) (Bin.pair j (Bin.pair (n i-j) (v i j)))
  have c : Comp x S a (fun i => z i 0) :=
    ((Comp.refl cnt.source).pair
      ((Comp.constant cnt.source 0).pair (cnt.pair ini)))
  suffices w : Comp x S (fun i => z i 0) (fun i => z i (n i)) from
    (c.trans w).right.right.right
  have zsize : Fits (fun i : Through n => S i.1.1) (fun i => z i.1.1 i.1.2) := by
    let f : Through n → I := fun i => i.1.1
    have h := cnt.target.pull f
    refine (cnt.source.pull f).pair ((h.mono ?_).pair ((h.mono ?_).pair sizes))
    · exact fun i => i.2
    · intro i
      exact Nat.sub_le _ _
  apply loop n z
  · let f : Before n → Through n := fun i => ⟨i.val,i.property.le⟩
    have h : Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1)
        (fun i => z i.1.1 i.1.2) (fun i => z i.1.1 i.1.2) :=
      Comp.refl (zsize.pull f)
    have w := advance _ h.left h.right.left h.right.right.right
    have g := h.left.pair
      (h.right.left.plus1.pair (h.right.right.left.minus1.pair w))
    exact g.congr (fun i => by
      rw [show n i.1.1-i.1.2-1 = n i.1.1 - (i.1.2+1) by omega])
  · have h : Comp (fun i : Through n => x i.1.1) (fun i => S i.1.1)
        (fun i => z i.1.1 i.1.2) (fun i => z i.1.1 i.1.2) :=
      Comp.refl zsize
    refine h.right.right.left.testnz.congr (fun i => ?_)
    by_cases e : i.1.2 < n i.1.1
    · simp [notZero,e,Nat.ne_of_gt (Nat.sub_pos_of_lt e)]
    · simp [notZero,e,Nat.sub_eq_zero_of_le (Nat.le_of_not_gt e)]

end Comp
end Fifths

end OAI