import Mathlib
import OAI.Geometry.CAT0Fillings.Charts.Extensions
import OAI.Geometry.CAT0Fillings.Charts.CurrentAxioms

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 CAT0Fillings
open Set MeasureTheory Filter

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  (μ : Measure E) [Measure.IsAddHaarMeasure μ]
lemma LipschitzWith.ae_fderiv_zero_on_level {F : E → ℝ} {K : ℝ≥0}
    (hF : LipschitzWith K F) (c : ℝ) :
    ∀ᵐ x ∂μ, F x = c → fderiv ℝ F x = 0 := by
  have hset : MeasurableSet {x | F x = c} := isClosed_eq hF.continuous continuous_const |>.measurableSet
  apply (ae_restrict_iff' hset).mp
  have heq : EqOn F (fun _ => c) {x | F x = c} := fun _ hx => hx
  filter_upwards [ae_uniqueDiffWithinAt μ {x | F x = c},ae_restrict_mem hset,
    (hF.ae_differentiableAt (μ := μ)).filter_mono (ae_mono Measure.restrict_le_self)]
    with x hx hxc hd
  rw [← fderivWithin_eq_fderiv hx hd, fderivWithin_congr' heq hxc]
  simpa only [Function.const_def,Pi.zero_apply] using
    congrFun (fderivWithin_const (𝕜 := ℝ) (E := E) (s := {x | F x = c}) c) x

lemma ae_fderivWithin_zero_on_level {s : Set E} (hs : MeasurableSet s)
    {f : E → ℝ} {K : ℝ≥0} (hf : LipschitzOnWith K f s) (c : ℝ) :
    ∀ᵐ x ∂μ.restrict s, f x = c → fderivWithin ℝ f s x = 0 := by
  obtain ⟨F,hF,heq⟩ := hf.extend_real
  filter_upwards [ae_fderivWithin_eq_fderiv_extension μ hs hF heq,
    (LipschitzWith.ae_fderiv_zero_on_level μ hF c).filter_mono
      (ae_mono Measure.restrict_le_self),ae_restrict_mem hs] with x hx hz hxs
  intro hfc
  rw [hx]
  exact hz ((heq hxs).symm.trans hfc)

end CAT0Fillings

namespace CAT0Fillings.IntegerChart
variable {X : Type*} [MetricSpace X] [Nonempty X] {k : ℕ}
  (C : IntegerChart X (k+1))

lemma boundary_action_locality (b : X → ℝ) (π : Fin k → X → ℝ) (h : Admissible b π)
    (hloc : ∃ (i : Fin k) (U : Set X) (c : ℝ), IsOpen U ∧ Function.support b ⊆ U ∧
      ∀ x ∈ U, π i x = c) : C.action (fun _ => 1) (Matrix.vecCons b π) = 0 := by
  obtain ⟨i,U,c,hU,hb,hπ⟩ := hloc
  obtain ⟨L,J,hφ,_⟩ := C.bilipschitz
  obtain ⟨K,hK⟩ := h.1.1
  have hadm : Admissible (fun _ : X => (1:ℝ)) (Matrix.vecCons b π) :=
    ⟨BoundedLip.const 1,fun j => Fin.cases h.1.1 (fun l => h.2 l) j⟩
  rw [action,ite_eq_left hadm]
  apply integral_eq_zero_of_ae
  filter_upwards [ae_restrict_mem C.borel,
    ae_fderivWithin_zero_on_level volume C.borel (C.scalar_lipschitzOn hφ hK) 0]
    with z hz hzero
  have hdet : C.jacobian (Matrix.vecCons b π) z = 0 := by
    by_cases hbz : C.scalar b z = 0
    · apply Matrix.det_eq_zero_of_row_eq_zero 0
      intro j
      change fderivWithin ℝ (C.scalar b) C.domain z (EuclideanSpace.single j 1) = 0
      rw [hzero hbz]; rfl
    · have hext : C.paramExtended z = C.param ⟨z,hz⟩ := by simp [paramExtended,hz]
      have hzU : C.paramExtended z ∈ U := by
        rw [hext]
        apply hb
        simpa [Function.mem_support,C.scalar_eq hz] using hbz
      have hh := (C.continuousOn_paramExtended z hz).preimage_mem_nhdsWithin (hU.mem_nhds hzU)
      have heq : C.scalar (π i) =ᶠ[𝓝[C.domain] z] fun _ => c := by
        filter_upwards [hh,eventually_mem_nhdsWithin] with y hy hys
        rw [C.scalar_eq hys]
        have hye : C.paramExtended y = C.param ⟨y,hys⟩ := by simp [paramExtended,hys]
        exact hπ _ (hye ▸ hy)
      have heqz : C.scalar (π i) z = c := by
        rw [C.scalar_eq hz]
        exact hπ _ (hext ▸ hzU)
      have hd0 : fderivWithin ℝ (C.scalar (π i)) C.domain z = 0 :=
        (heq.fderivWithin_eq (𝕜 := ℝ) heqz).trans (by
          simpa only [Function.const_def,Pi.zero_apply] using
            congrFun (fderivWithin_const (𝕜 := ℝ) (E := Euc (k+1)) (s := C.domain) c) z)
      apply Matrix.det_eq_zero_of_row_eq_zero i.succ
      intro j
      change fderivWithin ℝ (C.scalar (π i)) C.domain z (EuclideanSpace.single j 1) = 0
      rw [hd0]; rfl
  rw [hdet,mul_zero]; rfl

end CAT0Fillings.IntegerChart

namespace CAT0Fillings
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X] {k : ℕ}

omit [BorelSpace X] in
lemma IntegerRectifiable.boundary_locality {T : Functional X (k+1)}
    (hT : IntegerRectifiable T) (b : X → ℝ) (π : Fin k → X → ℝ) (hab : Admissible b π)
    (hloc : ∃ (i : Fin k) (U : Set X) (c : ℝ), IsOpen U ∧ Function.support b ⊆ U ∧
      ∀ x ∈ U, π i x = c) : boundarySucc T b π = 0 := by
  classical
  rw [boundarySucc,ite_eq_left hab]
  obtain ⟨C,hd,hC,hs,heq⟩ := hT
  rw [heq]
  suffices hall : ∀ i, (C i).action (fun _ => 1) (Matrix.vecCons b π) = 0 by
    simp only [hall,tsum_zero]
  intro i
  rcases isEmpty_or_nonempty X with hX | hX
  · have hb0 : (fun _ : X => (1:ℝ)) = fun _ => 0 := funext (fun x => isEmptyElim x)
    rw [hb0]
    simpa using (hC i).linearFirst (fun _ => 0) (fun _ => 0) (Matrix.vecCons b π) 0 0
      (BoundedLip.const 0) (BoundedLip.const 0) (fun j => Fin.cases hab.1.1 (fun l => hab.2 l) j)
  · exact (C i).boundary_action_locality b π hab hloc

end CAT0Fillings

end

end OAI