import OAI.Computability.SpaceSimulation.Epoch.Core
import OAI.Computability.SpaceSimulation.Evaluation.Circuit

namespace OAI

/-! Lay out the implicit word graph in flat (epoch,column) order. -/
namespace Fifths
namespace Tour
open Radix Bin Circuit
variable (D : Tour)

/-- First N array columns, then start and k round history columns. -/
def stride := D.N+D.k+1
def total := D.E*D.stride
abbrev Vertex := Fin D.total
theorem stride_pos : 0 < D.stride := Nat.zero_lt_succ _
theorem total_pos : 0 < D.total := Nat.mul_pos (Nat.zero_lt_succ _) D.stride_pos

def epoch (v : D.Vertex) := v.val / D.stride
def col (v : D.Vertex) := v.val % D.stride
def mkV (e j : ℕ) : D.Vertex :=
  ⟨(e*D.stride + j) % D.total,Nat.mod_lt _ D.total_pos⟩
def hV (e j : ℕ) := D.mkV e (D.N+j)

theorem epoch_lt (v : D.Vertex) : D.epoch v < D.E :=
  (Nat.div_lt_iff_lt_mul D.stride_pos).mpr v.isLt
theorem col_lt (v : D.Vertex) : D.col v < D.stride := Nat.mod_lt _ D.stride_pos
theorem re_V (v : D.Vertex) : D.mkV (D.epoch v) (D.col v) = v := by
  apply Fin.ext
  have e := Nat.mod_add_div v.val D.stride
  unfold mkV epoch col
  dsimp
  rw [mul_comm,add_comm,e,Nat.mod_eq_of_lt v.isLt]
theorem mkV_val {e j : ℕ} (p : e<D.E) (h : j < D.stride) :
    (D.mkV e j).val = e*D.stride+j := by
  unfold mkV; dsimp
  apply Nat.mod_eq_of_lt
  unfold total
  nlinarith only [p,h,Nat.zero_le e,D.stride_pos]
theorem epoch_v {e j : ℕ} (p : e < D.E) (h : j < D.stride) :
    D.epoch (D.mkV e j) = e := by
  unfold epoch
  rw [D.mkV_val p h, add_comm, mul_comm,Nat.add_mul_div_left]
  · rw [Nat.div_eq_of_lt h,Nat.zero_add]
  · exact D.stride_pos
theorem col_v {e j : ℕ} (p : e < D.E) (h : j < D.stride) :
    D.col (D.mkV e j) = j := by
  unfold col
  rw [D.mkV_val p h,add_comm]
  simp [Nat.mod_eq_of_lt h]

/-- Round index 0 on array columns too, so all calls can parse
their local functions in uniform space regardless of type. -/
def round (v : D.Vertex) := D.col v - D.N
theorem round_le (v : D.Vertex) : D.round v ≤ D.k := by
  have h := D.col_lt v
  unfold round
  unfold stride at h
  omega

def valueOf (v : D.Vertex) :=
  let e := D.epoch v * D.b
  if D.col v < D.N then (D.story e).cells (D.col v)
  else D.log e (D.round v*D.k)
def firstOf (v : D.Vertex) :=
  if D.col v < D.N then D.tape (D.col v) else D.init

def baseOf (v : D.Vertex) :=
  decide (D.epoch v = 0) && decide (D.col v ≤ D.N)
def guesses (v : D.Vertex) :=
  if D.col v ≤ D.N then 0 else D.guessLength

def header (v : D.Vertex) :=
  if D.col v ≤ D.N then D.hV (D.epoch v - 1) D.k
  else D.hV (D.epoch v) (D.round v - 1)
def childrenOf (v : D.Vertex) (i : ℕ) :=
  if D.col v < D.N then D.mkV (D.epoch v - 1) (D.col v)
  else if D.col v = D.N then D.header v
  else D.mkV (D.epoch v) i

def proposal (v : D.Vertex) (h y : ℕ) :=
  let n := (D.round v-1)*D.k + 1
  h % D.m^n + D.m^n*y -- `y` full guess (possibly invalid at local-only inputs)

def offer (v : D.Vertex) (z y h : ℕ) :=
  if D.col v < D.N then 1
  else if D.col v = D.N then Modulus.augBit D.width (get D.m h D.b) z
  else Modulus.augBit D.width (D.proposal v h y) z

def validAt (v : D.Vertex) (z y i h a : ℕ) :=
  if D.col v < D.N then
    if i = 0 then
      Modulus.augBit D.width (D.replay (D.col v) h a D.b).1 z
    else 1
  else if D.col v = D.N then 1
  else (D.replay i (D.proposal v h y) a (D.round v*D.k)).2.toNat

def circuit : Circuit where
  width := D.width
  count := D.N
  nodes := D.total
  base := D.baseOf
  head := D.header
  child := D.childrenOf
  guessing := D.guesses
  first := D.firstOf
  propose := D.offer
  allows := D.validAt
  semantic := D.valueOf

def target : D.Vertex := D.hV (D.E-1) D.k
-- meter values
def coinsEasy := D.circuit.price 0
def coinsHard := D.circuit.price D.guessLength
def per := D.coinsHard + (D.k+2) * D.coinsEasy
def coins (v : D.Vertex) :=
  let a := D.epoch v * D.per
  if D.col v < D.N then a
  else a + D.coinsHard + (D.round v+1)*D.coinsEasy

-- flat-coordinates API
theorem hc {e j} (p : e < D.E) (h : j ≤ D.k) :
    D.col (D.hV e j) = D.N+j := D.col_v p (by unfold stride; omega)
theorem he {e j} (p : e < D.E) (h : j ≤ D.k) :
    D.epoch (D.hV e j) = e := D.epoch_v p (by unfold stride; omega)
theorem hr {e j} (p : e < D.E) (h : j ≤ D.k) :
    D.round (D.hV e j) = j := by rw [round,D.hc p h]; omega
theorem ac {e j} (p : e < D.E) (h : j < D.N) :
    D.col (D.mkV e j) = j := D.col_v p (lt_of_lt_of_le h (by unfold stride; omega))
theorem ae {e j} (p : e < D.E) (h : j < D.N) :
    D.epoch (D.mkV e j) = e := D.epoch_v p (lt_of_lt_of_le h (by unfold stride; omega))
theorem at_array {e i} (h : e < D.E) (g : i < D.N) :
    D.valueOf (D.mkV e i) = (D.story (e*D.b)).cells i := by
  simp only [valueOf,D.ae h g,D.ac h g,g,↓reduceIte]
theorem at_history {e j} (h : e < D.E) (g : j ≤ D.k) :
    D.valueOf (D.hV e j) = D.log (e*D.b) (j*D.k) := by
  simp only [valueOf,D.he h g,D.hc h g,D.hr h g,show ¬ D.N+j<D.N by omega,↓reduceIte]

/-- Useful for correctness proofs. -/
theorem either (v : D.Vertex) :
    (∃ e < D.E, ∃ j < D.N, v = D.mkV e j) ∨
    (∃ e < D.E, ∃ j ≤ D.k, v = D.hV e j) := by
  by_cases h : D.col v < D.N
  · exact .inl ⟨D.epoch v,D.epoch_lt v,D.col v,h,(D.re_V v).symm⟩
  · refine .inr ⟨D.epoch v,D.epoch_lt v,D.round v,D.round_le v,?_⟩
    unfold hV round
    rw [show D.N+(D.col v-D.N) = D.col v by omega]
    exact (D.re_V v).symm
end Tour
end Fifths

end OAI