import OAI.LinearAlgebra.MatrixMultiplication.Recovery.Staggering
import Mathlib.Algebra.BigOperators.Group.Finset.Basic

namespace OAI

/-! Finite orbit symmetries, masks and exact recovery operations. -/

open scoped BigOperators

noncomputable section

namespace MatrixMultiplication.FiniteSchedule

open Staggering

def lotTick {K : ℕ} (j : Fin K) (stage : Fin 3) : ℕ := j.val + stage.val

theorem lotTick_lt {K : ℕ} (j : Fin K) (stage : Fin 3) :
    lotTick j stage < K + 2 := by
  have hj := j.isLt
  have hs := stage.isLt
  dsimp [lotTick]
  omega

def stageActive (K tick : ℕ) (stage : Fin 3) : Prop :=
  stage.val ≤ tick ∧ tick < K + stage.val

instance (K tick : ℕ) (stage : Fin 3) : Decidable (stageActive K tick stage) :=
  inferInstanceAs (Decidable (stage.val ≤ tick ∧ tick < K + stage.val))

theorem stageActive_iff_unique_lot (K tick : ℕ) (stage : Fin 3) :
    stageActive K tick stage ↔ ∃! j : Fin K, lotTick j stage = tick := by
  constructor
  · rintro ⟨hle, hlt⟩
    refine ⟨⟨tick - stage.val, by omega⟩, ?_, ?_⟩
    · dsimp [lotTick]
      omega
    · intro j hj
      apply Fin.ext
      dsimp [lotTick] at hj ⊢
      omega
  · rintro ⟨j, hj, _⟩
    have hjlt := j.isLt
    dsimp [stageActive, lotTick] at *
    omega

theorem lot_active_at_its_tick {K : ℕ} (j : Fin K) (stage : Fin 3) :
    stageActive K (lotTick j stage) stage := by
  have hj := j.isLt
  dsimp [stageActive, lotTick]
  omega

def tickCapacity (K : ℕ) (a b c : Capacity) (tick : ℕ) : Capacity := fun i =>
  (if stageActive K tick 0 then a i else 0) +
    (if stageActive K tick 1 then b i else 0) +
    (if stageActive K tick 2 then c i else 0)

theorem tickCapacity_first (K : ℕ) (hK : 2 ≤ K) (a b c : Capacity) :
    tickCapacity K a b c 0 = a := by
  funext i
  have h0 : 0 < K := by omega
  simp [tickCapacity, stageActive, h0]

theorem tickCapacity_second (K : ℕ) (hK : 2 ≤ K) (a b c : Capacity) :
    tickCapacity K a b c 1 = fun i => a i + b i := by
  funext i
  have h1 : 1 < K := by omega
  have h2 : 1 < K + 1 := by omega
  simp [tickCapacity, stageActive, h1, h2]

theorem tickCapacity_interior (K tick : ℕ) (ht : 2 ≤ tick) (htK : tick < K)
    (a b c : Capacity) :
    tickCapacity K a b c tick = fun i => a i + b i + c i := by
  funext i
  have h1 : 1 ≤ tick := by omega
  have ht1 : tick < K + 1 := by omega
  have ht2 : tick < K + 2 := by omega
  simp [tickCapacity, stageActive, ht, htK, h1, ht1, ht2]

theorem tickCapacity_penultimate (K : ℕ) (hK : 2 ≤ K) (a b c : Capacity) :
    tickCapacity K a b c K = fun i => b i + c i := by
  funext i
  have h1 : 1 ≤ K := by omega
  simp [tickCapacity, stageActive, hK, h1]

theorem tickCapacity_last (K : ℕ) (hK : 2 ≤ K) (a b c : Capacity) :
    tickCapacity K a b c (K + 1) = c := by
  funext i
  have h1 : 2 ≤ K + 1 := by omega
  simp [tickCapacity, stageActive, h1]

theorem sum_tick_minima (K : ℕ) (hK : 2 ≤ K) (a b c : Capacity) (full : ℝ)
    (hfull : ∀ i, a i + b i + c i = full) :
    (∑ tick ∈ Finset.range (K + 2), minCapacity (tickCapacity K a b c tick)) =
      (K - 2 : ℕ) * full + minCapacity a + minCapacity (fun i => a i + b i) +
        minCapacity (fun i => b i + c i) + minCapacity c := by
  let f : ℕ → ℝ := fun tick => minCapacity (tickCapacity K a b c tick)
  have hhead : ∑ tick ∈ Finset.range 2, f tick =
      minCapacity a + minCapacity (fun i => a i + b i) := by
    simp [f, Finset.sum_range_succ, tickCapacity_first K hK,
      tickCapacity_second K hK]
  have hinterior : (∑ tick ∈ Finset.range (K - 2), f (2 + tick)) =
      (K - 2 : ℕ) * full := by
    calc
      _ = ∑ _tick ∈ Finset.range (K - 2), full := by
        apply Finset.sum_congr rfl
        intro tick htick
        have hlt := Finset.mem_range.mp htick
        dsimp [f]
        rw [tickCapacity_interior K (2 + tick) (by omega) (by omega)]
        simp [minCapacity, hfull]
      _ = _ := by simp
  have htail : (∑ tick ∈ Finset.range 2, f (K + tick)) =
      minCapacity (fun i => b i + c i) + minCapacity c := by
    simp [f, Finset.sum_range_succ, tickCapacity_penultimate K hK,
      tickCapacity_last K hK]
  change (∑ tick ∈ Finset.range (K + 2), f tick) = _
  rw [Finset.sum_range_add f K 2, htail]
  have hsplit : (∑ tick ∈ Finset.range K, f tick) =
      (∑ tick ∈ Finset.range 2, f tick) +
        ∑ tick ∈ Finset.range (K - 2), f (2 + tick) := by
    have hKsum : 2 + (K - 2) = K := by omega
    simpa only [hKsum] using Finset.sum_range_add f 2 (K - 2)
  rw [hsplit, hhead, hinterior]
  ring

theorem finite_schedule_yield (K : ℕ) (hK : 2 ≤ K) (a b c : Capacity) (full : ℝ)
    (hfull : ∀ i, a i + b i + c i = full) :
    (∑ tick ∈ Finset.range (K + 2), minCapacity (tickCapacity K a b c tick)) =
      (K : ℝ) * full - boundaryDeficit a b c full := by
  rw [sum_tick_minima K hK a b c full hfull]
  exact Staggering.finite_schedule_yield a b c full K hK

theorem fixed_lot_boundary_limit {Y beta w S R : ℝ}
    (hfixed : ∀ K : ℕ, 2 ≤ K → Y - beta / (K : ℝ) + w * S / 3 ≤ R) :
    Y + w * S / 3 ≤ R := by
  by_contra hnot
  have hgap : 0 < Y + w * S / 3 - R := by linarith
  obtain ⟨K, hK⟩ := exists_nat_gt (max (beta / (Y + w * S / 3 - R)) (2 : ℝ))
  have hKtwo : (2 : ℝ) < (K : ℝ) := lt_of_le_of_lt (le_max_right _ _) hK
  have hKnat : 2 ≤ K := Nat.ofNat_le_cast.mp hKtwo.le
  have hKpos : (0 : ℝ) < (K : ℝ) := by linarith
  have hsmall : beta / (K : ℝ) < Y + w * S / 3 - R := by
    apply (div_lt_iff₀ hKpos).2
    have hquot : beta / (Y + w * S / 3 - R) < (K : ℝ) :=
      lt_of_le_of_lt (le_max_left _ _) hK
    simpa only [mul_comm] using (div_lt_iff₀ hgap).1 hquot
  have hbound := hfixed K hKnat
  linarith

end MatrixMultiplication.FiniteSchedule

end

end OAI