import Mathlib

namespace OAI

namespace StrictFilling

def clip (lo hi t : ℝ) : ℝ := max lo (min t hi)

lemma clip_eq_self {lo hi t : ℝ} (hl : lo ≤ t) (hu : t ≤ hi) :
    clip lo hi t = t := by
  simp [clip, min_eq_left hu, max_eq_right hl]

lemma clip_same (c t : ℝ) : clip c c t = c := by
  exact max_eq_left (min_le_right _ _)

lemma clip_between_zero {lo hi t : ℝ}
    (hl : lo ≤ max 0 t) (hu : min 0 t ≤ hi) :
    clip lo hi t ∈ Set.uIcc 0 t := by
  change min 0 t ≤ max lo (min t hi) ∧ max lo (min t hi) ≤ max 0 t
  constructor
  · exact (le_min (min_le_right _ _) hu).trans (le_max_right _ _)
  · exact max_le hl ((min_le_left _ _).trans (le_max_right _ _))

def medianZero (a b : ℝ) : ℝ := max (min a b) (min (max a b) 0)

lemma medianZero_properties (a b : ℝ) :
    medianZero a b ∈ Set.uIcc 0 a ∧
    medianZero a b ∈ Set.uIcc 0 b ∧
    |medianZero a b - a| ≤ |a - b| ∧
    |medianZero a b - b| ≤ |a - b| := by
  unfold medianZero
  change (min 0 a ≤ _ ∧ _ ≤ max 0 a) ∧
    (min 0 b ≤ _ ∧ _ ≤ max 0 b) ∧ _
  simp only [min_def, max_def]
  split_ifs <;> simp_all only [abs_le] <;>
    and_intros <;> first | trivial | linarith [le_abs_self (a-b), neg_le_abs (a-b)]

section Metric

variable {X : Type*} [PseudoMetricSpace X]

lemma lipschitz_add_const {f : X → ℝ} (hf : LipschitzWith 1 f) (c : ℝ) :
    LipschitzWith 1 (fun x => c + f x) := by
  apply LipschitzWith.mk_one
  intro x y
  simpa only [Real.dist_eq, add_sub_add_left_eq_sub, NNReal.coe_one, one_mul] using
    hf.dist_le_mul x y

lemma lipschitz_const_sub {f : X → ℝ} (hf : LipschitzWith 1 f) (c : ℝ) :
    LipschitzWith 1 (fun x => c - f x) := by
  simpa only [sub_eq_add_neg, Pi.neg_apply] using lipschitz_add_const hf.neg c

lemma lipschitz_clip {h r : X → ℝ} (hh : LipschitzWith 1 h)
    (hr : LipschitzWith 1 r) (c : ℝ) :
    LipschitzWith 1 (fun x => clip (c - r x) (c + r x) (h x)) := by
  simpa only [clip, max_self] using
    (lipschitz_const_sub hr c).max (hh.min (lipschitz_add_const hr c))

lemma endpoint_lower {h : X → ℝ} (hh : LipschitzWith 1 h)
    {u : X} {c : ℝ} (hc : c ∈ Set.uIcc 0 (h u)) (x : X) :
    c - dist x u ≤ max 0 (h x) := by
  have hc' : c ≤ max 0 (h u) := hc.2
  have hd := hh.dist_le_mul u x
  simp only [Real.dist_eq, NNReal.coe_one, one_mul, abs_le] at hd
  have hd0 : 0 ≤ dist x u := dist_nonneg
  rw [dist_comm u x] at hd
  rcases le_total 0 (h u) with hu | hu
  · rw [max_eq_right hu] at hc'
    exact (show c - dist x u ≤ h x by linarith).trans (le_max_right _ _)
  · rw [max_eq_left hu] at hc'
    exact (show c - dist x u ≤ 0 by linarith).trans (le_max_left _ _)

lemma endpoint_upper {h : X → ℝ} (hh : LipschitzWith 1 h)
    {u : X} {c : ℝ} (hc : c ∈ Set.uIcc 0 (h u)) (x : X) :
    min 0 (h x) ≤ c + dist x u := by
  have hc' : min 0 (h u) ≤ c := hc.1
  have hd := hh.dist_le_mul u x
  simp only [Real.dist_eq, NNReal.coe_one, one_mul, abs_le] at hd
  have hd0 : 0 ≤ dist x u := dist_nonneg
  rw [dist_comm u x] at hd
  rcases le_total 0 (h u) with hu | hu
  · rw [min_eq_left hu] at hc'
    exact (min_le_left _ _).trans (by linarith)
  · rw [min_eq_right hu] at hc'
    exact (min_le_right _ _).trans (show h x ≤ c + dist x u by linarith)

lemma cone_preserves_interval {h : X → ℝ} (hh : LipschitzWith 1 h)
    {u : X} {c : ℝ} (hc : c ∈ Set.uIcc 0 (h u)) (x : X) :
    clip (c - dist x u) (c + dist x u) (h x) ∈ Set.uIcc 0 (h x) :=
  clip_between_zero (endpoint_lower hh hc x) (endpoint_upper hh hc x)

def twoRadius (u v x : X) : ℝ := min (dist x u) (dist x v)

def twoClip (h : X → ℝ) (u v : X) (c : ℝ) (x : X) : ℝ :=
  clip (c - twoRadius u v x) (c + twoRadius u v x) (h x)

lemma twoRadius_lipschitz (u v : X) : LipschitzWith 1 (twoRadius u v) := by
  change LipschitzWith 1 (fun x => min (dist x u) (dist x v))
  simpa only [max_self] using
    (LipschitzWith.dist_left u).min (LipschitzWith.dist_left v)

lemma twoClip_lipschitz {h : X → ℝ} (hh : LipschitzWith 1 h)
    (u v : X) (c : ℝ) : LipschitzWith 1 (twoClip h u v c) :=
  lipschitz_clip hh (twoRadius_lipschitz u v) c

lemma twoClip_between_zero {h : X → ℝ} (hh : LipschitzWith 1 h)
    {u v : X} {c : ℝ}
    (hcu : c ∈ Set.uIcc 0 (h u)) (hcv : c ∈ Set.uIcc 0 (h v)) (x : X) :
    twoClip h u v c x ∈ Set.uIcc 0 (h x) := by
  unfold twoClip twoRadius
  rcases le_total (dist x u) (dist x v) with hd | hd
  · rw [min_eq_left hd]
    exact cone_preserves_interval hh hcu x
  · rw [min_eq_right hd]
    exact cone_preserves_interval hh hcv x

lemma twoClip_endpoints (h : X → ℝ) (u v : X) (c : ℝ) :
    twoClip h u v c u = c ∧ twoClip h u v c v = c := by
  simp only [twoClip, twoRadius, dist_self, min_eq_left dist_nonneg,
    min_eq_right dist_nonneg, sub_zero, add_zero, clip_same, and_self]

lemma cone_eq_self_of_dist {h : X → ℝ} {u : X} {c : ℝ} (x : X)
    (hc : |c - h x| ≤ dist x u) :
    clip (c - dist x u) (c + dist x u) (h x) = h x := by
  apply clip_eq_self <;> have := (abs_le.mp hc) <;> linarith

lemma twoClip_eq_self {h : X → ℝ} {u v : X} {c : ℝ} (x : X)
    (hcu : |c - h x| ≤ dist x u) (hcv : |c - h x| ≤ dist x v) :
    twoClip h u v c x = h x := by
  apply clip_eq_self <;>
    have hl := (abs_le.mp hcu) <;> have hr := (abs_le.mp hcv) <;>
    unfold twoRadius <;> rw [min_def] <;> split_ifs <;> linarith

lemma pin_compatible {h : X → ℝ} (hh : LipschitzWith 1 h)
    {u s : X} {c : ℝ} (hc : c ∈ Set.uIcc 0 (h u))
    (hs : |h s| ≤ 1 / 2) (hsep : 1 ≤ dist s u) :
    |c - h s| ≤ dist s u := by
  have hd := hh.dist_le_mul u s
  rw [dist_comm u s] at hd
  simp only [Real.dist_eq, NNReal.coe_one, one_mul, abs_le] at hd
  have hs' := abs_le.mp hs
  rcases Set.mem_uIcc.mp hc with h | h <;>
    apply abs_le.mpr <;> constructor <;> linarith

lemma room_compatible {h : X → ℝ} {u s : X} {c : ℝ}
    (hc : |c - h u| ≤ 2)
    (hroom : |h u - h s| ≤ dist u s - 2) :
    |c - h s| ≤ dist s u := by
  rw [dist_comm s u]
  calc
    |c - h s| ≤ |c - h u| + |h u - h s| := abs_sub_le c (h u) (h s)
    _ ≤ 2 + (dist u s - 2) := add_le_add hc hroom
    _ = dist u s := by ring

theorem strict_filling_movable_first
    (h : X → ℝ) (shell pins : Set X) (I : X → Set ℝ) (u v : X)
    (hsep : ∀ x y : X, x ≠ y → 1 ≤ dist x y)
    (hedge : dist u v = 1) (hh : LipschitzWith 1 h)
    (hpin : ∀ s ∈ pins, |h s| ≤ 1 / 2)
    (hI : ∀ x ∉ shell ∪ pins, (I x).OrdConnected ∧ 0 ∈ I x ∧ h x ∈ I x)
    (hu : u ∉ shell ∪ pins)
    (hroom : ∀ x, (x = u ∨ x = v) → x ∉ shell ∪ pins →
      ∀ s ∈ shell, |h x - h s| ≤ dist x s - 2) :
    ∃ g : X → ℝ, LipschitzWith 1 g ∧
      (∀ s ∈ shell ∪ pins, g s = h s) ∧
      (∀ x ∉ shell ∪ pins, g x ∈ I x) ∧ |g u - g v| ≤ 1 / 2 := by
  have hdist : |h u - h v| ≤ 1 := by
    simpa only [Real.dist_eq, NNReal.coe_one, one_mul, hedge] using hh.dist_le_mul u v
  have hsep_u : ∀ s ∈ shell ∪ pins, 1 ≤ dist s u := by
    intro s hs
    exact hsep s u (by intro hsu; subst s; exact hu hs)
  by_cases hv : v ∈ shell ∪ pins
  · have hvshell : v ∉ shell := by
      intro hvs
      have hr := hroom u (Or.inl rfl) hu v hvs
      rw [hedge] at hr
      linarith [abs_nonneg (h u - h v)]
    have hvpin : v ∈ pins := hv.resolve_left hvshell
    have hvbound := hpin v hvpin
    have hubound : |0 - h u| ≤ 2 := by
      have ht := abs_sub_le (h u) (h v) 0
      rw [sub_zero, sub_zero] at ht
      simpa only [zero_sub, abs_neg] using
        (show |h u| ≤ 2 by linarith)
    let g := twoClip h u u 0
    refine ⟨g, twoClip_lipschitz hh u u 0, ?_, ?_, ?_⟩
    · intro s hs
      change twoClip h u u 0 s = h s
      have hc : |0 - h s| ≤ dist s u := by
        rcases hs with hss | hsp
        · exact room_compatible hubound (hroom u (Or.inl rfl) hu s hss)
        · simpa only [zero_sub, abs_neg] using
            (hpin s hsp).trans (by linarith [hsep_u s (Or.inr hsp)])
      exact twoClip_eq_self s hc hc
    · intro x hx
      exact (hI x hx).1.uIcc_subset (hI x hx).2.1 (hI x hx).2.2
        (twoClip_between_zero hh (Set.left_mem_uIcc) (Set.left_mem_uIcc) x)
    · have hgu : g u = 0 := (twoClip_endpoints h u u 0).1
      have hgv : g v = h v := by
        apply twoClip_eq_self
        all_goals simpa only [zero_sub, abs_neg] using
          hvbound.trans (by linarith [hsep_u v hv])
      rw [hgu, hgv, zero_sub, abs_neg]
      exact hvbound
  · let c := medianZero (h u) (h v)
    have hc := medianZero_properties (h u) (h v)
    have hcu : c ∈ Set.uIcc 0 (h u) := hc.1
    have hcv : c ∈ Set.uIcc 0 (h v) := hc.2.1
    have hcu2 : |c - h u| ≤ 2 := (hc.2.2.1.trans hdist).trans (by norm_num)
    have hcv2 : |c - h v| ≤ 2 := (hc.2.2.2.trans hdist).trans (by norm_num)
    let g := twoClip h u v c
    refine ⟨g, twoClip_lipschitz hh u v c, ?_, ?_, ?_⟩
    · intro s hs
      have hc1 : |c - h s| ≤ dist s u := by
        rcases hs with hss | hsp
        · exact room_compatible hcu2 (hroom u (Or.inl rfl) hu s hss)
        · exact pin_compatible hh hcu (hpin s hsp) (hsep_u s (Or.inr hsp))
      have hc2 : |c - h s| ≤ dist s v := by
        rcases hs with hss | hsp
        · exact room_compatible hcv2 (hroom v (Or.inr rfl) hv s hss)
        · exact pin_compatible hh hcv (hpin s hsp)
            (hsep s v (by intro hsv; subst s; exact hv (Or.inr hsp)))
      exact twoClip_eq_self s hc1 hc2
    · intro x hx
      exact (hI x hx).1.uIcc_subset (hI x hx).2.1 (hI x hx).2.2
        (twoClip_between_zero hh hcu hcv x)
    · have he := twoClip_endpoints h u v c
      change |twoClip h u v c u - twoClip h u v c v| ≤ _
      rw [he.1, he.2, sub_self, abs_zero]
      norm_num

theorem strict_filling
    (h : X → ℝ) (shell pins : Set X) (I : X → Set ℝ) (u v : X)
    (hsep : ∀ x y : X, x ≠ y → 1 ≤ dist x y)
    (hedge : dist u v = 1) (hh : LipschitzWith 1 h)
    (hpin : ∀ s ∈ pins, |h s| ≤ 1 / 2)
    (hI : ∀ x ∉ shell ∪ pins, (I x).OrdConnected ∧ 0 ∈ I x ∧ h x ∈ I x)
    (hnotfixed : ¬ (u ∈ shell ∪ pins ∧ v ∈ shell ∪ pins))
    (hroom : ∀ x, (x = u ∨ x = v) → x ∉ shell ∪ pins →
      ∀ s ∈ shell, |h x - h s| ≤ dist x s - 2) :
    ∃ g : X → ℝ, LipschitzWith 1 g ∧
      (∀ s ∈ shell ∪ pins, g s = h s) ∧
      (∀ x ∉ shell ∪ pins, g x ∈ I x) ∧ |g u - g v| ≤ 1 / 2 := by
  by_cases hu : u ∈ shell ∪ pins
  · have hv : v ∉ shell ∪ pins := fun hv => hnotfixed ⟨hu, hv⟩
    obtain ⟨g, hg, hgf, hgi, hge⟩ := strict_filling_movable_first h shell pins I v u
      hsep (by rw [dist_comm]; exact hedge) hh hpin hI hv
      (fun x hx => hroom x hx.symm)
    refine ⟨g, hg, hgf, hgi, ?_⟩
    simpa only [abs_sub_comm] using hge
  · exact strict_filling_movable_first h shell pins I u v hsep hedge hh hpin hI hu hroom

end Metric

abbrev Component {V : Type*} (G : SimpleGraph V) (u : V) := {x : V // G.Reachable u x}

noncomputable instance componentMetric {V : Type*} (G : SimpleGraph V) (u : V) :
    MetricSpace (Component G u) where
  dist x y := (G.dist x.val y.val : ℝ)
  dist_self x := by simp
  dist_comm x y := by rw [G.dist_comm]
  dist_triangle x y z := by
    exact_mod_cast (x.property.symm.trans y.property).dist_triangle_left z.val
  eq_of_dist_eq_zero := by
    intro x y h
    apply Subtype.ext
    exact (x.property.symm.trans y.property).dist_eq_zero_iff.mp (by exact_mod_cast h)

lemma edge_bound_walk {V : Type*} {G : SimpleGraph V} {h : V → ℝ}
    (hh : ∀ x y, G.Adj x y → |h x - h y| ≤ 1)
    {x y : V} (p : G.Walk x y) : |h x - h y| ≤ (p.length : ℝ) := by
  induction p with
  | nil => simp
  | @cons x y z hxy p ih =>
    calc
      |h x - h z| ≤ |h x - h y| + |h y - h z| := abs_sub_le _ _ _
      _ ≤ 1 + (p.length : ℝ) := add_le_add (hh _ _ hxy) ih
      _ = ((SimpleGraph.Walk.cons hxy p).length : ℝ) := by simp; ring

lemma edge_bound_dist {V : Type*} {G : SimpleGraph V} {h : V → ℝ}
    (hh : ∀ x y, G.Adj x y → |h x - h y| ≤ 1)
    {x y : V} (hr : G.Reachable x y) : |h x - h y| ≤ (G.dist x y : ℝ) := by
  obtain ⟨p, hp⟩ := hr.exists_walk_length_eq_dist
  simpa only [hp] using edge_bound_walk hh p

lemma component_lipschitz {V : Type*} {G : SimpleGraph V} {h : V → ℝ}
    (hh : ∀ x y, G.Adj x y → |h x - h y| ≤ 1) (u : V) :
    LipschitzWith 1 (fun x : Component G u => h x.val) := by
  apply LipschitzWith.mk_one
  intro x y
  exact edge_bound_dist hh (x.property.symm.trans y.property)

lemma component_separated {V : Type*} {G : SimpleGraph V} {u : V}
    (x y : Component G u) (hxy : x ≠ y) : 1 ≤ dist x y := by
  change (1 : ℝ) ≤ (G.dist x.val y.val : ℝ)
  exact_mod_cast (x.property.symm.trans y.property).pos_dist_of_ne
    (by intro h; exact hxy (Subtype.ext h))

theorem graph_strict_filling {V : Type*} [Finite V]
    (G : SimpleGraph V) (h : V → ℝ) (shell pins : Set V) (I : V → Set ℝ)
    (u v : V) (hedge : G.Adj u v)
    (hh : ∀ x y, G.Adj x y → |h x - h y| ≤ 1)
    (hpin : ∀ s ∈ pins, |h s| ≤ 1 / 2)
    (hI : ∀ x ∉ shell ∪ pins, (I x).OrdConnected ∧ 0 ∈ I x ∧ h x ∈ I x)
    (hnotfixed : ¬ (u ∈ shell ∪ pins ∧ v ∈ shell ∪ pins))
    (hroom : ∀ x, (x = u ∨ x = v) → x ∉ shell ∪ pins →
      ∀ s ∈ shell, G.Reachable x s → |h x - h s| ≤ (G.dist x s : ℝ) - 2) :
    ∃ g : V → ℝ,
      (∀ x y, G.Adj x y → |g x - g y| ≤ 1) ∧
      (∀ s ∈ shell ∪ pins, g s = h s) ∧
      (∀ x ∉ shell ∪ pins, g x ∈ I x) ∧ |g u - g v| ≤ 1 / 2 := by
  classical
  let C := Component G u
  let uC : C := ⟨u, .refl u⟩
  let vC : C := ⟨v, hedge.reachable⟩
  let shellC : Set C := {x | x.val ∈ shell}
  let pinsC : Set C := {x | x.val ∈ pins}
  have hedgeC : dist uC vC = 1 := by
    change (G.dist u v : ℝ) = 1
    exact_mod_cast SimpleGraph.dist_eq_one_iff_adj.mpr hedge
  obtain ⟨gc, hgclip, hgcf, hgci, hgce⟩ :=
    strict_filling (fun x : C => h x.val) shellC pinsC (fun x => I x.val) uC vC
      (fun x y hxy => component_separated x y hxy) hedgeC (component_lipschitz hh u)
      (fun s hs => hpin s.val hs) (fun x hx => hI x.val hx) hnotfixed
      (by
        intro x hx hxnot s hs
        change |h x.val - h s.val| ≤ (G.dist x.val s.val : ℝ) - 2
        apply hroom x.val _ hxnot s.val hs (x.property.symm.trans s.property)
        rcases hx with hx | hx
        · exact Or.inl (congrArg Subtype.val hx)
        · exact Or.inr (congrArg Subtype.val hx))
  let g : V → ℝ := fun x => if hx : G.Reachable u x then gc ⟨x, hx⟩ else h x
  refine ⟨g, ?_, ?_, ?_, ?_⟩
  · intro x y hxy
    by_cases hx : G.Reachable u x
    · have hy := hx.trans hxy.reachable
      have hc := hgclip.dist_le_mul (⟨x, hx⟩ : C) (⟨y, hy⟩ : C)
      change |gc ⟨x, hx⟩ - gc ⟨y, hy⟩| ≤ 1 * (G.dist x y : ℝ) at hc
      simpa only [g, dite_eq_left hx, dite_eq_left hy, one_mul,
        SimpleGraph.dist_eq_one_iff_adj.mpr hxy, Nat.cast_one] using hc
    · have hy : ¬ G.Reachable u y := fun hy => hx (hy.trans hxy.symm.reachable)
      simpa only [g, dite_eq_right hx, dite_eq_right hy] using hh x y hxy
  · intro s hs
    by_cases hx : G.Reachable u s
    · exact (dite_eq_left hx).trans (hgcf ⟨s, hx⟩ hs)
    · exact dite_eq_right hx
  · intro x hx
    by_cases hr : G.Reachable u x
    · simpa only [g, dite_eq_left hr] using hgci ⟨x, hr⟩ hx
    · simpa only [g, dite_eq_right hr] using (hI x hx).2.2
  · simpa only [g, dite_eq_left (SimpleGraph.Reachable.refl u),
      dite_eq_left hedge.reachable] using hgce

end StrictFilling

end OAI