import Mathlib
import OAI.Geometry.IntegralFillings.Slicing.NormalRestriction
import OAI.Geometry.IntegralFillings.Optimality.BallCurrent

namespace OAI

section

open Set Filter MeasureTheory
open scoped Topology ENNReal NNReal

namespace SharpIntegralFillings.Optimality
open SmoothCutoff

noncomputable def radiusFunction (d : ℕ) (x : UnitBall d) : ℝ := -‖x.val‖

lemma radiusFunction_lipschitz (d : ℕ) : LipschitzWith 1 (radiusFunction d) := by
  apply LipschitzWith.of_dist_le_mul
  intro x y
  simp only [radiusFunction, NNReal.coe_one, one_mul, dist_neg_neg, Real.dist_eq,
    Subtype.dist_eq]
  rw [dist_eq_norm]
  exact abs_norm_sub_norm_le x.val y.val

lemma radiusFunction_boundedLip (d : ℕ) : BoundedLip (radiusFunction d) := by
  refine ⟨⟨1, radiusFunction_lipschitz d⟩, 1, ?_⟩
  intro x
  simpa only [radiusFunction, abs_neg, abs_of_nonneg (norm_nonneg _),
    Metric.mem_closedBall, dist_zero_right] using x.property

noncomputable def radialProfile {d : ℕ} (a : ℝ≥0) (t : ℝ) (z : Euc d) : ℝ :=
  profile a t (-‖z‖)

lemma radialProfile_contDiff {d : ℕ} {a : ℝ≥0} {t : ℝ}
    (ha : 1 < (a:ℝ) * (-t)) : ContDiff ℝ 1 (radialProfile (d := d) a t) := by
  apply contDiff_iff_contDiffAt.mpr
  intro x
  by_cases hx : x = 0
  · subst x
    have hc : Continuous (fun z : Euc d => (a:ℝ) * (-‖z‖ - t)) := by fun_prop
    have he : radialProfile (d := d) a t =ᶠ[𝓝 0] fun _ => 1 := by
      have ha' : 1 < (a:ℝ) * (-‖(0 : Euc d)‖ - t) := by simpa using ha
      filter_upwards [hc.continuousAt.eventually (eventually_gt_nhds ha')] with z hz
      exact Real.smoothTransition.one_of_one_le hz.le
    exact contDiffAt_const.congr_of_eventuallyEq he
  · exact Real.smoothTransition.contDiff.contDiffAt.comp x
      (contDiffAt_const.mul ((contDiffAt_id.norm ℝ hx).neg.sub contDiffAt_const))

lemma radialProfile_compact {d : ℕ} (a : ℝ≥0) (t : ℝ) :
    HasCompactSupport (radialProfile (d := d) a t) := by
  apply HasCompactSupport.intro (isCompact_closedBall (0 : Euc d) (-t))
  intro x hx
  apply profile_zero
  have hh : -t < ‖x‖ := by simpa only [Metric.mem_closedBall, dist_zero_right, not_le] using hx
  linarith

lemma radialProfile_zero_outside {d : ℕ} (a : ℝ≥0) {t : ℝ} (ht : -1 < t)
    {x : Euc d} (hx : x ∉ Metric.ball 0 1) : radialProfile a t x = 0 := by
  apply profile_zero
  have hh : 1 ≤ ‖x‖ := by simpa only [Metric.mem_ball, dist_zero_right, not_lt] using hx
  linarith

lemma radialProfile_fderiv_zero_outside {d : ℕ} (a : ℝ≥0) {t : ℝ} (ht : -1 < t)
    {x : Euc d} (hx : x ∉ Metric.ball 0 1) : fderiv ℝ (radialProfile a t) x = 0 := by
  have hh : 1 ≤ ‖x‖ := by simpa only [Metric.mem_ball, dist_zero_right, not_lt] using hx
  have he : radialProfile a t =ᶠ[𝓝 x] fun _ => 0 := by
    have hc : Continuous (fun y : Euc d => -‖y‖) := continuous_norm.neg
    have hx' : -‖x‖ < t := by linarith
    filter_upwards [hc.continuousAt.eventually_lt_const hx'] with y hy
    exact profile_zero a hy.le
  simpa using he.fderiv_eq (𝕜 := ℝ)

lemma ballChart_param_lipschitz (d : ℕ) : LipschitzWith 1 (ballChart d).param := by
  apply LipschitzWith.of_dist_le_mul
  intro x y
  simp only [NNReal.coe_one, one_mul]
  rfl

lemma ballChart_scalar_extension {d : ℕ} {f : UnitBall d → ℝ} {K : ℝ≥0}
    (hf : LipschitzWith K f) :
    ∃ F : Euc d → ℝ, LipschitzWith K F ∧ EqOn ((ballChart d).scalar f) F (ballChart d).domain := by
  have hs : LipschitzOnWith K ((ballChart d).scalar f) (ballChart d).domain := by
    simpa using (ballChart d).scalar_lipschitzOn (ballChart_param_lipschitz d) hf
  exact hs.extend_real

lemma ballChart_action_extensions {d : ℕ} {b : UnitBall d → ℝ}
    {π : Fin d → UnitBall d → ℝ} {B : Euc d → ℝ} {P : Fin d → Euc d → ℝ}
    {K : Fin d → ℝ≥0} (hab : Admissible b π) (hP : ∀ i, LipschitzWith (K i) (P i))
    (hb : EqOn ((ballChart d).scalar b) B (ballChart d).domain)
    (hπ : ∀ i, EqOn ((ballChart d).scalar (π i)) (P i) (ballChart d).domain) :
    (ballChart d).action b π = ∫ z in Metric.ball 0 1,
      B z * coordinateJacobian P (fun j => EuclideanSpace.single j 1) z := by
  rw [IntegerChart.action, ite_eq_left hab]
  apply integral_congr_ae
  filter_upwards [(ballChart d).ae_jacobian_eq_extensions hP hπ,
    ae_restrict_mem (ballChart d).borel] with z hj hz
  change (1:ℤ) * ((ballChart d).scalar b z) * _ = _
  rw [Int.cast_one, one_mul, hb hz, hj]
  congr 1
  rw [coordinateJacobian, ← Matrix.det_transpose]
  rfl

lemma radialProfile_lipschitz {d : ℕ} (a : ℝ≥0) (t : ℝ) :
    ∃ K : ℝ≥0, LipschitzWith K (radialProfile (d := d) a t) := by
  obtain ⟨C, hC⟩ := exists_profile_bounds
  have hn : LipschitzWith 1 (fun z : Euc d => -‖z‖) := by
    apply LipschitzWith.of_dist_le_mul
    intro x y
    simp only [NNReal.coe_one, one_mul, dist_neg_neg, Real.dist_eq]
    rw [dist_eq_norm]
    exact abs_norm_sub_norm_le x y
  exact ⟨C*a*1, (hC a t).1.comp hn⟩

lemma ballChart_local_stokes {k : ℕ} {a : ℝ≥0} {t : ℝ} (ht : -1 < t)
    (ha : 1 < (a:ℝ) * (-t)) {b : UnitBall (k+1) → ℝ}
    {π : Fin k → UnitBall (k+1) → ℝ} (hab : Admissible b π) :
    (ballChart (k+1)).action (profile a t ∘ radiusFunction (k+1)) (Matrix.vecCons b π) =
      -(ballChart (k+1)).action b (Matrix.vecCons (profile a t ∘ radiusFunction (k+1)) π) := by
  let C := ballChart (k+1)
  let f := radialProfile (d := k+1) a t
  obtain ⟨K, hK⟩ := hab.1.1
  obtain ⟨B, hB, hBe⟩ := ballChart_scalar_extension hK
  choose L hL using hab.2
  choose P hP hPe using fun i => ballChart_scalar_extension (hL i)
  obtain ⟨J,hJ⟩ := radialProfile_lipschitz (d := k+1) a t
  have hprof := Slicing.profile_comp_boundedLip (radiusFunction_boundedLip (k+1)) a t
  have hfe : EqOn (C.scalar (profile a t ∘ radiusFunction (k+1))) f C.domain := by
    intro z hz
    rw [C.scalar_eq hz]
    rfl
  have hleft : C.action (profile a t ∘ radiusFunction (k+1)) (Matrix.vecCons b π) =
      ∫ z in Metric.ball 0 1, f z * coordinateJacobian (Fin.cons B P)
        (fun j => EuclideanSpace.single j 1) z := by
    apply ballChart_action_extensions (K := Fin.cons K L)
      (Foundations.admissible_vecCons hprof hab.1.1 hab.2)
    · intro i
      exact Fin.cases hB (fun j => hP j) i
    · exact hfe
    · intro i
      exact Fin.cases hBe (fun j => hPe j) i
  have hright : C.action b (Matrix.vecCons (profile a t ∘ radiusFunction (k+1)) π) =
      ∫ z in Metric.ball 0 1, B z * coordinateJacobian (Fin.cons f P)
        (fun j => EuclideanSpace.single j 1) z := by
    apply ballChart_action_extensions (K := Fin.cons J L)
      (Foundations.admissible_vecCons hab.1 hprof.1 hab.2)
    · intro i
      exact Fin.cases hJ (fun j => hP j) i
    · exact hBe
    · intro i
      exact Fin.cases hfe (fun j => hPe j) i
  rw [hleft, hright]
  rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun z hz => ?_)]
  · rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun z hz => ?_)]
    · have hPu : ∀ i, LipschitzWith (∑ j, L j) (P i) := fun i =>
        (hP i).weaken (Finset.single_le_sum (fun j _ => zero_le) (Finset.mem_univ i))
      exact integral_coordinateJacobian_cons volume (radialProfile_contDiff ha)
        (radialProfile_compact a t) hB hPu (fun j => EuclideanSpace.single j 1)
    · have hdf : fderiv ℝ f z = 0 := radialProfile_fderiv_zero_outside a ht hz
      have hdet : coordinateJacobian (Fin.cons f P) (fun j => EuclideanSpace.single j 1) z = 0 := by
        apply Matrix.det_eq_zero_of_column_eq_zero 0
        intro i
        change fderiv ℝ f z _ = 0
        rw [hdf]
        rfl
      rw [hdet, mul_zero]
  · rw [show f z = 0 from radialProfile_zero_outside a ht hz, zero_mul]

end SharpIntegralFillings.Optimality

end

end OAI