import OAI.Analysis.FiniteFactor.Polynomial
import OAI.Analysis.FiniteFactor.Convolution
import Mathlib.Data.Int.Interval

namespace OAI

namespace FiniteFactor
open scoped ComplexConjugate

/-- Sum a row of the Laurent coefficient double sum using its unique possible
second exponent. -/
theorem laurent_row_eq (K : ℕ) (A B : ℤ → ℂ) (r v : ℤ) :
    (∑ j : Fin (2*K+1), if v + ((j.val : ℤ)-K) = r then
      A v * B ((j.val : ℤ)-K) else 0) =
    if -(K : ℤ) ≤ r-v ∧ r-v ≤ K then A v * B (r-v) else 0 := by
  classical
  by_cases hv : -(K : ℤ) ≤ r-v ∧ r-v ≤ K
  · rw [ite_eq_left hv]
    let j : Fin (2*K+1) := ⟨(r-v+K).toNat, by omega⟩
    have hj : (j.val : ℤ)-K = r-v := by dsimp [j]; omega
    rw [Finset.sum_eq_single j]
    · rw [hj, ite_eq_left (by omega)]
    · intro b _ hb
      apply ite_eq_right
      intro he
      apply hb
      apply Fin.ext
      have := b.isLt
      omega
    · simp
  · rw [ite_eq_right hv]
    apply Finset.sum_eq_zero
    intro j _
    apply ite_eq_right
    intro he
    apply hv
    have := j.isLt
    omega

/-- A finite subset of ℤ, exactly the two simultaneous coefficient cutoffs. -/
noncomputable def convolutionWindow (K : ℕ) (n : ℤ) : Finset ℤ :=
  (Finset.Icc (-(K : ℤ)) K).filter (fun v => -(K : ℤ) ≤ -n-v ∧ -n-v ≤ K)

theorem mem_convolutionWindow (K : ℕ) (n v : ℤ) :
    v ∈ convolutionWindow K n ↔ |v| ≤ (K : ℤ) ∧ |n+v| ≤ (K : ℤ) := by
  simp only [convolutionWindow, Finset.mem_filter, Finset.mem_Icc, abs_le]
  omega

theorem not_mem_convolutionWindow (K : ℕ) (n v : ℤ) :
    v ∉ convolutionWindow K n ↔ (K : ℤ) < |v| ∨ (K : ℤ) < |n+v| := by
  rw [mem_convolutionWindow]
  omega

theorem laurent_coefficient_eq_finite_convolution (K : ℕ) (A B : ℤ → ℂ) (n : ℤ) :
    laurentProductCoefficient K A B (-n) =
      ∑ v ∈ convolutionWindow K n, A v * B (-n-v) := by
  classical
  simp only [laurentProductCoefficient, laurent_row_eq]
  rw [convolutionWindow, Finset.sum_filter]
  apply Finset.sum_bij (fun i _ => (i.val : ℤ)-K)
  · intro i _
    simp only [Finset.mem_Icc]
    have := i.isLt
    omega
  · intro i _ j _ hij
    apply Fin.ext
    omega
  · intro v hv
    simp only [Finset.mem_Icc] at hv
    refine ⟨⟨(v+K).toNat, by omega⟩, Finset.mem_univ _, ?_⟩
    dsimp
    omega
  · intro i _
    rfl

/-- A zero absolutely convergent convolution forces the exact finite Laurent
coefficient to be the negative complementary tail. -/
theorem laurent_coefficient_eq_neg_tail (K : ℕ) (A B : ℤ → ℂ) (n : ℤ)
    (hs : Summable (fun v => A v * B (-n-v)))
    (hz : ∑' v, A v * B (-n-v) = 0) :
    laurentProductCoefficient K A B (-n) =
      -(∑' v : {v : ℤ // v ∉ convolutionWindow K n}, A v * B (-n-v)) := by
  rw [laurent_coefficient_eq_finite_convolution]
  exact finite_part_eq_neg_tail hs hz _

/-- The corresponding absolute tail bound used in error-pointwise. -/
theorem laurent_coefficient_norm_le_tail (K : ℕ) (A B : ℤ → ℂ) (n : ℤ)
    (hs : Summable (fun v => ‖A v * B (-n-v)‖))
    (hz : ∑' v, A v * B (-n-v) = 0) :
    ‖laurentProductCoefficient K A B (-n)‖ ≤
      ∑' v : {v : ℤ // v ∉ convolutionWindow K n}, ‖A v * B (-n-v)‖ := by
  rw [laurent_coefficient_eq_finite_convolution]
  exact finite_part_norm_le_tail hs hz _

/-- The full pointwise error estimate. The two exceptional masks remain
separate and each is summed over all of ℤ; no union bound is introduced. -/
theorem laurent_error_pointwise (K : ℕ) (n : ℤ)
    (ξ γ : lp (fun _ : ℤ => ℂ) 2) {F G : ℤ → ℝ}
    (hF : ∀ k, 0 < F k) (hG : ∀ k, 0 < G k)
    (hFa : Antitone F) (hGa : Antitone G) (hGF : ∀ k, G k ≤ F k)
    (hn : 0 ≤ n) {H₁ H₂ : Set ℤ} {ε : ℝ} (hε : 0 ≤ ε)
    (hz : ∑' v, leftCoefficient F ξ v * rightCoefficient G γ (-n-v) = 0)
    (hR : ∀ v, v ∉ convolutionWindow K n →
      G (n+v) / F v ≤ ε + H₁.indicator (fun _ => 1) v +
        H₂.indicator (fun _ => 1) v) :
    ‖laurentProductCoefficient K (leftCoefficient F ξ) (rightCoefficient G γ) (-n)‖ ≤
      ε * (‖ξ‖ * ‖γ‖) +
      (∑' v, H₁.indicator (fun v => ‖ξ v‖ * ‖γ (n+v)‖) v) +
      (∑' v, H₂.indicator (fun v => ‖ξ v‖ * ‖γ (n+v)‖) v) := by
  classical
  let p : ℤ → ℝ := fun v => ‖ξ v‖ * ‖γ (n+v)‖
  have hp0 : ∀ v, 0 ≤ p v := fun v => mul_nonneg (norm_nonneg _) (norm_nonneg _)
  obtain ⟨hp, hpbound⟩ := shifted_l2_norm_product ξ γ n
  change Summable p at hp
  change (∑' v, p v) ≤ ‖ξ‖ * ‖γ‖ at hpbound
  have hmask : ∀ H : Set ℤ, Summable (H.indicator p) := by
    intro H
    apply hp.of_nonneg_of_le
    · intro v
      by_cases hv : v ∈ H <;> simp [hv, hp0]
    · intro v
      by_cases hv : v ∈ H <;> simp [hv, hp0]
  let b : ℤ → ℝ := fun v => ε * p v + H₁.indicator p v + H₂.indicator p v
  have hb : Summable b := ((hp.mul_left ε).add (hmask H₁)).add (hmask H₂)
  have hb0 : ∀ v, 0 ≤ b v := by
    intro v
    dsimp [b]
    have h₁ : 0 ≤ H₁.indicator p v := by by_cases hv : v ∈ H₁ <;> simp [hv, hp0]
    have h₂ : 0 ≤ H₂.indicator p v := by by_cases hv : v ∈ H₂ <;> simp [hv, hp0]
    exact add_nonneg (add_nonneg (mul_nonneg hε (hp0 v)) h₁) h₂
  have hterm : ∀ v, v ∉ convolutionWindow K n →
      ‖leftCoefficient F ξ v * rightCoefficient G γ (-n-v)‖ ≤ b v := by
    intro v hv
    rw [cocycle_convolution_term_eq]
    have hr : 0 ≤ G (n+v) / F v := (div_pos (hG _) (hF _)).le
    simp only [norm_mul, RCLike.norm_conj, Complex.norm_real, Real.norm_eq_abs,
      abs_of_nonneg hr]
    calc
      G (n+v) / F v * ‖ξ v‖ * ‖γ (n+v)‖ = (G (n+v) / F v) * p v := by dsimp [p]; ring
      _ ≤ (ε + H₁.indicator (fun _ => 1) v + H₂.indicator (fun _ => 1) v) * p v :=
        mul_le_mul_of_nonneg_right (hR v hv) (hp0 v)
      _ = b v := by
        dsimp [b]
        by_cases h₁ : v ∈ H₁ <;> by_cases h₂ : v ∈ H₂ <;> simp [h₁, h₂] <;> ring
  have hs := (cocycle_convolution_absolute_convergence ξ γ hF hG hFa hGa hGF hn).1
  calc
    ‖laurentProductCoefficient K (leftCoefficient F ξ) (rightCoefficient G γ) (-n)‖ ≤
        ∑' v : {v : ℤ // v ∉ convolutionWindow K n},
          ‖leftCoefficient F ξ v * rightCoefficient G γ (-n-v)‖ :=
      laurent_coefficient_norm_le_tail K _ _ n hs hz
    _ ≤ ∑' v : {v : ℤ // v ∉ convolutionWindow K n}, b v :=
      (hs.subtype _).tsum_le_tsum (fun v => hterm v v.property) (hb.subtype _)
    _ ≤ ∑' v, b v := hb.tsum_subtype_le _ _ hb0
    _ = ε * (∑' v, p v) + (∑' v, H₁.indicator p v) + (∑' v, H₂.indicator p v) := by
      change (∑' v, (ε * p v + H₁.indicator p v + H₂.indicator p v)) = _
      rw [Summable.tsum_add ((hp.mul_left ε).add (hmask H₁)) (hmask H₂),
        Summable.tsum_add (hp.mul_left ε) (hmask H₁), tsum_mul_left]
    _ ≤ _ := by
      change ε * (∑' v, p v) + (∑' v, H₁.indicator p v) + (∑' v, H₂.indicator p v) ≤
        ε * (‖ξ‖ * ‖γ‖) + (∑' v, H₁.indicator p v) + (∑' v, H₂.indicator p v)
      linarith [mul_le_mul_of_nonneg_left hpbound hε]

end FiniteFactor

end OAI