import OAI.Geometry.Immersion.ClosedSurface.MeanSupport
import OAI.Geometry.Immersion.ClosedSurface.GridCover

namespace OAI

noncomputable section
open Set Complex Bundle Manifold
open scoped ContDiff Matrix Topology Manifold BigOperators

namespace ClosedSurfaceR4.PhaseGrid
open Set Function WeightedEstimates
attribute [local instance] Classical.propDecidable


lemma cutoff_weighted_bounds : ∃ C : ℕ → ℝ, (∀ m, 1 ≤ C m) ∧
    ∀ (h : ℝ), 0 < h → ∀ (a : Index) (m : ℕ),
      WeightedBound univ h m (C m) (cutoff h a) := by
  obtain ⟨c,hc,hbound⟩ := cutoff_derivative_bounds
  let C (m : ℕ) := 1 + ∑ j ∈ Finset.range (m+1), c j
  have hC (m : ℕ) : 1 ≤ C m := by
    have hs : 0 ≤ ∑ j ∈ Finset.range (m+1), c j := Finset.sum_nonneg (fun j _ => hc j)
    dsimp [C]; linarith
  refine ⟨C,hC,fun h hh a m j hj x _ => ?_⟩
  rw [iteratedFDerivWithin_univ]
  have hmul := mul_le_mul_of_nonneg_left (hbound h hh a j x) (pow_nonneg hh.le j)
  have hle : c j ≤ C m := by
    have hs := Finset.single_le_sum (fun i (_ : i ∈ Finset.range (m+1)) => hc i)
      (show j ∈ Finset.range (m+1) by simp; omega)
    dsimp [C]; linarith
  apply le_trans _ hle
  convert hmul using 1
  field_simp



lemma weighted_sum_bounded_overlap {h C : ℝ} (hh : 0 < h) (hC : 0 ≤ C)
    {m : ℕ} (s : Finset Index) (f : Index → Base → ℝ)
    (hf : ∀ a ∈ s, ContDiff ℝ ∞ (f a))
    (hsupp : ∀ a ∈ s, tsupport (f a) ⊆ tsupport (cutoff h a))
    (hb : ∀ a ∈ s, WeightedBound univ h m C (f a)) :
    WeightedBound univ h m (36*C) (fun x => ∑ a ∈ s, f a x) := by
  intro j hj x _
  rw [iteratedFDerivWithin_univ, iteratedFDeriv_sum (fun a ha =>
    (hf a ha).of_le (by exact_mod_cast (le_top : (j : ℕ∞) ≤ ⊤)))]
  let t := s.filter (fun a => x ∈ tsupport (cutoff h a))
  have ht : t ⊆ s := Finset.filter_subset _ _
  have hz (a : Index) (ha : a ∈ s) (hat : a ∉ t) :
      iteratedFDeriv ℝ j (f a) x = 0 := by
    apply notMem_support.mp
    intro hmem
    have hx := hsupp a ha (support_iteratedFDeriv_subset j hmem)
    exact hat (Finset.mem_filter.mpr ⟨ha,hx⟩)
  have he : (∑ a ∈ t, iteratedFDeriv ℝ j (f a) x) =
      ∑ a ∈ s, iteratedFDeriv ℝ j (f a) x :=
    Finset.sum_subset ht (fun a ha hat => hz a ha hat)
  simp only [Finset.sum_apply]
  rw [← he]
  calc
    _ ≤ h^j * ∑ a ∈ t, ‖iteratedFDeriv ℝ j (f a) x‖ := by
      gcongr; exact norm_sum_le _ _
    _ = ∑ a ∈ t, h^j * ‖iteratedFDeriv ℝ j (f a) x‖ := Finset.mul_sum _ _ _
    _ ≤ ∑ _a ∈ t, C := Finset.sum_le_sum (fun a ha => by
      simpa only [iteratedFDerivWithin_univ] using hb a (ht ha) j hj x (mem_univ x))
    _ = (t.card : ℝ)*C := by simp
    _ ≤ 36*C := by
      apply mul_le_mul_of_nonneg_right _ hC
      exact_mod_cast active_cutoff_count hh s x

def squareSum (s : Finset Index) (h : ℝ) (x : Base) : ℝ :=
  ∑ a ∈ s, (cutoff h a x)^2

def normalizedCutoff (s : Finset Index) (h : ℝ) (a : Index) (x : Base) : ℝ :=
  cutoff h a x / Real.sqrt (squareSum s h x)

lemma squareSum_smooth (s : Finset Index) (h : ℝ) : ContDiff ℝ ∞ (squareSum s h) :=
  ContDiff.sum (fun a _ => (cutoff_smooth h a).pow 2)

lemma squareSum_nonneg (s : Finset Index) (h : ℝ) (x : Base) : 0 ≤ squareSum s h x :=
  Finset.sum_nonneg (fun _ _ => sq_nonneg _)

lemma squareSum_ge_one {s : Finset Index} {h : ℝ} (hh : 0 < h) {x : Base}
    (hcover : ∃ a ∈ s, x ∈ cell h 1 a) : 1 ≤ squareSum s h x := by
  obtain ⟨a,ha,hax⟩ := hcover
  have hb := Finset.single_le_sum (fun b (_ : b ∈ s) => sq_nonneg (cutoff h b x)) ha
  simpa [squareSum,cutoff_one_on_cell hh a hax] using hb

lemma normalizedCutoff_tsupport (s : Finset Index) (h : ℝ) (a : Index) :
    tsupport (normalizedCutoff s h a) ⊆ tsupport (cutoff h a) := by
  apply closure_mono
  intro x hx
  exact fun hz => hx (by simp [normalizedCutoff,hz])

lemma normalizedCutoff_squares {s : Finset Index} {h : ℝ} {x : Base}
    (hp : 0 < squareSum s h x) : ∑ a ∈ s, (normalizedCutoff s h a x)^2 = 1 := by
  calc
    _ = squareSum s h x / (Real.sqrt (squareSum s h x))^2 := by
      simp only [normalizedCutoff,div_pow,Finset.sum_div,squareSum]
    _ = 1 := by rw [Real.sq_sqrt hp.le,div_self hp.ne']

lemma squareSum_weighted_bounds : ∃ D : ℕ → ℝ, (∀ m, 1 ≤ D m) ∧
    ∀ (h : ℝ), 0 < h → ∀ (s : Finset Index) (m : ℕ),
      WeightedBound univ h m (D m) (squareSum s h) := by
  obtain ⟨C,hC,hbound⟩ := cutoff_weighted_bounds
  let D (m : ℕ) := 1 + 36 * (2^m * C m * C m)
  have hD (m : ℕ) : 1 ≤ D m := by
    have hc0 : 0 ≤ C m := zero_le_one.trans (hC m)
    have hp : 0 ≤ 36 * (2^m * C m * C m) := by positivity
    dsimp [D]; linarith
  refine ⟨D,hD,fun h hh s m => ?_⟩
  have hc0 : 0 ≤ C m := zero_le_one.trans (hC m)
  have hb : WeightedBound univ h m (36 * (2^m * C m * C m))
      (fun x => ∑ a ∈ s, cutoff h a x * cutoff h a x) :=
    weighted_sum_bounded_overlap hh (by positivity) s _
      (fun a _ => (cutoff_smooth h a).mul (cutoff_smooth h a))
      (fun a _ => tsupport_mul_subset_left)
      (fun a _ => (hbound h hh a m).real_mul uniqueDiffOn_univ hh.le hc0 hc0
        (cutoff_smooth h a).contDiffOn (cutoff_smooth h a).contDiffOn (hbound h hh a m))
  exact (hb.mono_const (by dsimp [D]; linarith)).congr (fun x _ => by simp [squareSum,pow_two])

end ClosedSurfaceR4.PhaseGrid

namespace ClosedSurfaceR4.PhaseGrid
open Set Function WeightedEstimates

lemma inverse_sqrt_smooth : ContDiffOn ℝ ∞ (fun r : ℝ => (Real.sqrt r)⁻¹) (Ioi 0) := by
  apply (contDiffOn_id.sqrt (fun r hr => ne_of_gt hr)).inv
  intro r hr
  exact (Real.sqrt_pos.2 hr).ne'

lemma normalizedCutoff_smooth {U : Set Base} {s : Finset Index} {h : ℝ}
    (hh : 0 < h) (hcover : ∀ x ∈ U, ∃ a ∈ s, x ∈ cell h 1 a) (a : Index) :
    ContDiffOn ℝ ∞ (normalizedCutoff s h a) U := by
  have hm : MapsTo (squareSum s h) U (Ioi 0) :=
    fun x hx => zero_lt_one.trans_le (squareSum_ge_one hh (hcover x hx))
  have hi := inverse_sqrt_smooth.comp (squareSum_smooth s h).contDiffOn hm
  change ContDiffOn ℝ ∞ (fun x => cutoff h a x / Real.sqrt (squareSum s h x)) U
  simpa only [div_eq_mul_inv,Function.comp_apply] using (cutoff_smooth h a).contDiffOn.mul hi




theorem normalizedCutoff_weighted_bounds : ∃ C : ℕ → ℝ, (∀ m, 1 ≤ C m) ∧
    ∀ (h : ℝ), 0 < h → ∀ (s : Finset Index) (U : Set Base), IsOpen U →
      (∀ x ∈ U, ∃ a ∈ s, x ∈ cell h 1 a) → ∀ (a : Index) (m : ℕ),
      WeightedBound U h m (C m) (normalizedCutoff s h a) := by
  obtain ⟨c,hc,hcb⟩ := cutoff_weighted_bounds
  obtain ⟨d,hd,hdb⟩ := squareSum_weighted_bounds
  have hcoeff (m : ℕ) : ∃ e : ℝ, 1 ≤ e ∧ ∀ j ≤ m, ∀ r ∈ Icc (1:ℝ) (d m),
      ‖iteratedFDerivWithin ℝ j (fun r : ℝ => (Real.sqrt r)⁻¹) (Ioi 0) r‖ ≤ e :=
    compact_coefficient_bound isOpen_Ioi.uniqueDiffOn isCompact_Icc
      (fun r hr => zero_lt_one.trans_le hr.1) inverse_sqrt_smooth m
  choose e he heb using hcoeff
  let C (m : ℕ) := 1 + 2^m * c m * ((m.factorial : ℝ) * e m * (d m)^m)
  have hc0 (m : ℕ) : 0 ≤ c m := zero_le_one.trans (hc m)
  have hd0 (m : ℕ) : 0 ≤ d m := zero_le_one.trans (hd m)
  have he0 (m : ℕ) : 0 ≤ e m := zero_le_one.trans (he m)
  have hC (m : ℕ) : 1 ≤ C m := by
    have hcm := hc0 m
    have hdm := hd0 m
    have hem := he0 m
    have hnonneg : 0 ≤ 2^m * c m * ((m.factorial : ℝ) * e m * (d m)^m) := by positivity
    dsimp [C]; linarith
  refine ⟨C,hC,fun h hh s U hU hcover a m => ?_⟩
  have hb := (hdb h hh s m).restrict_open hU
  have hmap : MapsTo (squareSum s h) U (Icc 1 (d m)) := by
    intro x hx
    refine ⟨squareSum_ge_one hh (hcover x hx),?_⟩
    exact (le_abs_self _).trans (by simpa only [Real.norm_eq_abs] using hb.norm_le hx)
  have hpos : MapsTo (squareSum s h) U (Ioi 0) := fun x hx =>
    zero_lt_one.trans_le (hmap hx).1
  have hs : ContDiffOn ℝ ∞ (squareSum s h) U := (squareSum_smooth s h).contDiffOn
  have hi : ContDiffOn ℝ ∞ (fun x => (Real.sqrt (squareSum s h x))⁻¹) U :=
    inverse_sqrt_smooth.comp hs hpos
  have hbi := hb.comp hU.uniqueDiffOn isOpen_Ioi.uniqueDiffOn hh (hd m) (he0 m)
    hs inverse_sqrt_smooth hpos (fun j hj x hx => heb m j hj _ (hmap hx))
  have hcm := hc0 m
  have hdm := hd0 m
  have hem := he0 m
  have hp := ((hcb h hh a m).restrict_open hU).real_mul hU.uniqueDiffOn hh.le
    (hc0 m) (by positivity) (cutoff_smooth h a).contDiffOn hi hbi
  have hp' := hp.mono_const (show 2^m*c m*((m.factorial:ℝ)*e m*(d m)^m) ≤ C m by
    dsimp [C]; linarith)
  exact hp'.congr (fun x _ => by simp only [normalizedCutoff,div_eq_mul_inv])



theorem normalizedCutoff_polynomial_derivatives : ∃ C : ℕ → ℝ, (∀ j, 1 ≤ C j) ∧
    ∀ (z : ℝ), 0 < z → ∀ (s : Finset Index) (U : Set Base), IsOpen U →
      (∀ x ∈ U, ∃ a ∈ s, x ∈ cell (z^6) 1 a) → ∀ (a : Index) (j : ℕ) (x : Base),
      x ∈ U → ‖iteratedFDeriv ℝ j (normalizedCutoff s (z^6) a) x‖ ≤ C j / z^(6*j) := by
  obtain ⟨C,hC,hb⟩ := normalizedCutoff_weighted_bounds
  refine ⟨C,hC,fun z hz s U hU hcover a j x hx => ?_⟩
  have hp := (hb (z^6) (pow_pos hz _) s U hU hcover a j).deriv_le (pow_pos hz _) le_rfl hx
  simpa only [iteratedFDerivWithin_of_isOpen j hU hx,← pow_mul] using hp

end ClosedSurfaceR4.PhaseGrid

end

end OAI