import Mathlib
import OAI.Geometry.IntegralFillings.Jacobian.WeakLimits
import OAI.Geometry.IntegralFillings.Charts.ExtensionsLimit
import OAI.Geometry.IntegralFillings.Charts.Scalar

namespace OAI

section
open Filter Set
open Set Filter MeasureTheory TopologicalSpace
open scoped Topology ENNReal
open Set MeasureTheory
open scoped RealInnerProductSpace
open Matrix
open scoped RealInnerProductSpace MatrixOrder
open Set Filter MeasureTheory
open scoped Topology ENNReal NNReal
open MeasureTheory Filter Set Metric
open scoped Topology Pointwise NNReal
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 scoped Topology NNReal

namespace SharpIntegralFillings
namespace IntegerChart
variable {X : Type*} [MetricSpace X] {k : ℕ} (C : IntegerChart X k)
lemma integrable_weight {b : X → ℝ} (hb : BoundedLip b) :
    Integrable (fun z => (C.multiplicity z : ℝ) * C.scalar b z)
      (volume.restrict C.domain) := by
  obtain ⟨K,hK⟩ := hb.1
  obtain ⟨M,hM⟩ := hb.2
  apply C.integrable.mul_bdd (C.measurable_scalar hK).aestronglyMeasurable
  filter_upwards [ae_restrict_mem C.borel] with z hz
  simpa [C.scalar_eq hz,Real.norm_eq_abs] using hM (C.param ⟨z,hz⟩)

lemma action_eq_extended_jacobian {b : X → ℝ} {π : Fin k → X → ℝ}
    (h : Admissible b π) {F : Fin k → Euc k → ℝ} {K : ℝ≥0}
    (hF : ∀ i, LipschitzWith K (F i))
    (heq : ∀ i, EqOn (C.scalar (π i)) (F i) C.domain) :
    C.action b π = ∫ z,
      C.domain.indicator (fun z => (C.multiplicity z : ℝ) * C.scalar b z) z *
        coordinateJacobian F (fun j => EuclideanSpace.single j 1) z := by
  rw [action,ite_eq_left h]
  have H := C.ae_jacobian_eq_extensions hF heq
  have H' : C.jacobian π =ᵐ[volume.restrict C.domain]
      coordinateJacobian F (fun j => EuclideanSpace.single j 1) := by
    filter_upwards [H] with z hz
    rw [hz,coordinateJacobian,← Matrix.det_transpose]
    rfl
  calc
    _ = ∫ z in C.domain, ((C.multiplicity z : ℝ) * C.scalar b z) *
        coordinateJacobian F (fun j => EuclideanSpace.single j 1) z := by
      apply integral_congr_ae
      filter_upwards [H'] with z hz
      rw [hz]
    _ = _ := by
      rw [← integral_indicator C.borel]
      apply integral_congr_ae
      filter_upwards [] with z
      exact Set.indicator_mul_left _ _ _

lemma action_sequentialContinuity (b : X → ℝ) (π : Fin k → X → ℝ)
    (πs : ℕ → Fin k → X → ℝ) (hb : BoundedLip b)
    (hπs : ∀ i, ∃ K : ℝ≥0, ∀ j, LipschitzWith K (πs j i))
    (hlim : ∀ i x, Tendsto (fun j => πs j i x) atTop (𝓝 (π i x))) :
    Tendsto (fun j => C.action b (πs j)) atTop (𝓝 (C.action b π)) := by
  obtain ⟨L,U,hφ,_⟩ := C.bilipschitz
  choose Ks hKs using hπs
  let K : ℝ≥0 := ∑ i, Ks i
  have hK (i : Fin k) : Ks i ≤ K :=
    Finset.single_le_sum (fun _ _ => bot_le) (Finset.mem_univ i)
  have hseq (j : ℕ) (i : Fin k) : LipschitzWith K (πs j i) := (hKs i j).weaken (hK i)
  have hπ (i : Fin k) : LipschitzWith K (π i) := by
    apply LipschitzWith.of_dist_le_mul
    intro x y
    exact le_of_tendsto ((hlim i x).dist (hlim i y))
      (Eventually.of_forall fun j => (hseq j i).dist_le_mul x y)
  have htot : TotallyBounded C.domain := C.bounded.isCompact_closure.totallyBounded.subset subset_closure
  have hsc (i : Fin k) (j : ℕ) : LipschitzOnWith (K*L) (C.scalar (πs j i)) C.domain :=
    C.scalar_lipschitzOn hφ (hseq j i)
  have hlsc (i : Fin k) (z : Euc k) (hz : z ∈ C.domain) :
      Tendsto (fun j => C.scalar (πs j i) z) atTop (𝓝 (C.scalar (π i) z)) := by
    simpa only [C.scalar_eq hz] using hlim i (C.param ⟨z,hz⟩)
  choose Fs F hFs hF heqs heq hlimF using fun i =>
    exists_convergent_lipschitz_extensions htot (hsc i) (hlsc i)
  let a : Euc k → ℝ := C.domain.indicator (fun z => (C.multiplicity z : ℝ) * C.scalar b z)
  have ha : Integrable a volume := (integrable_indicator_iff C.borel).mpr (C.integrable_weight hb)
  have H := weak_coordinateJacobian volume k (fun j i => hFs i j) hF hlimF
    (fun j => EuclideanSpace.single j 1) ha
  have heqs' (j : ℕ) := C.action_eq_extended_jacobian ⟨hb,fun i => ⟨K,hseq j i⟩⟩
    (fun i => hFs i j) (fun i => heqs i j)
  have heq' := C.action_eq_extended_jacobian ⟨hb,fun i => ⟨K,hπ i⟩⟩ hF heq
  simpa only [heqs',heq'] using H

end IntegerChart
end SharpIntegralFillings

end

end OAI