import OAI.Computability.StarHeight.SplitMetadata

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uT uP uC uM uS uK uM2 uM3
universe uM4

namespace ClockAffine

open scoped Classical
open RobustClock

variable {T : Type uT} {P : Type uP} {C : Type uC} {M : Type uM} {S : Type uS} {K : Type uK} [Fintype T] [Fintype P] [Fintype C]
  [Monoid M] [Field K] [AddCommGroup S] [Module K S]

variable (clock : Specification T P C)

def Edge (z : C → RobustClock.Circle) (a b : T) : Prop :=
  ∃ i ∈ clock.I a, ∃ j ∈ clock.J b, i + j = z

noncomputable def offChoice (z : C → RobustClock.Circle) : Option (T × T) :=
  if h : ∃ ab : T × T, ab.1 ≠ ab.2 ∧ Edge clock z ab.1 ab.2 then some h.choose else none

lemma offChoice_some {z : C → RobustClock.Circle} {ab : T × T}
    (he : offChoice clock z = some ab) :
    ab.1 ≠ ab.2 ∧ Edge clock z ab.1 ab.2 ∧
      ∀ a b, Edge clock z a b → a = ab.1 ∧ b = ab.2 := by
  classical
  unfold offChoice at he
  split_ifs at he with hx
  · have hab := Option.some.inj he
    have hh := hab ▸ hx.choose_spec
    refine ⟨hh.1,hh.2,?_⟩
    rcases clock.graph z with hd | ⟨a,b,_,_,hu⟩
    · exact False.elim (hh.1 (hd _ _ hh.2))
    · have ht := hu _ _ hh.2
      intro a' b' he'
      exact ⟨(hu _ _ he').1.trans ht.1.symm,(hu _ _ he').2.trans ht.2.symm⟩

lemma offChoice_none {z : C → RobustClock.Circle} (he : offChoice clock z = none)
    {a b : T} (hab : Edge clock z a b) : a = b := by
  classical
  by_contra hn
  have hx : ∃ ab : T × T, ab.1 ≠ ab.2 ∧ Edge clock z ab.1 ab.2 := ⟨(a,b),hn,hab⟩
  simp only [offChoice,dite_eq_left hx] at he
  cases he

lemma offChoice_of_offedge {z : C → RobustClock.Circle} {a b : T}
    (hn : a ≠ b) (he : Edge clock z a b) : offChoice clock z = some (a,b) := by
  cases hh : offChoice clock z with
  | none => exact False.elim (hn (offChoice_none clock hh he))
  | some ab =>
    have hp := (offChoice_some clock hh).2.2 _ _ he
    rcases ab with ⟨a',b'⟩
    dsimp at hp
    rcases hp with ⟨rfl,rfl⟩
    rfl

lemma edge_add (φ : ℤ →+ (C → RobustClock.Circle)) {q t k : ℤ} {a b : T}
    (hp : φ (k-t) ∈ clock.I a) (hs : φ (q-k) ∈ clock.J b) :
    Edge clock (φ (q-t)) a b := by
  refine ⟨_,hp,_,hs,?_⟩
  rw [← map_add]
  congr 1
  ring

variable (ρ : M → (S →ₗ[K] S))

def productTable {g : ℕ} (A C : M) (d : Fin g → M) : S →ₗ[K] S :=
  ρ (A * (List.ofFn d).prod * C)

structure Factors (M : Type uM2) (g : ℕ) where
  A : M
  entries : Fin g → M
  C : M

structure Snapshot (M : Type uM3) [Monoid M] (g : ℕ) where
  product : M
  boundaries : Option (Factors M g)
  product_eq : ∀ f, boundaries = some f → product = f.A * (List.ofFn f.entries).prod * f.C

variable {g : ℕ}
variable (β : M → M → (Fin g → M) → S) (X Y : T → S)

noncomputable def shift (z : C → RobustClock.Circle) (D : Snapshot M g) : S :=
  match offChoice clock z with
  | some ab => Y ab.2 - ρ D.product (X ab.1)
  | none => match D.boundaries with
    | none => 0
    | some f => β f.A f.C f.entries

noncomputable def update (z : C → RobustClock.Circle) (D : Snapshot M g) (x : S) : S :=
  ρ D.product x + shift clock ρ β X Y z D

lemma update_off {z : C → RobustClock.Circle} {a b : T} (D : Snapshot M g)
    (hn : a ≠ b) (he : Edge clock z a b) :
    update clock ρ β X Y z D (X a) = Y b := by
  simp only [update,shift,offChoice_of_offedge clock hn he]
  abel

lemma update_main {z : C → RobustClock.Circle} {f : Factors M g} (D : Snapshot M g)
    (hc : offChoice clock z = none) (hf : D.boundaries = some f) (x : S) :
    update clock ρ β X Y z D x = productTable ρ f.A f.C f.entries x + β f.A f.C f.entries := by
  simp only [update,shift,hc,hf,productTable,D.product_eq f hf]

lemma update_periodic {z : C → RobustClock.Circle} (D : Snapshot M g)
    (hc : offChoice clock z = none) (hf : D.boundaries = none) (x : S) :
    update clock ρ β X Y z D x = ρ D.product x := by
  simp only [update,shift,hc,hf,add_zero]

lemma independent_pair {z : C → RobustClock.Circle} {a b : T} (D : Snapshot M g)
    (he : Edge clock z a b)
    (hdiag : a = b → offChoice clock z = none →
      ρ D.product (X a) + (match D.boundaries with
        | none => 0
        | some f => β f.A f.C f.entries) = Y b) :
    update clock ρ β X Y z D (X a) = Y b := by
  cases hc : offChoice clock z with
  | none =>
    have hab := offChoice_none clock hc he
    simpa only [update,shift,hc] using hdiag hab hc
  | some ab =>
    have hh := offChoice_some clock hc
    have hab := hh.2.2 _ _ he
    have hn : a ≠ b := fun heq => hh.1 (hab.1.symm.trans (heq.trans hab.2))
    exact update_off clock ρ β X Y D hn he

structure Later (M : Type uM4) [Monoid M] (g : ℕ) where
  tailProduct : M
  boundaries : Option (Factors M g)
  tail_eq : ∀ f, boundaries = some f → tailProduct = f.A * (List.ofFn f.entries).prod * f.C

def Later.substitute (D : Later M g) (m : M) : Snapshot M g where
  product := m * D.tailProduct
  boundaries := D.boundaries.map (fun f => ⟨m * f.A,f.entries,f.C⟩)
  product_eq := by
    intro f hf
    obtain ⟨a,ha,hf⟩ := Option.map_eq_some_iff.mp hf
    subst f
    simp only [D.tail_eq a ha,mul_assoc]

noncomputable def hypothetical (z : C → RobustClock.Circle) (D : Later M g) :
    M → (S × K →ₗ[K] S × K) := fun m =>
  Homogenization.lift (ρ (m * D.tailProduct))
    (shift clock ρ β X Y z (D.substitute m))

lemma hypothetical_at (z : C → RobustClock.Circle) (D : Later M g) (m : M) (x : S) :
    hypothetical clock ρ β X Y z D m (x,1) =
      (update clock ρ β X Y z (D.substitute m) x,1) := by
  simp only [hypothetical,Homogenization.lift_apply_one,update,Later.substitute]

lemma hypothetical_actual (z : C → RobustClock.Circle) (D : Later M g) (m : M) :
    hypothetical clock ρ β X Y z D m =
      Homogenization.lift (ρ (D.substitute m).product)
        (shift clock ρ β X Y z (D.substitute m)) := rfl

end ClockAffine

end GeneralizedStarHeight

end OAI