import Mathlib
import OAI.Analysis.CoulombIonization.Variational.SmoothNewton

namespace OAI

noncomputable section

namespace CoulombAnalysis

open MeasureTheory Filter
open scoped Topology BigOperators ContDiff
section Work_LipschitzMollifier_scope

open MeasureTheory Filter Set Metric
open scoped BigOperators ContDiff Topology Convolution NNReal

lemma normalized_convolution_integrable {η g : TFSpace → ℝ}
    (hη : Continuous η) (hcη : HasCompactSupport η) (hg : Continuous g) (x : TFSpace) :
    Integrable (fun z => η z*g (x-z)) :=
  (hη.mul (hg.comp (continuous_const.sub continuous_id))).integrable_of_hasCompactSupport hcη.mul_right

lemma normalized_convolution_lipschitz {η g : TFSpace → ℝ} {L : ℝ≥0}
    (hη : Continuous η) (hcη : HasCompactSupport η)
    (hnη : ∀ x, 0 ≤ η x) (hmη : ∫ x, η x = 1) (hg : LipschitzWith L g) :
    LipschitzWith L (η ⋆[newtonMul] g) := by
  apply LipschitzWith.of_dist_le_mul
  intro x y
  have hi : Integrable η := hη.integrable_of_hasCompactSupport hcη
  have he : (η ⋆[newtonMul] g) x-(η ⋆[newtonMul] g) y =
      ∫ z, η z*(g (x-z)-g (y-z)) := by
    simp only [convolution,newtonMul,ContinuousLinearMap.mul_apply',mul_sub]
    rw [integral_sub (normalized_convolution_integrable hη hcη hg.continuous x)
      (normalized_convolution_integrable hη hcη hg.continuous y)]
  rw [dist_eq_norm,he]
  calc
    _ ≤ ∫ z, ((L:ℝ)*dist x y)*η z := norm_integral_le_of_norm_le
      (hi.const_mul _) (Eventually.of_forall fun z => by
        rw [norm_mul,Real.norm_of_nonneg (hnη z)]
        have hh := hg.dist_le_mul (x-z) (y-z)
        rw [dist_sub_right,dist_eq_norm] at hh
        nlinarith [mul_le_mul_of_nonneg_left hh (hnη z)])
    _ = _ := by rw [integral_const_mul,hmη,mul_one]

lemma normalized_convolution_error {η g : TFSpace → ℝ} {L : ℝ≥0} {r : ℝ}
    (hη : Continuous η) (hcη : HasCompactSupport η)
    (hnη : ∀ x, 0 ≤ η x) (hmη : ∫ x, η x = 1)
    (hsη : ∀ x, η x ≠ 0 → ‖x‖ ≤ r) (hg : LipschitzWith L g) (x : TFSpace) :
    ‖(η ⋆[newtonMul] g) x-g x‖ ≤ (L:ℝ)*r := by
  have hi : Integrable η := hη.integrable_of_hasCompactSupport hcη
  have he : (η ⋆[newtonMul] g) x-g x = ∫ z, η z*(g (x-z)-g x) := by
    simp only [convolution,newtonMul,ContinuousLinearMap.mul_apply',mul_sub]
    rw [integral_sub (normalized_convolution_integrable hη hcη hg.continuous x)
      (hi.mul_const _),integral_mul_const,hmη,one_mul]
  rw [he]
  calc
    _ ≤ ∫ z, ((L:ℝ)*r)*η z := norm_integral_le_of_norm_le (hi.const_mul _)
      (Eventually.of_forall fun z => by
        by_cases hz : η z = 0
        · simp [hz]
        · rw [norm_mul,Real.norm_of_nonneg (hnη z)]
          have hh := hg.dist_le_mul (x-z) x
          have hd : dist (x-z) x = ‖z‖ := by rw [dist_eq_norm]; simp
          rw [hd,dist_eq_norm] at hh
          have hl : ‖g (x-z)-g x‖ ≤ (L:ℝ)*r :=
            hh.trans (mul_le_mul_of_nonneg_left (hsη z hz) L.coe_nonneg)
          nlinarith [mul_le_mul_of_nonneg_left hl (hnη z)])
    _ = _ := by rw [integral_const_mul,hmη,mul_one]

lemma convolution_tsupport_bound {η g : TFSpace → ℝ} {r s : ℝ}
    (hsη : ∀ x, η x ≠ 0 → ‖x‖ ≤ r) (hsg : ∀ x, g x ≠ 0 → ‖x‖ ≤ s) :
    tsupport (η ⋆[newtonMul] g) ⊆ closedBall 0 (r+s) := by
  apply closure_minimal _ isClosed_closedBall
  intro x hx
  obtain ⟨u,hu,v,hv,rfl⟩ := support_convolution_subset newtonMul hx
  rw [mem_closedBall_zero_iff]
  exact (norm_add_le u v).trans (add_le_add (hsη u hu) (hsg v hv))

def packetSmooth (r : ℝ) (g : TFSpace → ℝ) : TFSpace → ℝ :=
  CoulombAtom.packetDensity 0 r ⋆[newtonMul] g

lemma packetSmooth_contDiff {r : ℝ} (hr : 0 < r) {g : TFSpace → ℝ} (hg : Continuous g) :
    ContDiff ℝ ∞ (packetSmooth r g) :=
  (CoulombAtom.packetDensity_compact 0 hr).contDiff_convolution_left newtonMul
    (CoulombAtom.packetDensity_smooth 0 r) hg.locallyIntegrable

lemma packetSmooth_compact {r : ℝ} (hr : 0 < r) {g : TFSpace → ℝ} (hg : HasCompactSupport g) :
    HasCompactSupport (packetSmooth r g) :=
  HasCompactSupport.convolution newtonMul (CoulombAtom.packetDensity_compact 0 hr) hg

lemma packetSmooth_lipschitz {r : ℝ} (hr : 0 < r) {g : TFSpace → ℝ} {L : ℝ≥0}
    (hg : LipschitzWith L g) : LipschitzWith L (packetSmooth r g) :=
  normalized_convolution_lipschitz (CoulombAtom.packetDensity_smooth 0 r).continuous
    (CoulombAtom.packetDensity_compact 0 hr) (CoulombAtom.packetDensity_nonneg 0 r)
    (CoulombAtom.packetDensity_mass 0 hr) hg

lemma packetSmooth_error {r : ℝ} (hr : 0 < r) {g : TFSpace → ℝ} {L : ℝ≥0}
    (hg : LipschitzWith L g) (x : TFSpace) : ‖packetSmooth r g x-g x‖ ≤ (L:ℝ)*r :=
  normalized_convolution_error (CoulombAtom.packetDensity_smooth 0 r).continuous
    (CoulombAtom.packetDensity_compact 0 hr) (CoulombAtom.packetDensity_nonneg 0 r)
    (CoulombAtom.packetDensity_mass 0 hr)
    (fun z hz => by simpa only [sub_zero] using CoulombAtom.packetDensity_support 0 hr hz) hg x

lemma packetSmooth_support {r s : ℝ} (hr : 0 < r) {g : TFSpace → ℝ}
    (hsg : Function.support g ⊆ closedBall 0 s) :
    tsupport (packetSmooth r g) ⊆ closedBall 0 (r+s) :=
  convolution_tsupport_bound
    (fun z hz => by simpa only [sub_zero] using CoulombAtom.packetDensity_support 0 hr hz)
    (fun z hz => by simpa only [mem_closedBall_zero_iff] using hsg hz)

end Work_LipschitzMollifier_scope

open MeasureTheory Filter Set Metric
open scoped BigOperators ContDiff NNReal Topology

lemma compact_continuous_bound {g : TFSpace → ℝ} (hg : Continuous g)
    (hcg : HasCompactSupport g) : ∃ B : ℝ, ∀ x, ‖g x‖ ≤ B := by
  obtain ⟨B,hB⟩ := hcg.isCompact.exists_bound_of_continuousOn hg.continuousOn
  refine ⟨max B 0,fun x => ?_⟩
  by_cases hx : x ∈ tsupport g
  · exact (hB x hx).trans (le_max_left _ _)
  · rw [image_eq_zero_of_notMem_tsupport hx,norm_zero]
    exact le_max_right _ _

lemma packetSmooth_tendsto {ε : ℕ → ℝ} (he : ∀ n, 0 < ε n)
    (hlim : Tendsto ε atTop (𝓝 0)) {g : TFSpace → ℝ} {L : ℝ≥0}
    (hg : LipschitzWith L g) (x : TFSpace) :
    Tendsto (fun n => packetSmooth (ε n) g x) atTop (𝓝 (g x)) := by
  apply tendsto_iff_norm_sub_tendsto_zero.mpr
  apply squeeze_zero (fun n => norm_nonneg _) (fun n => packetSmooth_error (he n) hg x)
  simpa only [mul_zero] using hlim.const_mul (L:ℝ)

lemma packetSmooth_pair_tendsto (μ : Measure TFSpace) {f : TFSpace → ℝ}
    (hf : Integrable f μ) {ε : ℕ → ℝ} {r : ℝ}
    (he : ∀ n, 0 < ε n) (heb : ∀ n, ε n ≤ r) (hlim : Tendsto ε atTop (𝓝 0))
    {g : TFSpace → ℝ} {L : ℝ≥0} (hg : LipschitzWith L g) (hcg : HasCompactSupport g) :
    Tendsto (fun n => ∫ x, packetSmooth (ε n) g x*f x ∂μ) atTop
      (𝓝 (∫ x, g x*f x ∂μ)) := by
  obtain ⟨B,hB⟩ := compact_continuous_bound hg.continuous hcg
  have hn (n : ℕ) (x : TFSpace) : ‖packetSmooth (ε n) g x‖ ≤ (L:ℝ)*r+B := by
    calc
      _ = ‖packetSmooth (ε n) g x-g x+g x‖ := by rw [sub_add_cancel]
      _ ≤ ‖packetSmooth (ε n) g x-g x‖+‖g x‖ := norm_add_le _ _
      _ ≤ (L:ℝ)*r+B := add_le_add ((packetSmooth_error (he n) hg x).trans
        (mul_le_mul_of_nonneg_left (heb n) L.coe_nonneg)) (hB x)
  apply tendsto_integral_of_dominated_convergence (fun x => ((L:ℝ)*r+B)*‖f x‖)
  · intro n
    exact ((packetSmooth_contDiff (he n) hg.continuous).continuous.aestronglyMeasurable).mul
      hf.aestronglyMeasurable
  · exact hf.norm.const_mul _
  · intro n
    exact Eventually.of_forall fun x => by
      rw [norm_mul]
      exact mul_le_mul_of_nonneg_right (hn n x) (norm_nonneg _)
  · exact Eventually.of_forall fun x => (packetSmooth_tendsto he hlim hg x).mul_const (f x)

end CoulombAnalysis

end

end OAI