import Mathlib
import OAI.Geometry.CAT0Fillings.Calculus.LipschitzFTC
import OAI.Geometry.CAT0Fillings.Reconstruction.Slices
import OAI.Geometry.CAT0Fillings.Reconstruction.AtomGraphs

namespace OAI

section

open Set Filter MeasureTheory Metric
open scoped Topology NNReal

namespace CAT0Fillings.Slicing
open Foundations MassMeasure BorelRestriction BorelCoefficients

attribute [local instance] Classical.propDecidable
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X]

omit [MeasurableSpace X] [BorelSpace X] in
lemma boundedLip_of_lipschitz_compact {f : X → ℝ} {K : ℝ≥0}
    (hf : LipschitzWith K f) : BoundedLip f := by
  refine ⟨⟨K, hf⟩, ?_⟩
  obtain ⟨M, hM⟩ := isCompact_univ.exists_bound_of_continuousOn hf.continuous.continuousOn
  exact ⟨M, fun x => by simpa only [Real.norm_eq_abs] using hM x (mem_univ _)⟩

noncomputable def outerCutoff (p : X) (r : ℝ) (x : X) : ℝ :=
  min 1 (max 0 ((dist x p - r) / r))

omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in
lemma outerCutoff_lipschitz (p : X) (r : ℝ) :
    LipschitzWith (Real.nnabs (1 / r)) (outerCutoff p r) := by
  have h' : LipschitzWith (Real.nnabs (1/r)) (fun x : X => (dist x p-r)/r) := by
    apply LipschitzWith.of_dist_le_mul
    intro x y
    change dist ((dist x p-r)/r) ((dist y p-r)/r) ≤ |1/r| * dist x y
    calc
      _ = |1/r| * |dist x p - dist y p| := by
        rw [Real.dist_eq, show (dist x p-r)/r - (dist y p-r)/r =
          (1/r)*(dist x p-dist y p) by ring, abs_mul]
      _ ≤ _ := mul_le_mul_of_nonneg_left (abs_dist_sub_le x y p) (abs_nonneg _)
  exact (h'.const_max 0).const_min 1

omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in
lemma outerCutoff_eq_one (p : X) {r : ℝ} (hr : 0 < r) {x : X}
    (hx : 2*r ≤ dist x p) : outerCutoff p r x = 1 := by
  have h : 1 ≤ (dist x p - r) / r := (le_div_iff₀ hr).mpr (by linarith)
  simp only [outerCutoff, min_eq_left (h.trans (le_max_right _ _))]

omit [MeasurableSpace X] [BorelSpace X] [CompactSpace X] in
lemma outerCutoff_support (p : X) {r : ℝ} (hr : 0 < r) :
    Function.support (outerCutoff p r) ⊆ {x | r < dist x p} := by
  intro x hx
  by_contra h
  have hd : dist x p ≤ r := le_of_not_gt h
  have hv : (dist x p - r) / r ≤ 0 := div_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr hd) hr.le
  exact hx (by simp only [outerCutoff, max_eq_left hv, min_eq_right (by norm_num : (0 : ℝ) ≤ 1)])

lemma restrict_zero_separated {k : ℕ} {T : Functional X k}
    (hT : IsMetricCurrent T) {E : Set X} (hE : MeasurableSet E)
    {p : X} {r : ℝ} (hr : 0 < r) (hEr : ∀ x ∈ E, 2*r ≤ dist x p)
    {b : X → ℝ} {π : Fin k → X → ℝ} (hab : Admissible b π)
    (hb : ∀ x, r ≤ dist x p → b x = 0) :
    restrictCurrent hT E b π = 0 := by
  rw [restrictCurrent_apply hT E hab]
  have he : E.indicator b = (0 : X → ℝ) := by
    funext x
    by_cases hx : x ∈ E
    · simp [hx, hb x (by linarith [hEr x hx])]
    · simp [hx]
  rw [borelAction_of_integrable _ hT
    ((integrable_boundedLip _ hab.1).indicator hE) π hab.2]
  simp [he]

lemma boundary_restrict_zero_separated {k : ℕ} {T : Functional X (k+1)}
    (hT : IsMetricCurrent T) {E : Set X} (hE : MeasurableSet E)
    {p : X} {r : ℝ} (hr : 0 < r) (hEr : ∀ x ∈ E, 2*r ≤ dist x p)
    {b : X → ℝ} {π : Fin k → X → ℝ} (hab : Admissible b π)
    (hb : ∀ x, r ≤ dist x p → b x = 0) :
    boundarySucc (restrictCurrent hT E) b π = 0 := by
  have hπ : ∀ i, ∃ K, LipschitzWith K (Matrix.vecCons b π i) :=
    fun i => Fin.cases hab.1.1 (fun j => hab.2 j) i
  rw [boundarySucc, ite_eq_left hab, restrictCurrent_apply hT E ⟨BoundedLip.const 1, hπ⟩]
  have he : E.indicator (fun _ : X => (1 : ℝ)) =
      (fun x => E.indicator (fun _ : X => (1 : ℝ)) x * outerCutoff p r x) := by
    funext x
    by_cases hx : x ∈ E
    · simp only [indicator_of_mem hx, one_mul, outerCutoff_eq_one p hr (hEr x hx)]
    · simp only [indicator_of_notMem hx, zero_mul]
  rw [he]
  apply borelAction_locality_mul _ hT (currentMassMeasure_controls hT)
    ((integrable_const (1 : ℝ)).indicator hE)
    (boundedLip_of_lipschitz_compact (outerCutoff_lipschitz p r)) _ hπ
  refine ⟨0, {x | r < dist x p}, 0,
    isOpen_lt continuous_const (continuous_id.dist continuous_const),
    outerCutoff_support p hr, ?_⟩
  intro x hx
  exact hb x hx.le

lemma superlevelSlice_zero_separated {k : ℕ} {T : Functional X (k+1)}
    (hT : IsMetricCurrent T) (hB : IsMetricCurrent (boundarySucc T))
    {u : X → ℝ} (hu : Continuous u) (t : ℝ)
    {p : X} {r : ℝ} (hr : 0 < r)
    (hside : (∀ x, t < u x → 2*r ≤ dist x p) ∨
      (∀ x, u x ≤ t → 2*r ≤ dist x p))
    {b : X → ℝ} {π : Fin k → X → ℝ} (hab : Admissible b π)
    (hb : ∀ x, r ≤ dist x p → b x = 0) :
    superlevelSlice hT hB u t b π = 0 := by
  have hE : MeasurableSet {x | t < u x} :=
    measurableSet_lt measurable_const hu.measurable
  rcases hside with hside | hside
  · change restrictCurrent hB _ b π - boundarySucc (restrictCurrent hT _) b π = 0
    rw [restrict_zero_separated hB hE hr hside hab hb,
      boundary_restrict_zero_separated hT hE hr hside hab hb, sub_self]
  · have hside' : ∀ x ∈ {x | t < u x}ᶜ, 2*r ≤ dist x p := by
      intro x hx
      exact hside x (le_of_not_gt hx)
    have hCB := restrictCurrent_complement_sum hB hE b π
    rw [restrict_zero_separated hB hE.compl hr hside' hab hb, add_zero] at hCB
    have hCT := restrictCurrent_complement_sum hT hE (fun _ => 1) (Matrix.vecCons b π)
    have hπ : Admissible (fun _ : X => (1 : ℝ)) (Matrix.vecCons b π) :=
      ⟨BoundedLip.const 1, fun i => Fin.cases hab.1.1 (fun j => hab.2 j) i⟩
    have hcz := boundary_restrict_zero_separated hT hE.compl hr hside' hab hb
    rw [boundarySucc, ite_eq_left hab] at hcz
    rw [hcz, add_zero] at hCT
    change restrictCurrent hB _ b π - boundarySucc (restrictCurrent hT _) b π = 0
    rw [hCB]
    simp only [boundarySucc, ite_eq_left hab]
    rw [hCT, sub_self]

end CAT0Fillings.Slicing

namespace CAT0Fillings.Slicing
open Foundations MassMeasure BorelRestriction BorelCoefficients SliceReconstruction

attribute [local instance] Classical.propDecidable
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X]

lemma unitRepresentation_atoms_on_level {T : Functional X 1}
    (hT : IsMetricCurrent T) (hB : IsMetricCurrent (boundarySucc T))
    {u : X → ℝ} (hu : Continuous u) (t : ℝ)
    {m : ℕ} {a : Fin m → ℤ} {x : Fin m → X}
    (ha : ∀ i, a i ≠ 0) (hx : Function.Injective x)
    (hS : UnitRepresentation (superlevelSlice hT hB u t) a x) (i : Fin m) :
    u (x i) = t := by
  classical
  by_contra hne
  have hside : ∃ δ > 0, (∀ y, t < u y → δ ≤ dist y (x i)) ∨
      (∀ y, u y ≤ t → δ ≤ dist y (x i)) := by
    rcases lt_or_gt_of_ne hne with hlt | hgt
    · obtain ⟨δ, hδ, hball⟩ := Metric.isOpen_iff.mp
        (isOpen_lt hu continuous_const) (x i) hlt
      refine ⟨δ, hδ, Or.inl ?_⟩
      intro y hy
      apply le_of_not_gt
      intro hyd
      have : u y < t := hball (by simpa only [mem_ball] using hyd)
      exact (lt_trans hy this).false
    · obtain ⟨δ, hδ, hball⟩ := Metric.isOpen_iff.mp
        (isOpen_lt continuous_const hu) (x i) hgt
      refine ⟨δ, hδ, Or.inr ?_⟩
      intro y hy
      apply le_of_not_gt
      intro hyd
      have : t < u y := hball (by simpa only [mem_ball] using hyd)
      exact (not_lt_of_ge hy) this
  obtain ⟨δ, hδ, hside⟩ := hside
  have he : ∀ᶠ r : ℝ in 𝓝 0, r < 1 ∧ 2*r < δ ∧
      ∀ j : Fin m, j ≠ i → r < dist (x j) (x i) := by
    refine (eventually_lt_nhds zero_lt_one).and ?_
    have hδ' : ∀ᶠ r : ℝ in 𝓝 0, 2*r < δ := by
      filter_upwards [eventually_lt_nhds (half_pos hδ)] with r hr
      linarith
    refine hδ'.and ?_
    simp only [Filter.eventually_all]
    intro j hji
    exact eventually_lt_nhds (dist_pos.mpr (fun h => hji (hx h)))
  obtain ⟨ε, hε, hεball⟩ := Metric.mem_nhds_iff.mp he
  let r := ε/2
  have hr0 : 0 < r := half_pos hε
  have hr := hεball (show r ∈ ball (0 : ℝ) ε by
    simpa only [mem_ball, Real.dist_eq, sub_zero, abs_of_pos hr0] using half_lt_self hε)
  let b : X → ℝ := fun y => max 0 (r - dist y (x i))
  have hb : LipschitzWith 1 b := by
    have hs : LipschitzWith 1 (fun y : X => r - dist y (x i)) := by
      simpa only [zero_add] using (LipschitzWith.const r).sub (LipschitzWith.dist_left (x i))
    exact hs.const_max 0
  have hb1 : ∀ y, |b y| ≤ 1 := by
    intro y
    rw [abs_of_nonneg (le_max_left _ _)]
    exact max_le zero_le_one (by linarith [@dist_nonneg X _ y (x i), hr.1])
  have hbfar : ∀ y, r ≤ dist y (x i) → b y = 0 := by
    intro y hy
    exact max_eq_left (sub_nonpos.mpr hy)
  have hsz : superlevelSlice hT hB u t b (fun j => Fin.elim0 j) = 0 := by
    apply superlevelSlice_zero_separated hT hB hu t hr0 _
      ⟨⟨⟨1,hb⟩,1,hb1⟩, fun j => Fin.elim0 j⟩ hbfar
    rcases hside with hside | hside
    · exact Or.inl fun y hy => hr.2.1.le.trans (hside y hy)
    · exact Or.inr fun y hy => hr.2.1.le.trans (hside y hy)
  have hsum : (∑ j, (a j : ℝ) * b (x j)) = (a i : ℝ) * r := by
    rw [Finset.sum_eq_single i]
    · simp only [b, dist_self, sub_zero, max_eq_right hr0.le]
    · intro j _ hji
      rw [hbfar _ (hr.2.2 j hji).le, mul_zero]
    · simp
  have heq := hS b hb hb1
  rw [hsz, hsum] at heq
  have hai : (a i : ℝ) ≠ 0 := by exact_mod_cast ha i
  exact (mul_ne_zero hai hr0.ne') heq.symm

end CAT0Fillings.Slicing
end

section

open Set Filter MeasureTheory Metric TopologicalSpace
open scoped Topology NNReal

namespace CAT0Fillings.SliceReconstruction
open Slicing

attribute [local instance] Classical.propDecidable
variable {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
  [CompactSpace X] [Nonempty X]

omit [MeasurableSpace X] [BorelSpace X] in
lemma atomCode_atoms_injective (c : AtomCode) (hc : c.Valid (X := X))
    (x : Fin c.size → X)
    (hx : ∀ i, dist (x i) (denseSeq X (c.centers i)) ≤ c.radius) :
    Function.Injective x := by
  intro i j hij
  by_contra hne
  have hsep := hc.2.2.2 i j hne
  have htri := dist_triangle (denseSeq X (c.centers i)) (x i) (denseSeq X (c.centers j))
  rw [dist_comm (denseSeq X (c.centers i)) (x i), hij] at htri
  have hi := hx i
  rw [hij] at hi
  linarith [hi, hx j, hc.1]

lemma selectedAtom_on_level {T : Functional X 1}
    (hT : IsMetricCurrent T) (hB : IsMetricCurrent (boundarySucc T))
    {u : X → ℝ} (hu : Continuous u) (E : Set ℝ) (c : AtomCode)
    (t : atomDomain (superlevelSlice hT hB u) E c) (i : Fin c.size) :
    u (selectedAtom (superlevelSlice hT hB u) E c t i) = t := by
  have hs := selectedAtom_spec (superlevelSlice hT hB u) E c t
  exact unitRepresentation_atoms_on_level hT hB hu t t.property.2.1.2.2.1
    (atomCode_atoms_injective c t.property.2.1 _ hs.1) hs.2 i

theorem exists_compact_bilipschitz_scalar_atom_graphs {T : Functional X 1}
    (hT : IsMetricCurrent T) (hB : IsMetricCurrent (boundarySucc T))
    {u : X → ℝ} {K : ℝ≥0} (hu : LipschitzWith K u)
    (hI : ∀ᵐ t : ℝ, IsIntegral 0 (superlevelSlice hT hB u t)) :
    ∃ (D : PieceIndex × AtomCode → Set ℝ)
      (γ : ∀ i : PieceIndex × AtomCode, D i → Fin i.2.size → X),
      (∀ i, IsCompact (D i)) ∧ (∀ᵐ t : ℝ, t ∈ ⋃ i, D i) ∧
      (∀ i j, LipschitzWith (i.1.1 : ℝ≥0) (fun t => γ i t j)) ∧
      (∀ i j, AntilipschitzWith K (fun t => γ i t j)) ∧
      (∀ i (t : D i) j, u (γ i t j) = t) ∧
      (∀ i (t : D i), UnitRepresentation (superlevelSlice hT hB u t) i.2.weights (γ i t)) ∧
      (∀ i (t : D i), Function.Injective (γ i t)) := by
  classical
  obtain ⟨E, hEc, hEae, hLip⟩ := exists_compact_slice_lipschitz_pieces hT hB hu.continuous
  let S := superlevelSlice hT hB u
  let D (i : PieceIndex × AtomCode) : Set ℝ := atomDomain S (E i.1) i.2
  let γ (i : PieceIndex × AtomCode) (t : D i) := selectedAtom S (E i.1) i.2 t
  have hL (i : PieceIndex) (b : X → ℝ) (hb : LipschitzWith 1 b) (hb1 : ∀ x, |b x| ≤ 1) :
      LipschitzOnWith (i.1 : ℝ≥0) (fun t => S t b (fun j => Fin.elim0 j)) (E i) :=
    hLip i b (fun j => Fin.elim0 j) hb hb1 (fun j => Fin.elim0 j)
  refine ⟨D, γ, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
  · intro i
    exact isCompact_atomDomain S (hEc i.1) i.2
      (fun b hb hb1 => (hL i.1 b hb hb1).continuousOn)
  · filter_upwards [hEae, hI] with t ht hIt
    obtain ⟨i, hi⟩ := mem_iUnion.mp ht
    obtain ⟨c, hc⟩ := integral_mem_atomDomain S hi hIt
    exact mem_iUnion.mpr ⟨(i,c), hc⟩
  · intro i j
    exact selectedAtom_lipschitz S (E i.1) i.2 (hL i.1) j
  · intro i j
    apply AntilipschitzWith.of_le_mul_dist
    intro s t
    have hs := selectedAtom_on_level hT hB hu.continuous (E i.1) i.2 s j
    have ht := selectedAtom_on_level hT hB hu.continuous (E i.1) i.2 t j
    have h := hu.dist_le_mul (γ i s j) (γ i t j)
    rw [hs, ht] at h
    exact h
  · intro i t j
    exact selectedAtom_on_level hT hB hu.continuous (E i.1) i.2 t j
  · intro i t
    exact (selectedAtom_spec S (E i.1) i.2 t).2
  · intro i t
    exact atomCode_atoms_injective i.2 t.property.2.1 _
      (selectedAtom_spec S (E i.1) i.2 t).1

end CAT0Fillings.SliceReconstruction
end

end OAI