import Mathlib
import OAI.Geometry.CAT0Fillings.Currents.GeneralPush
import OAI.Geometry.CAT0Fillings.Radial.MassComparison
import OAI.Geometry.CAT0Fillings.Slicing.IntegralBoundary
import OAI.Geometry.CAT0Fillings.Swept.WholeMass

namespace OAI

section

open Set Filter MeasureTheory Matrix
open scoped Topology NNReal BigOperators

namespace CAT0Fillings
open CurrentOperations

variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X] [Nonempty X] {k : ℕ}

structure ChartGeometry {T : Functional X k} (hT : IsMetricCurrent T) where
  chart : ℕ → IntegerChart X k
  field : ℕ → Euc k → Seminorm ℝ (Euc k)
  disjoint : Pairwise (fun i j => Disjoint (chart i).image (chart j).image)
  summable : Summable (fun i => mass (chart i).action)
  action : ∀ b π, T b π = ∑' i, (chart i).action b π
  measurable : ∀ i v, Measurable (fun z => field i z v)
  differential : ∀ i, ∀ᵐ z ∂volume.restrict (chart i).domain,
    (∀ hz : z ∈ (chart i).domain, MetricDifferentiation.HasCenteredMetricDifferentialWithin
      (chart i).domain (chart i).param (field i z) ⟨z,hz⟩) ∧
    (∀ u v, field i z (u+v)^2+field i z (u-v)^2 = 2*field i z u^2+2*field i z v^2) ∧
    (∀ v, field i z v = 0 ↔ v = 0)
  integrable : ∀ i, Integrable (fun z => |((chart i).multiplicity z : ℝ)| *Real.sqrt
    (polarizationMatrix (field i z) (EuclideanSpace.basisFun (Fin k) ℝ).toBasis).det)
    (volume.restrict (chart i).domain)
  chart_mass : ∀ i, mass (chart i).action = ∫ z, |((chart i).multiplicity z : ℝ)| *Real.sqrt
    (polarizationMatrix (field i z) (EuclideanSpace.basisFun (Fin k) ℝ).toBasis).det
    ∂volume.restrict (chart i).domain
  measure_eq : MassMeasure.currentMassMeasure hT = Measure.sum (fun i =>
    (chart i).majorantMeasure (fun z => Real.sqrt
      (polarizationMatrix (field i z) (EuclideanSpace.basisFun (Fin k) ℝ).toBasis).det))
  total_mass : mass T = ∑' i, mass (chart i).action
  current : ∀ i, IsMetricCurrent (chart i).action
  control : ∀ i, Controls (chart i).action ((chart i).majorantMeasure (fun z =>
    Real.sqrt (polarizationMatrix (field i z)
      (EuclideanSpace.basisFun (Fin k) ℝ).toBasis).det))

theorem exists_chartGeometry {T : Functional X k}
    (hX : IsCAT0 X) (hT : IsMetricCurrent T) (hr : IntegerRectifiable T) :
    Nonempty (ChartGeometry hT) := by
  classical
  obtain ⟨C,hdis,hC,hsum,heq⟩ := hr
  choose P hPm hP hρ hfin hcontrol hmin hfield using
    fun i => (C i).exists_exact_quadratic_mass hX (hC i)
  choose p hPeq hpm hp using hfield
  simp only [hPeq] at hρ hfin hcontrol hmin
  let J (i : ℕ) (z : Euc k) := Real.sqrt
    (polarizationMatrix (p i z) (EuclideanSpace.basisFun (Fin k) ℝ).toBasis).det
  have hmass (i : ℕ) : mass (C i).action =
      ∫ z, |((C i).multiplicity z : ℝ)| *J i z ∂volume.restrict (C i).domain :=
    (C i).mass_eq_integral_majorant (hC i) (hρ i)
      (Eventually.of_forall fun _ => Real.sqrt_nonneg _) (hcontrol i) (hmin i)
  let μ (i : ℕ) : Measure X := (C i).majorantMeasure (J i)
  have hμfin : ∀ i, IsFiniteMeasure (μ i) := hfin
  let := hμfin
  have htot (i : ℕ) : (μ i).real univ = mass (C i).action := by
    have heqm : MassMeasure.currentMassMeasure (hC i) = μ i := by
      apply le_antisymm (MassMeasure.currentMassMeasure_le (hC i) (hcontrol i))
      exact hmin i _ inferInstance (MassMeasure.currentMassMeasure_controls (hC i))
    rw [←heqm]
    exact MassMeasure.currentMassMeasure_total _
  have hμsum : Summable (fun i => (μ i).real univ) := by simpa only [htot] using hsum
  let := finite_sum_measure_of_summable_total μ hμsum
  have hmeasure : MassMeasure.currentMassMeasure hT = Measure.sum μ := by
    apply le_antisymm
    · exact MassMeasure.currentMassMeasure_le hT (controls_sum_general hcontrol heq)
    · exact sum_measure_le_of_component_minimal hC hcontrol hmin heq
        (fun i => (C i).measurableSet_image) hdis
        (fun i => (C i).majorantMeasure_ae_image _) (MassMeasure.currentMassMeasure_controls hT)
  have htotal : mass T = ∑' i, mass (C i).action := by
    rw [←MassMeasure.currentMassMeasure_total hT,hmeasure]
    rw [measureReal_def,Measure.sum_apply _ MeasurableSet.univ,
      ENNReal.tsum_toReal_eq (fun i => measure_ne_top (μ i) univ)]
    exact tsum_congr htot
  exact ⟨⟨C,p,hdis,hsum,heq,hpm,hp,hρ,hmass,hmeasure,htotal,hC,hcontrol⟩⟩

namespace ChartGeometry
variable {T : Functional X k} {hT : IsMetricCurrent T} (q : ChartGeometry hT)

noncomputable def gram (i : ℕ) (z : Euc k) : Matrix (Fin k) (Fin k) ℝ :=
  polarizationMatrix (q.field i z) (EuclideanSpace.basisFun (Fin k) ℝ).toBasis
noncomputable def density (i : ℕ) (z : Euc k) : ℝ :=
  |((q.chart i).multiplicity z : ℝ)| *Real.sqrt (q.gram i z).det

lemma density_integrable (i : ℕ) : Integrable (q.density i)
    (volume.restrict (q.chart i).domain) := q.integrable i
lemma density_summable : Summable (fun i => ∫ z, q.density i z
    ∂volume.restrict (q.chart i).domain) := by
  simpa only [density,gram,q.chart_mass] using q.summable
lemma density_mass : mass T = ∑' i, ∫ z, q.density i z
    ∂volume.restrict (q.chart i).domain := by
  simpa only [density,gram,q.chart_mass] using q.total_mass

end ChartGeometry
end CAT0Fillings
end

section

open Set Filter MeasureTheory
open scoped Topology NNReal BigOperators

namespace CAT0Fillings
open CurrentOperations

variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X] [Nonempty X] {k : ℕ}

omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] [Nonempty X] in
lemma endpoint_lipschitz [MeasurableSpace X] [BorelSpace X] [CompactSpace X] [Nonempty X]
    (t : Icc (0:ℝ) 1) :
    LipschitzWith 1 (fun y : X => (t,y) : X → ClosedCylinder X) := by
  simpa using (LipschitzWith.const t).prodMk
    (LipschitzWith.id : LipschitzWith 1 (id : X → X))

theorem swept_boundary_integral
    {T : Functional X (k+1)} (hT : IsIntegral (k+1) T) (hz : boundarySucc T = 0)
    (C : ℕ → IntegerChart X (k+1))
    (hd : Pairwise (fun i j => Disjoint (C i).image (C j).image))
    (hs : Summable (fun i => mass (C i).action))
    (heq : ∀ b π, T b π = ∑' i, (C i).action b π)
    (F : ClosedCylinder X → X) {K : ℝ≥0} (hF : LipschitzWith K F)
    (hF0 : ∀ y, F (⟨0,by constructor <;> norm_num⟩,y) = y) :
    IsIntegral (k+2) (pushCurrent F (closedPrismFamily C)) ∧
    boundarySucc (pushCurrent F (closedPrismFamily C)) =
      pushCurrent (fun y => F (⟨1,by constructor <;> norm_num⟩,y)) T - T := by
  let f : X → X := fun y => F (⟨1,by constructor <;> norm_num⟩,y)
  have hf : LipschitzWith K f := by
    simpa only [mul_one,Function.comp_def,f] using
      hF.comp (endpoint_lipschitz (X := X) ⟨1,by constructor <;> norm_num⟩)
  let : Nonempty (ClosedCylinder X) := ⟨(⟨0,by constructor <;> norm_num⟩,Classical.choice inferInstance)⟩
  have hb : boundarySucc (pushCurrent F (closedPrismFamily C)) = pushCurrent f T - T := by
    funext b π
    by_cases hab : Admissible b π
    · rw [pushCurrent_boundarySucc _ hF,pushCurrent_apply _ _ hab,
        closedPrismFamily_boundary_cycle hT.1 hT.2.1 hz C hs heq _ _
          (admissible_comp hab hF)]
      simp only [Pi.sub_apply,pushCurrent_apply _ _ hab,Function.comp_apply,hF0,f]
      rfl
    · simp only [boundarySucc,Pi.sub_apply,pushCurrent,ite_eq_right hab,
        hT.1.offDomain b π hab,sub_self]
  have hbi := (integral_push hT hf).sub hT
  refine ⟨⟨pushCurrent_isMetricCurrent (closedPrismFamily_current C hs) hF,
    integerRectifiable_push (closedPrismFamily_rectifiable C hd hs) hF,?_,?_⟩,hb⟩
  · rw [hb]; exact hbi.1
  · rw [hb]; exact hbi.2.1

end CAT0Fillings
end

section

open Set Filter MeasureTheory Matrix
open scoped Topology NNReal BigOperators

namespace CAT0Fillings
open CurrentOperations

variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X] [Nonempty X] {k : ℕ}

namespace ChartGeometry
variable {T : Functional X k} {hT : IsMetricCurrent T} (q : ChartGeometry hT)

noncomputable def sweptMass (o : X) (g : X → ℝ) : ℝ :=
  ∑' i, ∫ z, |((q.chart i).multiplicity z : ℝ)| *(q.chart i).sweptWeight (q.field i) o g z
    ∂volume.restrict (q.chart i).domain

lemma swept_integrable_summable (o : X) {g : X → ℝ} {K : ℝ≥0}
    (hg : LipschitzWith K g) (hg0 : ∀ y, 0 ≤ g y) :
    (∀ i, Integrable (fun z => |((q.chart i).multiplicity z : ℝ)| *
      (q.chart i).sweptWeight (q.field i) o g z)
      (volume.restrict (q.chart i).domain)) ∧
    Summable (fun i => ∫ z, |((q.chart i).multiplicity z : ℝ)| *
      (q.chart i).sweptWeight (q.field i) o g z ∂volume.restrict (q.chart i).domain) := by
  obtain ⟨B,hB⟩ := isCompact_univ.exists_bound_of_continuousOn
    ((continuous_const.dist continuous_id).mul hg.continuous).continuousOn
  apply summable_swept_integrals q.chart q.field q.measurable q.differential q.integrable
    q.density_summable o hg hg0
  intro y
  exact (le_abs_self _).trans (by simpa only [Real.norm_eq_abs,Pi.mul_apply,id_eq] using hB y (mem_univ y))

lemma sweptMass_nonneg (o : X) {g : X → ℝ} (hg0 : ∀ y, 0 ≤ g y) :
    0 ≤ q.sweptMass o g := by
  apply tsum_nonneg
  intro i
  apply integral_nonneg_of_ae
  filter_upwards [(q.chart i).ae_sweptWeight_nonneg (q.field i) o hg0] with z hz
  exact mul_nonneg (abs_nonneg _) hz

lemma sweptMass_const_mul (o : X) (g : X → ℝ) (h : ℝ) :
    q.sweptMass o (fun y => h*g y) = h*q.sweptMass o g := by
  have hs (C : IntegerChart X k) : C.scalar (fun y => h*g y) = fun z => h*C.scalar g z := by
    funext z
    by_cases hz : z ∈ C.domain <;> simp [IntegerChart.scalar,hz]
  simp only [sweptMass,IntegerChart.sweptWeight,hs]
  simp_rw [show ∀ (a b c d e : ℝ), a*(b*(h*c)*d*e) = h*(a*(b*c*d*e)) by intros; ring]
  simp only [integral_const_mul,tsum_mul_left]

end ChartGeometry

theorem exists_swept_current {T : Functional X (k+1)}
    (hT : IsIntegral (k+1) T) (hz : boundarySucc T = 0) (q : ChartGeometry hT.1)
    (seg : X → X → ℝ → X)
    (hseg : ∀ o x a b, a ∈ Icc (0:ℝ) 1 → b ∈ Icc (0:ℝ) 1 →
      dist (seg o x a) (seg o x b) = |a-b| *dist o x)
    (hcomp : ∀ o x y a b, a ∈ Icc (0:ℝ) 1 → b ∈ Icc (0:ℝ) 1 →
      dist (seg o x a) (seg o y b)^2 ≤ (a*dist o x-b*dist o y)^2+
        a*b*(dist x y^2-(dist o x-dist o y)^2))
    (hseg1 : ∀ o x, seg o x 1 = x)
    (o : X) {g : X → ℝ} {K : ℝ≥0} (hg : LipschitzWith K g)
    (hg0 : ∀ y, 0 ≤ g y) (hg1 : ∀ y, g y ≤ 1) :
    ∃ S : Functional X (k+2), IsIntegral (k+2) S ∧
      boundarySucc S = pushCurrent (fun y => seg o y (1-g y)) T - T ∧
      mass S ≤ q.sweptMass o g := by
  obtain ⟨F,⟨L,hF⟩,hFeq,hFcl⟩ := exists_swept_radial_map seg hseg hcomp o hg hg0 hg1
  have hF0 : ∀ y, F (⟨0,by constructor <;> norm_num⟩,y) = y := by
    intro y
    rw [hFeq]
    simp only [zero_mul,sub_zero,hseg1]
  obtain ⟨hS,hb⟩ := swept_boundary_integral hT hz q.chart q.disjoint q.summable q.action F hF hF0
  obtain ⟨hI,hIs⟩ := q.swept_integrable_summable o hg hg0
  refine ⟨pushCurrent F (closedPrismFamily q.chart),hS,?_,?_⟩
  · simpa only [hFeq,one_mul] using hb
  · exact whole_swept_mass_le q.chart q.summable seg hcomp o g hg hg0 hg1 F hF hFcl
      q.field hI hIs q.differential

end CAT0Fillings
end

end OAI