import OAI.Computability.StarHeight.StreamRecovery

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uAlphabet uAlphabet2 uAlphabet3 uJ uC uAlphabet4 uT uP
universe uC2 uAlphabet5 uJ2 uC3

namespace SourceSchedule

structure Late (Alphabet : Type uAlphabet) (B : ℕ) (h w E earlyLast : ℤ) where
  endRule : CanonicalEpisodes.Parameters Alphabet
  lag : ℤ
  modulus : endRule.B=B
  spacing : 4*(h+w+1) < endRule.S
  separation : 10*(B:ℤ)*endRule.S+10*(h+w+1) < endRule.d
  lag_pos : 0 < lag
  lag_margin : earlyLast < lag-E
  offset_margin : E < endRule.offset-(2*w+endRule.width+endRule.rule.r+endRule.K+1)
  tail_margin : (endRule.d:ℤ)+(endRule.B-1)*endRule.S+
    (2*w+endRule.width+endRule.rule.r+endRule.K+1) < endRule.tail

lemma exists_late {Alphabet : Type uAlphabet2} [Fintype Alphabet] (B : ℕ) (hB : 0 < B)
    (h w E earlyLast : ℤ) (hh : 0 ≤ h) (hw : 0 ≤ w) (hE : 0 ≤ E) :
    Nonempty (Late Alphabet B h w E earlyLast) := by
  let S : ℤ := 4*(h+w+1)+1
  have hS : 0 ≤ S := by dsimp [S];omega
  let D : ℤ := 10*(B:ℤ)*S+10*(h+w+1)
  have hD : 0 ≤ D := by dsimp [D];positivity
  let d : ℕ := D.toNat+2
  have hd : (d:ℤ)=D+2 := by simp only [d,Nat.cast_add,Int.toNat_of_nonneg hD,Nat.cast_ofNat]
  have hd₂ : 2 ≤ d := by dsimp [d];omega
  let K : ℕ := 3*d^2+1
  obtain ⟨rule⟩ := LocalMarkers.nonempty_rule (Alphabet := Alphabet) (d := d) (K := K) hd₂
    (show 3*d^2<K by dsimp [K];omega)
  let width : ℤ := 3*d+((B:ℤ)-1)*S
  have hwidth : 0 ≤ width := by
    have hBb : (0:ℤ) ≤ (B:ℤ)-1 := by
      have : (1:ℤ) ≤ B := by exact_mod_cast hB
      omega
    dsimp [width];positivity
  let endE : ℤ := 2*w+width+rule.r+K+1
  have hr := rule.radius_ge
  have hendE : 0 ≤ endE := by dsimp [endE];omega
  let tail : ℤ := d+((B:ℤ)-1)*S+endE+2
  have htail : 0 < tail := by
    have hBb : (0:ℤ) ≤ (B:ℤ)-1 := by
      have : (1:ℤ) ≤ B := by exact_mod_cast hB
      omega
    dsimp [tail];positivity
  let er : CanonicalEpisodes.Parameters Alphabet :=
    ⟨B,S,d,K,E+endE+1,tail,rule,by exact_mod_cast hB,hS,hd₂,
      by dsimp [K];omega,htail⟩
  refine ⟨⟨er,|earlyLast|+E+1,rfl,?_,?_,?_,?_,?_,?_⟩⟩
  · dsimp [er,S];omega
  · change D < (d:ℤ);omega
  · positivity
  · have := le_abs_self earlyLast;omega
  · change E < E+endE+1-endE;omega
  · change (d:ℤ)+((B:ℤ)-1)*S+endE < tail
    dsimp [tail];omega

namespace Late

variable {Alphabet : Type uAlphabet3} {B : ℕ} {h w E earlyLast : ℤ}
    (L : Late Alphabet B h w E earlyLast)

lemma radius_nonneg : 0 ≤ L.endRule.rule.r :=
  (show (0:ℤ) ≤ L.endRule.K by positivity).trans L.endRule.rule.radius_ge

lemma overlap (hh : 0 ≤ h) (hw : 0 ≤ w) :
    (L.endRule.d:ℤ)^2+w ≤ L.endRule.K := by
  have hd := L.separation
  have hS := L.endRule.S_nonneg
  have hprod : 0 ≤ 10*(B:ℤ)*L.endRule.S := by positivity
  have hseed : 3*(L.endRule.d:ℤ)^2 < L.endRule.K := by exact_mod_cast L.endRule.seed_long
  have hd₂ : (2:ℤ) ≤ L.endRule.d := by exact_mod_cast L.endRule.d_ge
  nlinarith

lemma complete_lower {f : ℤ → Alphabet} {s b : ℤ}
    (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f
      (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) :
    s+L.lag+L.endRule.offset+(2*w+L.endRule.width+L.endRule.rule.r+L.endRule.K+1) < b := by
  have hb := L.endRule.end_lower he
  have ht := L.tail_margin
  omega

lemma visible {J : Type uJ} {C : Type uC} (A : ExceptionalOrigins.Parameters Alphabet J C)
    (heq : A.endRule=L.endRule) (hw : A.w=w) (hwpos : 0 ≤ w) (hE : 0 ≤ E)
    (hinleft : ∀ j, -E ≤ A.offset j-w-A.w₀-A.innerRule.r)
    (hinright : ∀ j u, A.offset j+w+A.H u+max A.ext A.w₀+A.innerRule.r ≤ E)
    {f : ℤ → Alphabet} {s b δ Q : ℤ} (hδ : |δ| ≤ w)
    (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f
      (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) :
    A.Visible (s+earlyLast) b (s+L.lag+δ) Q := by
  have hlo := L.lag_margin
  have hoff := L.offset_margin
  have hb := L.complete_lower he
  have hδ' := abs_le.mp hδ
  have hr := L.radius_nonneg
  have hwidth := L.endRule.width_nonneg
  have hK : (0:ℤ) ≤ L.endRule.K := by positivity
  have hlower : s+earlyLast < s+L.lag-E := by omega
  refine ⟨?_,?_,?_⟩
  · rw [heq]
    refine ⟨?_,?_,?_,?_⟩ <;> omega
  · intro v _ hav
    rw [hw] at hav
    have hv := abs_le.mp hav
    rw [heq]
    constructor <;> omega
  · intro j
    have hj := hinleft j
    have hj' := hinright j (A.residue (Q-(s+L.lag+δ)))
    have hEend : 0 ≤ 2*w+L.endRule.width+L.endRule.rule.r+L.endRule.K+1 := by omega
    constructor <;> omega

end Late

end SourceSchedule

namespace SourceSchedule

noncomputable def finiteBound (F : Finset ℤ) : ℕ := F.sup Int.natAbs

lemma abs_le_finiteBound {F : Finset ℤ} {x : ℤ} (hx : x ∈ F) :
    |x| ≤ (finiteBound F:ℤ) := by
  have hh : x.natAbs ≤ finiteBound F := Finset.le_sup (f := Int.natAbs) hx
  simpa only [Int.natCast_natAbs] using (show (x.natAbs:ℤ) ≤ finiteBound F by exact_mod_cast hh)

namespace Early

open scoped BigOperators

variable {Alphabet : Type uAlphabet4} {T : Type uT} {P : Type uP} {C : Type uC2} [Fintype T] [Fintype P] [Fintype C]
    {g' B size : ℕ} {clock : RobustClock.Specification T P C}
    {label : P → Fin g'} {reserved : P → ℤ}
    (S : Early (Alphabet := Alphabet) clock B size label reserved)

noncomputable def period : ℕ := ∏ c, S.denominator c

lemma period_pos : 0 < S.period := Finset.prod_pos (fun c _ => (S.prime c).pos)

noncomputable def cuts (g : ℕ) : OuterStream.Cuts g B where
  main j := S.inner.mainBase j.val
  periodic j u := S.inner.periodicOffset j.val u 0
  R := S.R
  N := S.period * innerD S.p (B*S.R) * size.factorial
  R_pos := S.R_pos
  N_pos := Nat.mul_pos (Nat.mul_pos S.period_pos (by have := innerD_ge S.p (B*S.R);omega))
    (Nat.factorial_pos _)

noncomputable def diameter : ℤ := 2*(absoluteBound S.p:ℤ)+1

lemma diameter_pos : 0 < S.diameter := by dsimp [diameter];positivity

noncomputable def sweepWidth (g : ℕ) : ℤ :=
  2*S.diameter+2*(finiteBound (S.cuts g).offsets:ℤ)+1

lemma sweepWidth_large (g : ℕ) : 2*S.diameter < S.sweepWidth g := by
  dsimp [sweepWidth];omega

lemma sweepWidth_pos (g : ℕ) : 0 < S.sweepWidth g := by
  have := S.diameter_pos;have := S.sweepWidth_large g;omega

lemma offsets_difference (g : ℕ) {a b : ℤ} (ha : a ∈ (S.cuts g).offsets)
    (hb : b ∈ (S.cuts g).offsets) : |a-b| < S.sweepWidth g := by
  have ha' := abs_le_finiteBound ha
  have hb' := abs_le_finiteBound hb
  have hh := abs_sub a b
  have hd := S.diameter_pos
  dsimp [sweepWidth]
  omega

lemma stencil_difference (g : ℕ) (i j : P) : |S.p i-S.p j| < S.sweepWidth g := by
  have hh := difference_bound S.p i j
  have hw := S.sweepWidth_large g
  have hd := S.diameter_pos
  change |S.p i-S.p j| ≤ S.diameter at hh
  omega

noncomputable def envelope (g : ℕ) : ℤ :=
  S.sweepWidth g+2*|((B*S.R:ℕ):ℤ)|+|S.rule.r|+
    (absoluteBound (fun j : Fin (g+1) => S.inner.boundary j.val):ℤ)+
    (absoluteBound S.inner.H:ℤ)+|S.inner.extension|+
    (3*(innerD S.p (B*S.R))^2+1:ℕ)+
    (size*innerD S.p (B*S.R):ℕ)+(finiteBound (S.cuts g).offsets:ℤ)+1

lemma envelope_pos (g : ℕ) : 0 < S.envelope g := by
  have := S.sweepWidth_pos g
  dsimp [envelope];positivity

lemma inner_left (g : ℕ) (j : Fin (g+1)) :
    -S.envelope g ≤ S.inner.boundary j.val-S.sweepWidth g-(B*S.R:ℕ)-S.rule.r := by
  have hj := abs_le_absoluteBound (fun j : Fin (g+1) => S.inner.boundary j.val) j
  have hab := neg_abs_le (S.inner.boundary j.val)
  have hr := le_abs_self S.rule.r
  have hw := le_abs_self ((B*S.R:ℕ):ℤ)
  have hH : (0:ℤ) ≤ absoluteBound S.inner.H := by positivity
  have := abs_nonneg S.inner.extension
  have := abs_nonneg ((B*S.R:ℕ):ℤ)
  have := sq_nonneg (innerD S.p (B*S.R):ℤ)
  have : (0:ℤ) ≤ (size:ℤ)*(innerD S.p (B*S.R):ℤ) :=
    mul_nonneg (Int.natCast_nonneg _) (Int.natCast_nonneg _)
  simp only [envelope,Nat.cast_add,Nat.cast_mul,Nat.cast_pow,Nat.cast_one,Nat.cast_ofNat]
  simp only [Nat.cast_mul] at *
  omega

lemma inner_right (g : ℕ) (j : Fin (g+1)) (u : Fin B) :
    S.inner.boundary j.val+S.sweepWidth g+S.inner.H u+
      max S.inner.extension (B*S.R:ℕ)+S.rule.r ≤ S.envelope g := by
  have hj := (le_abs_self (S.inner.boundary j.val)).trans
    (abs_le_absoluteBound (fun j : Fin (g+1) => S.inner.boundary j.val) j)
  have hH := (le_abs_self (S.inner.H u)).trans (abs_le_absoluteBound S.inner.H u)
  have hr := le_abs_self S.rule.r
  have he := le_abs_self S.inner.extension
  have hw := le_abs_self ((B*S.R:ℕ):ℤ)
  have hwpos := abs_nonneg ((B*S.R:ℕ):ℤ)
  have hepos := abs_nonneg S.inner.extension
  have hm : max S.inner.extension (B*S.R:ℕ) ≤ |S.inner.extension|+|((B*S.R:ℕ):ℤ)| := by
    apply max_le <;> omega
  have := sq_nonneg (innerD S.p (B*S.R):ℤ)
  have : (0:ℤ) ≤ (size:ℤ)*(innerD S.p (B*S.R):ℤ) :=
    mul_nonneg (Int.natCast_nonneg _) (Int.natCast_nonneg _)
  simp only [envelope,Nat.cast_add,Nat.cast_mul,Nat.cast_pow,Nat.cast_one,Nat.cast_ofNat]
  simp only [Nat.cast_mul] at *
  omega

lemma exists_full_late [Fintype Alphabet] (hB : 0 < B) (g : ℕ) :
    Nonempty (Late Alphabet B S.diameter (S.sweepWidth g) (S.envelope g) (S.β (Fin.last g'))) :=
  exists_late B hB _ _ _ _ S.diameter_pos.le (S.sweepWidth_pos g).le (S.envelope_pos g).le

variable (g : ℕ) (L : Late Alphabet B S.diameter (S.sweepWidth g) (S.envelope g) (S.β (Fin.last g')))

noncomputable def parameters (hB : 0 < B) : ExceptionalOrigins.Parameters Alphabet (Fin (g+1)) C where
  endRule := L.endRule
  d := innerD S.p (B*S.R)
  K := 3*(innerD S.p (B*S.R))^2+1
  B := B
  B_pos := hB
  end_modulus := L.modulus
  innerRule := S.rule
  offset j := S.inner.boundary j.val
  H := S.inner.H
  w := S.sweepWidth g
  w₀ := (B*S.R:ℕ)
  ext := S.inner.extension
  φ := PeriodicClock.speedMap (fun c => (S.numerator c:ℝ)/S.denominator c)
  W := clock.W

lemma geometry (hB : 0 < B) : OuterStream.Geometry (S.parameters g L hB) (S.cuts g) := by
  have hw := (S.sweepWidth_pos g).le
  have hr := L.radius_nonneg
  have hwidth := L.endRule.width_nonneg
  have hK : (0:ℤ) ≤ L.endRule.K := by positivity
  have he := (S.envelope_pos g).le
  have hbound : ∀ a ∈ (S.cuts g).offsets, |a| ≤ S.envelope g := by
    intro a ha
    have hh := abs_le_finiteBound ha
    have hw' := S.sweepWidth_pos g
    dsimp [envelope]
    have hrest : 0 ≤ 2*|((B*S.R:ℕ):ℤ)|+|S.rule.r|+
        (absoluteBound (fun j : Fin (g+1) => S.inner.boundary j.val):ℤ)+
        (absoluteBound S.inner.H:ℤ)+|S.inner.extension|+
        (3*(innerD S.p (B*S.R))^2+1:ℕ)+(size*innerD S.p (B*S.R):ℕ) := by positivity
    push_cast at *
    omega
  refine ⟨?_,?_,?_,?_,?_,?_⟩
  · intro role
    cases role with
    | inl j => simpa only [parameters,cuts,OuterStream.Cuts.base,IntegerSchedules.Inner.mainOffset,Nat.cast_zero,zero_mul,add_zero]
        using S.inner.main_multiple j.val 0
    | inr ju => exact S.inner.periodic_multiple ju.1.val ju.2 0
  · intro u i j hij
    have hh := (S.inner.halfGap_large hB (by have := S.rule.radius_ge;omega)).1
    have hH := S.inner.H_bounded u
    have hgap := S.inner.gap_pos
    have hrule : 0 ≤ S.rule.r := (show (0:ℤ) ≤ 3*(innerD S.p (B*S.R))^2+1 by positivity).trans S.rule.radius_ge
    have hij' : (i.val:ℤ)+1 ≤ j.val := by exact_mod_cast (show i.val+1 ≤ j.val from hij)
    have hm := mul_le_mul_of_nonneg_right hij' (show 0 ≤ 2*S.inner.halfGap by positivity)
    change S.inner.boundary i.val+S.inner.H u ≤ S.inner.boundary j.val
    dsimp [IntegerSchedules.Inner.boundary]
    nlinarith
  · intro a ha
    have hh := (le_abs_self a).trans (hbound a ha)
    have hoff := L.offset_margin
    change a+L.endRule.width+L.endRule.rule.r ≤ L.endRule.offset
    omega
  · intro a ha b hb
    have hh := (le_abs_self (a-b)).trans (S.offsets_difference g ha hb).le
    have ht := L.tail_margin
    change a-b+L.endRule.width+L.endRule.rule.r+
      ((L.endRule.d:ℤ)+(L.endRule.B-1)*L.endRule.S) ≤ L.endRule.tail
    omega
  · intro a ha b hb
    have hh := (le_abs_self (a-b)).trans (S.offsets_difference g ha hb).le
    have ht := L.tail_margin
    change a-b+L.endRule.K+((L.endRule.d:ℤ)+(L.endRule.B-1)*L.endRule.S) ≤ L.endRule.tail
    omega
  · intro a ha b hb
    exact (add_le_add_right (S.offsets_difference g ha hb).le _).trans
      (L.overlap S.diameter_pos.le hw)

lemma actual_visible (hB : 0 < B) {f : ℤ → Alphabet} {s b δ Q : ℤ}
    (hδ : |δ| ≤ S.sweepWidth g)
    (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f
      (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) :
    (S.parameters g L hB).Visible (s+S.β (Fin.last g')) b (s+L.lag+δ) Q :=
  L.visible (S.parameters g L hB) rfl rfl (S.sweepWidth_pos g).le (S.envelope_pos g).le
    (S.inner_left g) (S.inner_right g) hδ he

end Early

end SourceSchedule

namespace ExceptionalOrigins.Parameters

variable {Alphabet : Type uAlphabet5} {J : Type uJ2} {C : Type uC3} (A : ExceptionalOrigins.Parameters Alphabet J C)

lemma not_failed_clock {f : ℤ → Alphabet} {t Q : ℤ} (hn : ¬A.Failed f t Q) :
    A.φ (Q-t) ∉ A.W := fun h => hn (Or.inr (Or.inl h))

lemma not_failed_inner {f : ℤ → Alphabet} {t Q δ : ℤ} (hn : ¬A.Failed f t Q)
    (hδ : |δ| ≤ A.w₀) (j : J) :
    A.inner f j (A.residue (Q-t)) (t+δ) = A.inner f j (A.residue (Q-t)) t := by
  by_contra he
  apply hn
  right;right
  refine ⟨j,Or.inl ⟨δ,hδ,?_⟩⟩
  simpa only [inner,add_right_comm t δ,add_right_comm (t+A.offset j) δ] using Ne.symm he

lemma not_failed_absent {f : ℤ → Alphabet} {t Q : ℤ} (hn : ¬A.Failed f t Q)
    (j : J) (hj : A.inner f j (A.residue (Q-t)) t = none) :
    ∀ x, t+A.offset j ≤ x → x ≤ t+A.offset j+A.H (A.residue (Q-t))+A.ext →
      x ∉ A.innerRule.markers f := by
  intro x hx hx' hm
  exact hn (Or.inr (Or.inr ⟨j,Or.inr ⟨hj,x,hm,hx,hx'⟩⟩))

lemma not_failed_end {f : ℤ → Alphabet} {t Q δ : ℤ} (hn : ¬A.Failed f t Q)
    (hδ : |δ| ≤ A.w) (hm : (A.B:ℤ) ∣ δ) :
    A.endRule.small f (t+δ+A.endRule.offset) = A.endRule.small f (t+A.endRule.offset) ∧
    A.endRule.large f (t+δ+A.endRule.offset) = A.endRule.large f (t+A.endRule.offset) := by
  constructor
  · by_contra he
    apply hn
    left;left
    refine ⟨δ,hm,hδ,?_⟩
    simpa only [CanonicalEpisodes.Parameters.small,←A.end_modulus,add_right_comm t δ]
      using Ne.symm he
  · by_contra he
    apply hn
    left;right
    refine ⟨δ,hm,hδ,?_⟩
    simpa only [CanonicalEpisodes.Parameters.large,←A.end_modulus,add_right_comm t δ]
      using Ne.symm he

end ExceptionalOrigins.Parameters

end GeneralizedStarHeight

end OAI