import OAI.Analysis.FourierLLogL.Paths.Launch
/-! # The uniform output path -/

open Function Set Filter
open scoped Topology BigOperators ComplexConjugate
noncomputable section

namespace OAI

namespace FourierLLogL.Dyadic.Procedure.Paths
open Law Node Real Period Compress.Params Thermal Fund Scene Fork Road Event Journal Wire Pulse Thread Capture Chart Snapshot
variable {M j J : ℕ} {s q : Scene M} {f : Grid M → ℝ}
open scoped Classical


namespace Troupe
open Plot

def depthB (b : Beat M) := b.post.here.lev

lemma depth_next (b : Beat M) : (winds b).here.lev=depthB b+1 := by
  unfold winds depthB smaller
  cases b.bit <;> rfl

def muted (u : Grid M) (p : Plot) (c : Board M) (j : ℕ) : Path M → Prop
| [] => True
| b::l => ¬ p.catches b.post c j u ∧ muted u p (turn p c b.post) j l

lemma mute_cat (u : Grid M) (p : Plot) (c : Board M) (j : ℕ) (l r : Path M) :
    muted u p c j (l++r) ↔ muted u p c j l ∧ muted u p (quarrel p c l) j r := by
  induction l generalizing c with
  | nil => simp [muted,quarrel]
  | cons b l ih =>
    change (_∧muted u p (p.turn c b.post) j (l++r)) ↔ (_∧_)∧_
    rw [ih]; simp only [and_assoc]; rfl

lemma first_on (u : Grid M) (p : Plot) (c : Board M) (j : ℕ) (l : Path M) :
    muted u p c j l ∨ ∃ a b r,l=a++b::r ∧ muted u p c j a ∧
      p.catches b.post (quarrel p c a) j u := by
  induction l generalizing c with
  | nil => exact Or.inl True.intro
  | cons b l ih =>
    by_cases h : p.catches b.post c j u
    · exact Or.inr ⟨[],b,l,rfl,True.intro,h⟩
    rcases ih (turn p c b.post) with H|⟨a,d,r,H,h1,h2⟩
    · exact Or.inl ⟨h,H⟩
    exact Or.inr ⟨b::a,d,r,by rw [H]; rfl,⟨h,h1⟩,h2⟩

private lemma close_persists {A B : Finset (Grid M)} (h : A ⊆ B) (n : ℕ)
    {x : Grid M} (hv : enclosed A n x) : enclosed B n x := by
  classical
  obtain ⟨f,hf,rfl⟩ := hv
  let k (x : Grid M) := if x∈A then f x else 0
  refine ⟨k,fun i hi => ?_,?_⟩
  · unfold k; split_ifs with hh; exact hf _ hh; simp
  · have H : ∑ i∈A,k i • i=∑ i∈B,k i • i := Finset.sum_subset h (fun i _ h => by simp [k,h])
    rw [← H]; exact Finset.sum_congr rfl fun _ hx => by simp [k,hx]

private lemma reach_persists {A B : Finset (Grid M)} (h : A ⊆ B) (r t : ℝ)
    {x : Grid M} (hh : r ≤ t) (hv : atReach A r x) :
    atReach B t x := by
  obtain ⟨i,hi,hE⟩ := hv
  exact ⟨i,close_persists h 1 hi,hE.trans hh⟩

/-- snag only denotes a nonbad high depth. -/
def snag (g : Grade) (x : Grid M) (b : Beat M) :=
    intense g.main b.post (side g.i) x ∧ ¬ hazard b.post g.main g.i

def ink (s : Scene M) (g : Grade) (j : ℕ) := spotLimit s j g.i g.main

lemma mute_distance (u : Grid M) (p : Plot)
    (c : Board M) (s : Scene M) (l r : Path M)
    (h : Cast j J f s (l++r)) (he : Comes c s j J f) (hh : muted u p c j l)
    (k : ℝ) (hp : atReach c.chart.items k u) :
    ∀ b∈l, snag (grade p) u b →
      s.here.lev ≤ depthB b ∧ ink b.post (grade p) j < k := by
  induction l generalizing s c with
  | nil => simp
  | cons b l ih =>
    intro z hz hx
    obtain ⟨rfl,⟨t,ht⟩,h₁⟩ := h
    have hC := zoom_spec _ he.valid p.ix p.main ht
    let d := turn p c b.post
    have HR : atReach d.chart.items k u := reach_persists hC.extend k k le_rfl hp
    have hi : b.post.here=b.pre.here := ht.2.1.1.here
    rcases List.mem_cons.mp hz with rfl|hz
    · refine ⟨le_of_eq (congrArg Node.lev hi.symm),lt_of_not_ge fun H => ?_⟩
      exact hh.1 ⟨hx.1,reach_persists hC.extend k _ H hp⟩
    obtain ⟨ha,hb⟩ := ih d (winds b) h₁ (comes_down p ht he b.bit) hh.2 HR z hz hx
    rw [depth_next] at ha; change b.pre.here.lev ≤ _
      ∧ _
    rw [← hi]; exact ⟨le_trans (Nat.le_add_right (depthB b) 1) ha,hb⟩

def volumeAt (p : Plot) (s : Scene M) (c : Board M) :=
    localSize s.here p.ix c.chart

def betweenS (a H : ℕ) (b : Beat M) :=
    a ≤ depthB b ∧ depthB b < a+H

lemma screen_time (u : Grid M) (p : Plot)
    (c : Board M) (s : Scene M) (L : Path M)
    (h : Cast j J f s L) (he : Comes c s j J f) (hp : volumeAt p s c)
    (hv : oiled p c L) :
    ∃ a : ℕ, ∀ l r : Path M, L=l++r → muted u p c j l →
      ∀ b∈l, snag (grade p) u b → betweenS a (latency p j) b := by
  induction L generalizing c s with
  | nil =>
    refine ⟨0,?_⟩; intro l r hh hp b hb; cases l
    · cases hb
    · cases hh
  | cons b L ih =>
    have hi := oily_cons p h he hv
    obtain ⟨rfl,⟨t,ht⟩,h₁⟩ := h
    have hC := zoom_spec _ he.valid p.ix p.main ht
    have hH := ht.2.1.1.here
    let d := turn p c b.post; let s := b.post
    have HC : localSize s.here p.ix d.chart := hC.expands (hH.symm ▸ hp)
    by_cases hx : snag (grade p) u b
    · let I := horizon s.here p.ix d.chart.size
      have heq : d.chart=(now p c b.post) := rfl
      have HB : atReach d.chart.items I u := by
        have HE := hC.awake hx.2 u hx.1
        change atReach d.chart.items (d.chart.wide+speed s.here p.ix d.chart.size) u at HE
        apply reach_persists (Finset.Subset.refl _) _ _ ?_ HE
        unfold localSize at HC
        unfold I horizon; nlinarith
      refine ⟨depthB b,?_⟩
      intro l r hL hh z hz hZ
      cases l with
      | nil => cases hz
      | cons w l =>
        change b::L=w::(l++r) at hL; cases hL
        rcases List.mem_cons.mp hz with rfl|hz
        · unfold betweenS latency; omega
        obtain ⟨ha,hb⟩ := mute_distance u p d (winds b) l r h₁ hi.2.2 hh.2 I HB z hz hZ
        refine ⟨?_, lt_of_not_ge (fun H => ?_)⟩
        · rw [depth_next] at ha; omega
        have Hx' := waiting p j s.here z.post.here H d.chart.size hi.1
        exact hb.not_ge Hx'
    · have HV : volumeAt p (winds b) d := by
        unfold volumeAt localSize; unfold localSize at HC
        apply HC.trans
        apply mul_le_mul_of_nonneg_left _ (by positivity)
        apply speed_le _ le_rfl
        rw [depth_next]; exact Nat.le_add_right _ _
      obtain ⟨a,ha⟩ := ih d _ h₁ hi.2.2 HV hi.2.1
      refine ⟨a,?_⟩
      intro l r hL hh z hz hZ
      cases l with
      | nil => cases hz
      | cons w l =>
        change b::L=w::(l++r) at hL
        have hw := List.cons.inj hL
        cases hw.1
        rcases List.mem_cons.mp hz with rfl|hz
        · exact (hx hZ).elim
        exact ha l r (List.cons.inj hL).2 hh.2 z hz hZ

def stall (u : Grid M) (g : Grade) (j : ℕ) (L : Path M) (l : Path M) :=
    muted u (heroPlot g L) (vacant M) j l
def billWait (g : Grade) (j : ℕ) (L : Path M) :=
    latency (heroPlot g L) j
lemma bound_stage {u : Grid M} {s : Scene M} (L : Path M)
    (h : Cast j J f s L) (g : Grade) :
    ∃ a : ℕ, ∀ l r : Path M, L=l++r → stall u g j L l →
      ∀ b∈l, snag g u b → betweenS a (billWait g j L) b :=
  screen_time u (heroPlot g L) (vacant M) s L h (vacant_comes s)
    (by simp [volumeAt,vacant,classic,Chart.size,localSize]) (oil_hero g L)

end Troupe


end FourierLLogL.Dyadic.Procedure.Paths

end OAI