import Mathlib
import OAI.Geometry.IntegralFillings.Charts.MultiplicityRestriction
import OAI.Geometry.IntegralFillings.Currents.ActionSeries

namespace OAI

section
open Set MeasureTheory Measure Filter Module
open Set Filter MeasureTheory Measure ContinuousLinearMap
open scoped Topology Convolution NNReal
open Set Filter MeasureTheory Measure Metric
open scoped Topology ContDiff
open Set Filter Metric
open Set MeasureTheory Filter
open Set Filter MeasureTheory
open scoped Topology ENNReal NNReal
open Filter Set
open scoped Topology NNReal
open Set Filter MeasureTheory TopologicalSpace
open scoped Topology ENNReal
open MeasureTheory Filter Set Metric
open scoped Topology Pointwise NNReal
open Set MeasureTheory
open scoped RealInnerProductSpace
open Matrix
open scoped RealInnerProductSpace MatrixOrder

namespace SharpIntegralFillings
attribute [local instance] Classical.propDecidable
open BorelCoefficients BorelRestriction MassMeasure

theorem integerRectifiable_restrict
    {X : Type*} [MetricSpace X] [CompactSpace X]
    [MeasurableSpace X] [BorelSpace X] [Nonempty X]
    {k : ℕ} {T : Functional X k} (hT : IsMetricCurrent T)
    (hrect : IntegerRectifiable T) {E : Set X} (hE : MeasurableSet E) :
    IntegerRectifiable (restrictCurrent hT E) := by
  obtain ⟨C,hdis,hC,hsum,heq⟩ := hrect
  let D : ℕ → IntegerChart X k := fun i => (C i).restrictMultiplicity E hE
  have hD (i) : IsMetricCurrent (D i).action :=
    (C i).restrictMultiplicity_isMetricCurrent (hC i) hE
  refine ⟨D,hdis,hD,?_,?_⟩
  · apply hsum.of_nonneg_of_le (fun i => mass_nonneg (D i).action)
    exact fun i => (C i).restrictMultiplicity_mass_le (hC i) hE
  · let μ (i) := currentMassMeasure (hC i)
    have hμfin : ∀ i, IsFiniteMeasure (μ i) := fun i => inferInstance
    let := hμfin
    have hμsum : Summable (fun i => (μ i).real univ) := by
      simpa only [μ,currentMassMeasure_total] using hsum
    let := finite_sum_measure_of_summable_total μ hμsum
    have hμ (i) : Controls (C i).action (μ i) := currentMassMeasure_controls (hC i)
    intro b π
    by_cases hab : Admissible b π
    · rw [restrictCurrent_apply hT E hab,
        borelAction_independent (currentMassMeasure hT) hT
          (currentMassMeasure_controls hT) (controls_sum hμ heq)
          ((integrable_boundedLip _ hab.1).indicator hE)
          ((integrable_boundedLip _ hab.1).indicator hE) π hab.2,
        borelAction_sum μ hT hC hμ heq
          ((integrable_boundedLip _ hab.1).indicator hE) π hab.2]
      apply tsum_congr
      intro i
      change _ = ((C i).restrictMultiplicity E hE).action b π
      rw [(C i).restrictMultiplicity_action (hC i) hE,restrictCurrent_apply (hC i) E hab]
    · rw [(restrictCurrent_isMetricCurrent hT hE).offDomain b π hab]
      symm
      calc
        (∑' i, (D i).action b π) = ∑' (_i : ℕ), (0 : ℝ) :=
          tsum_congr (fun i => (hD i).offDomain b π hab)
        _ = 0 := tsum_zero

end SharpIntegralFillings

namespace SharpIntegralFillings
open MeasureTheory Filter Set
open scoped Topology

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
  [MeasurableSpace E] [BorelSpace E]

lemma ae_fderivWithin_restrict_domain (μ : Measure E) [μ.IsAddHaarMeasure]
    {s t : Set E} (hs : MeasurableSet s) (ht : MeasurableSet t) (hts : t ⊆ s)
    {f g : E → ℝ} {K : ℝ≥0} (hf : LipschitzOnWith K f s) (hgf : EqOn g f t) :
    ∀ᵐ x ∂μ.restrict t, fderivWithin ℝ g t x = fderivWithin ℝ f s x := by
  obtain ⟨F,hF,hfF⟩ := hf.extend_real
  have hgF : EqOn g F t := fun x hx => (hgf hx).trans (hfF (hts hx))
  filter_upwards [ae_fderivWithin_eq_fderiv_extension μ ht hF hgF,
    (ae_fderivWithin_eq_fderiv_extension μ hs hF hfF).filter_mono
      (ae_mono (Measure.restrict_mono hts le_rfl))] with x hx hy
  exact hx.trans hy.symm

namespace IntegerChart
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  {k : ℕ} (C : IntegerChart X k)

noncomputable def restrictDomain {t : Set (Euc k)} (ht : MeasurableSet t)
    (hts : t ⊆ C.domain) : IntegerChart X k where
  domain := t
  borel := ht
  bounded := C.bounded.subset hts
  param := fun z => C.param ⟨z,hts z.property⟩
  bilipschitz := by
    obtain ⟨K,J,hK,hJ⟩ := C.bilipschitz
    refine ⟨K,J,LipschitzWith.of_dist_le_mul (fun a b =>
      hK.dist_le_mul ⟨a,hts a.property⟩ ⟨b,hts b.property⟩),?_⟩
    exact AntilipschitzWith.of_le_mul_dist (fun a b =>
      hJ.le_mul_dist ⟨a,hts a.property⟩ ⟨b,hts b.property⟩)
  multiplicity := C.multiplicity
  integrable := C.integrable.mono_measure (Measure.restrict_mono hts le_rfl)

omit [MeasurableSpace X] [BorelSpace X] in
lemma restrictDomain_scalar {t : Set (Euc k)} (ht : MeasurableSet t) (hts : t ⊆ C.domain)
    (b : X → ℝ) : EqOn ((C.restrictDomain ht hts).scalar b) (C.scalar b) t := by
  classical
  intro x hx
  change (if hz : x ∈ t then b (C.param ⟨x,hts hz⟩) else 0) = C.scalar b x
  rw [dite_eq_left hx,scalar,dite_eq_left (hts hx)]

omit [MeasurableSpace X] [BorelSpace X] in
lemma restrictDomain_jacobian_ae {t : Set (Euc k)} (ht : MeasurableSet t)
    (hts : t ⊆ C.domain) {π : Fin k → X → ℝ}
    (hπ : ∀ i, ∃ K : ℝ≥0, LipschitzWith K (π i)) :
    (C.restrictDomain ht hts).jacobian π =ᵐ[volume.restrict t] C.jacobian π := by
  have hderiv : ∀ᵐ x ∂volume.restrict t, ∀ i,
      fderivWithin ℝ ((C.restrictDomain ht hts).scalar (π i)) t x =
        fderivWithin ℝ (C.scalar (π i)) C.domain x := by
    rw [eventually_all]
    intro i
    obtain ⟨K,hK⟩ := hπ i
    obtain ⟨L,J,hL,_⟩ := C.bilipschitz
    exact ae_fderivWithin_restrict_domain volume C.borel ht hts
      (C.scalar_lipschitzOn hL hK) (C.restrictDomain_scalar ht hts (π i))
  filter_upwards [hderiv] with x hx
  unfold jacobian
  congr 1
  funext i j
  exact congrArg (fun l => l (EuclideanSpace.single j 1)) (hx i)

variable [CompactSpace X] [Nonempty X]

omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in
lemma paramExtended_mem_image_iff {t : Set (Euc k)} (hts : t ⊆ C.domain)
    {x : Euc k} (hx : x ∈ C.domain) :
    C.paramExtended x ∈ C.paramExtended '' t ↔ x ∈ t := by
  constructor
  · rintro ⟨y,hy,hxy⟩
    obtain ⟨K,J,_,hJ⟩ := C.bilipschitz
    have hxy' : C.param ⟨y,hts hy⟩ = C.param ⟨x,hx⟩ := by
      simpa only [paramExtended,dite_eq_left hx,dite_eq_left (hts hy)] using hxy
    have heq : y = x := congrArg Subtype.val (hJ.injective hxy')
    exact heq ▸ hy
  · exact fun h => ⟨x,h,rfl⟩

lemma restrictDomain_action {t : Set (Euc k)} (ht : MeasurableSet t)
    (hts : t ⊆ C.domain) (hC : IsMetricCurrent C.action) :
    (C.restrictDomain ht hts).action =
      BorelRestriction.restrictCurrent hC (C.paramExtended '' t) := by
  classical
  let E := C.paramExtended '' t
  have hE : MeasurableSet E := C.measurableSet_paramExtended_image ht hts
  rw [←C.restrictMultiplicity_action hC hE]
  funext b π
  by_cases hadm : Admissible b π
  · rw [action,action,ite_eq_left hadm,ite_eq_left hadm]
    change (∫ z in t, (C.multiplicity z : ℝ)*(C.restrictDomain ht hts).scalar b z*
      (C.restrictDomain ht hts).jacobian π z) =
      ∫ z in C.domain, (↑((C.paramExtended ⁻¹' E).indicator C.multiplicity z) : ℝ)*
        C.scalar b z*C.jacobian π z
    calc
      _ = ∫ z in t, (C.multiplicity z : ℝ)*C.scalar b z*C.jacobian π z := by
        apply integral_congr_ae
        filter_upwards [C.restrictDomain_jacobian_ae ht hts hadm.2,ae_restrict_mem ht] with z hz hzt
        rw [hz,C.restrictDomain_scalar ht hts b hzt]
      _ = ∫ z in C.domain, t.indicator (fun z =>
          (C.multiplicity z : ℝ)*C.scalar b z*C.jacobian π z) z := by
        rw [integral_indicator ht,Measure.restrict_restrict ht,inter_eq_left.mpr hts]
      _ = _ := by
        apply integral_congr_ae
        filter_upwards [ae_restrict_mem C.borel] with z hz
        have he : z ∈ C.paramExtended ⁻¹' E ↔ z ∈ t := C.paramExtended_mem_image_iff hts hz
        by_cases hzt : z ∈ t
        · simp only [indicator_of_mem hzt,indicator_of_mem (he.mpr hzt)]
        · simp only [indicator_of_notMem hzt,indicator_of_notMem (mt he.mp hzt),Int.cast_zero,zero_mul]
  · simp only [action,ite_eq_right hadm]

lemma restrictDomain_isMetricCurrent {t : Set (Euc k)} (ht : MeasurableSet t)
    (hts : t ⊆ C.domain) (hC : IsMetricCurrent C.action) :
    IsMetricCurrent (C.restrictDomain ht hts).action := by
  rw [C.restrictDomain_action ht hts hC]
  exact BorelRestriction.restrictCurrent_isMetricCurrent hC
    (C.measurableSet_paramExtended_image ht hts)

lemma restrictDomain_mass {t : Set (Euc k)} (ht : MeasurableSet t)
    (hts : t ⊆ C.domain) (hC : IsMetricCurrent C.action) :
    mass (C.restrictDomain ht hts).action =
      (MassMeasure.currentMassMeasure hC).real (C.paramExtended '' t) := by
  rw [C.restrictDomain_action ht hts hC,
    BorelRestriction.restriction_mass hC (C.measurableSet_paramExtended_image ht hts)]

end IntegerChart
end SharpIntegralFillings
open Set Filter MeasureTheory
open scoped Topology ENNReal NNReal

namespace SharpIntegralFillings

attribute [local instance] Classical.propDecidable

universe u

end SharpIntegralFillings

end

end OAI