import Mathlib
import OAI.Geometry.IntegralFillings.Currents.WeightedAction
import OAI.Geometry.IntegralFillings.Currents.Contraction

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 Filter Set
open scoped Topology NNReal
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

namespace SharpIntegralFillings
open Set MeasureTheory Filter BorelCoefficients

variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X] {k : ℕ} {T : Functional X (k+1)}
lemma weightedCurrent_boundary_cycle (hT : IsMetricCurrent T) (hrect : IntegerRectifiable T)
    (hz : IsCycle T) (μ : Measure X) [IsFiniteMeasure μ] (hμ : Controls T μ)
    {u : X → ℝ} (hu : BoundedLip u) :
    boundarySucc (weightedCurrent μ hT u) = - contractCurrent u T := by
  classical
  funext b π
  by_cases hab : Admissible b π
  · have hcons : Admissible (fun _ : X => (1:ℝ)) (Matrix.vecCons b π) :=
      ⟨BoundedLip.const 1,fun i => Fin.cases hab.1.1 (fun j => hab.2 j) i⟩
    simp only [boundarySucc,ite_eq_left hab,weightedCurrent,ite_eq_left hcons,mul_one,
      Pi.neg_apply,contractCurrent_apply _ _ hab]
    rw [borelAction_eq μ hT hμ ⟨hu,fun i => Fin.cases hab.1.1 (fun j => hab.2 j) i⟩]
    exact Foundations.IntegerRectifiable.cycle_product_rule hrect hz hu hab.1 π hab.2
  · simp only [boundarySucc,ite_eq_right hab,Pi.neg_apply,contractCurrent,neg_zero]

lemma weightedCurrent_boundary_controls (hT : IsMetricCurrent T) (hrect : IntegerRectifiable T)
    (hz : IsCycle T) (μ : Measure X) [IsFiniteMeasure μ] (hμ : Controls T μ)
    {u : X → ℝ} (hu : BoundedLip u) {K : ℝ≥0} (hK : LipschitzWith K u) :
    Controls (boundarySucc (weightedCurrent μ hT u)) (K • μ) := by
  rw [weightedCurrent_boundary_cycle hT hrect hz μ hμ hu]
  intro b π hb hπ
  simpa only [Pi.neg_apply,abs_neg] using contractCurrent_controls hT hμ hK b π hb hπ

end SharpIntegralFillings

namespace SharpIntegralFillings.IntegerChart
open Set MeasureTheory Filter

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

lemma ae_fderivWithin_scalar_comp {u : X → ℝ} {K : ℝ≥0} (hu : LipschitzWith K u)
    {φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t) :
    ∀ᵐ z ∂volume.restrict C.domain,
      fderivWithin ℝ (C.scalar (φ ∘ u)) C.domain z =
        dφ (C.scalar u z) • fderivWithin ℝ (C.scalar u) C.domain z := by
  filter_upwards [ae_uniqueDiffWithinAt volume C.domain,ae_restrict_mem C.borel,
    C.ae_differentiableWithinAt_scalar hu] with z hz hzs hdu
  have heq : EqOn (C.scalar (φ ∘ u)) (φ ∘ C.scalar u) C.domain := by
    intro y hy
    simp only [Function.comp_apply,C.scalar_eq hy]
  have hh := (hφ (C.scalar u z)).comp_hasFDerivWithinAt z hdu.hasFDerivWithinAt
  exact (hh.congr heq (heq hzs)).fderivWithin hz

lemma ae_jacobian_update_comp (π : Fin k → X → ℝ) (i : Fin k)
    {u : X → ℝ} {K : ℝ≥0} (hu : LipschitzWith K u)
    {φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t) :
    ∀ᵐ z ∂volume.restrict C.domain,
      C.jacobian (Function.update π i (φ ∘ u)) z =
        dφ (C.scalar u z) * C.jacobian (Function.update π i u) z := by
  filter_upwards [C.ae_fderivWithin_scalar_comp hu hφ] with z hz
  rw [C.jacobian_update,C.jacobian_update,hz]
  simpa only [_root_.smul_apply,Pi.smul_def,smul_eq_mul] using Matrix.det_updateRow_smul
    (Matrix.of fun a j => fderivWithin ℝ (C.scalar (π a)) C.domain z (EuclideanSpace.single j 1))
    i (dφ (C.scalar u z))
    (fun j => fderivWithin ℝ (C.scalar u) C.domain z (EuclideanSpace.single j 1))

lemma action_update_comp {b u : X → ℝ} (hb : BoundedLip b) (hu : BoundedLip u)
    {φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t)
    (hφu : BoundedLip (φ ∘ u)) (hdu : BoundedLip (dφ ∘ u))
    (π : Fin k → X → ℝ) (hπ : ∀ j, ∃ K : ℝ≥0, LipschitzWith K (π j)) (i : Fin k) :
    C.action b (Function.update π i (φ ∘ u)) =
      C.action (fun x => b x * dφ (u x)) (Function.update π i u) := by
  obtain ⟨K,hK⟩ := hu.1
  have hup {a : X → ℝ} (ha : BoundedLip a) :
      ∀ j, ∃ K : ℝ≥0, LipschitzWith K ((Function.update π i a) j) := by
    intro j
    by_cases hji : j = i
    · simpa [hji] using ha.1
    · simpa [hji] using hπ j
  rw [action,ite_eq_left ⟨hb,hup hφu⟩,action,ite_eq_left ⟨hb.mul hdu,hup hu⟩]
  apply integral_congr_ae
  filter_upwards [C.ae_jacobian_update_comp π i hK hφ,ae_restrict_mem C.borel] with z hz hzs
  rw [hz,C.scalar_eq hzs,C.scalar_eq hzs,C.scalar_eq hzs]
  ring

end SharpIntegralFillings.IntegerChart

namespace SharpIntegralFillings.Foundations
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] [CompactSpace X]

omit [BorelSpace X] [CompactSpace X] in
lemma IntegerRectifiable.apply_update_comp {k : ℕ} {T : Functional X k}
    (hT : IntegerRectifiable T) {b u : X → ℝ} (hb : BoundedLip b) (hu : BoundedLip u)
    {φ dφ : ℝ → ℝ} (hφ : ∀ t, HasDerivAt φ (dφ t) t)
    (hφu : BoundedLip (φ ∘ u)) (hdu : BoundedLip (dφ ∘ u))
    (π : Fin k → X → ℝ) (hπ : ∀ j, ∃ K : ℝ≥0, LipschitzWith K (π j)) (i : Fin k) :
    T b (Function.update π i (φ ∘ u)) =
      T (fun x => b x * dφ (u x)) (Function.update π i u) := by
  obtain ⟨C,_,_,_,heq⟩ := hT
  rw [heq,heq]
  apply tsum_congr
  intro j
  exact (C j).action_update_comp hb hu hφ hφu hdu π hπ i

end SharpIntegralFillings.Foundations

end

end OAI