import OAI.Computability.FourierTransform.BinaryFFT

namespace OAI

/-! Circulant addition between disjoint dirty intervals by two transformed words and inverses. -/
namespace PowerSaving.Slant
open Reel Zone Stroke Spectral Finset
noncomputable section

def eddy (d : ℕ) (r : ℂ) (u v : Zone) (h : Line) : Reel :=
  let p := pulse d r; let b := backPulse d r
  let f := flash v u (freq (2^d) r h)
  ((((atBase u.lo p).stack (atBase v.lo p)).stack f).stack (atBase u.lo b)).stack
    (atBase v.lo b)

lemma beat_mounted (p : ℕ) (r : Reel) : (atBase p r).beats=r.beats := rfl

lemma beats_eddy (d : ℕ) (r : ℂ) (u v : Zone) (h : Line) :
    (eddy d r u v h).beats=20*d+28 := by
  unfold eddy; dsimp only
  simp only [stack,beat_mounted,beats_pulse,beats_flash,beats_back]
  omega

lemma Zone.Fits.end_le {v : Zone} {n : ℕ} (hv : v.Fits n) (hp : 0<v.wide) :
    v.lo+v.wide ≤ n := by
  have := hv _ (v.inside (by omega : v.wide-1<v.wide))
  omega

lemma Zone.Fits.mount {v : Zone} {n : ℕ} (hv : v.Fits n) (hp : 0<v.wide)
    {r : Reel} (h : r.Sound v.wide) :
    (atBase v.lo r).Sound n :=
  (h.atBase _).wider (hv.end_le hp)

section
variable {u v : Zone} {d n : ℕ} (r : ℂ) (h : Line) (hu : u.wide=2^d)
  (hv : v.wide=2^d) (hs : u.Sep v)

include hu hv hs
theorem sound_eddy (pu : u.Fits n) (pv : v.Fits n) :
    (eddy d r u v h).Sound n := by
  have HU {a : Reel} (h : a.Sound (2^d)) :=
    pu.mount (by rw [hu]; positivity) (show a.Sound u.wide by rwa [hu])
  have HV {a : Reel} (h : a.Sound (2^d)) :=
    pv.mount (by rw [hv]; positivity) (show a.Sound v.wide by rwa [hv])
  have hq : v.wide=u.wide := hv.trans hu.symm
  exact ((((HU (sound_pulse d r)).stack (HV (sound_pulse d r))).stack
    (sound_flash pv pu hq hs.symm _)).stack (HU (sound_back d r))).stack
    (HV (sound_back d r))

theorem spill_eddy (hr : IsPrimitiveRoot r (2^d)) :
    Spill (eddy d r u v h) u v (cyclic (2^d) h) := by
  let q := 2^d
  let f := freq q r
  let g := fun (x : Line) (i : ℕ) => (q:ℂ)⁻¹ * freq q r⁻¹ x i
  let p := pulse d r; let b := backPulse d r
  let pa := atBase u.lo p; let pb := atBase v.lo p
  let ba := atBase u.lo b; let bb := atBase v.lo b
  let fl := flash v u (f h)
  have hq : v.wide=u.wide := hv.trans hu.symm
  have h1 : Retrace pa u f := atBase_retrace (by rw [hu]; exact sound_pulse d _)
    (by rw [hu]; exact flows_pulse d _ hr)
  have h2 : Retrace pb v f := atBase_retrace (by rw [hv]; exact sound_pulse d _)
    (by rw [hv]; exact flows_pulse d _ hr)
  have h4 : Retrace ba u g := atBase_retrace (by rw [hu]; exact sound_back d _)
    (by rw [hu]; exact flows_back d _ hr)
  have h5 : Retrace bb v g := atBase_retrace (by rw [hv]; exact sound_back d _)
    (by rw [hv]; exact flows_back d _ hr)
  have h3 : Spill fl u v (fun x i => f h i*x i) := spill_flash hq hs.symm (f h)
  have gf (x y : Line) (i : ℕ) (hi : i<q) (H : ∀ i<q, x i=f y i) :
      g x i=y i := by
    unfold g
    rw [freq_congr H]
    exact freq_inv hr y i hi
  change u.wide=q at hu; change v.wide=q at hv
  have clean (x : Line) (i : ℕ) (hi : i<u.wide) :
      u.peek ((eddy d r u v h).go x) i=u.peek x i := by
    change u.peek (((((pa.stack pb).stack fl).stack ba).stack bb).go x) i=_
    simp only [go_stack]
    rw [retrace_preserve h5 hs _ i hi,h4.draws _ i hi]
    refine gf _ _ i (hu ▸ hi) ?_
    intro j hj
    have hk : j<u.wide := hu.symm ▸ hj
    rw [h3.preserves hs _ j hk,retrace_preserve h2 hs _ j hk,h1.draws _ j hk]
  constructor
  · intro x i hi
    change v.peek (((((pa.stack pb).stack fl).stack ba).stack bb).go x) i=_
    simp only [go_stack]
    rw [h5.draws _ i hi]
    refine gf _ (v.peek x + cyclic q h (u.peek x)) i (hv ▸ hi) ?_
    intro j hj
    have hk : j<v.wide := hv.symm ▸ hj
    have hp : j<u.wide := hq ▸ hk
    rw [retrace_preserve h4 hs.symm _ j hk,h3.adds _ j hk,h2.draws _ j hk]
    rw [retrace_preserve h2 hs _ j hp, h1.draws _ j hp]
    have hx : freq q r (v.peek (pa.go x)) = f (v.peek x) := freq_congr
      (fun j hj => retrace_preserve h1 hs.symm _ j (hv.symm ▸ hj)) r
    unfold f
    rw [hx, freq_add]
    exact congr_arg (freq q r (v.peek x) j + ·) (freq_cyclic hr.pow_eq_one _ _ _).symm
  · intro x i hi
    by_cases hh : u.has i
    · have H := clean x (i-u.lo) (u.enter hh)
      simpa [Zone.peek,Stroke.drift,u.identify hh] using H
    · change ((((pa.stack pb).stack fl).stack ba).stack bb).go x i=_
      simp only [go_stack]
      rw [h5.waits _ i hi,h4.waits _ i hh,h3.keeps _ i hi,h2.waits _ i hi,h1.waits _ i hh]

end

lemma cyclic_reads (v : ℕ) (h : Line) : Reads v v (cyclic v h) := by
  intro x y hxy i hi
  unfold cyclic
  exact sum_congr rfl fun _ hj => congr_arg (_*·) (hxy _ (mem_range.mp hj))

lemma cyclic_add (v : ℕ) (h : Line) : AdditiveOn v (cyclic v h) := by
  intro x y i _
  simp [cyclic,mul_add,sum_add_distrib]

lemma cyclic_neg (v : ℕ) (h : Line) :
    cyclic v (fun i => -h i) = minusFn (cyclic v h) := by
  ext x i
  simp [cyclic,minusFn]

end
end PowerSaving.Slant

end OAI