import OAI.Geometry.CylinderCovering.Simplex.DiameterDefinitions

namespace OAI

open Set Metric

namespace CylinderCovering.SimplexDiameter

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma chordLength_zero {S : Set E} (hS : S.Nonempty) (u : E) :
    ChordLength S u 0 := by
  obtain ⟨x, hx⟩ := hS
  exact ⟨le_rfl, x, hx, by simpa using hx⟩

lemma chordLength_le_diam {S : Set E} {u : E} {r : ℝ}
    (hS : Bornology.IsBounded S) (hu : ‖u‖ = 1) (hr : ChordLength S u r) :
    r ≤ diam S := by
  obtain ⟨hr, x, hx, hy⟩ := hr
  have hd := dist_le_diam_of_mem hS hy hx
  simpa [dist_eq_norm, norm_smul, Real.norm_eq_abs, abs_of_nonneg hr, hu] using hd

lemma chordLength_segment {S : Set E} {u : E} {r : ℝ}
    (hS : Convex ℝ S) (hr : ChordLength S u r) :
    ∃ x ∈ S, segment ℝ x (x + r • u) ⊆ S := by
  obtain ⟨_, x, hx, hy⟩ := hr
  exact ⟨x, hx, hS.segment_subset hx hy⟩

lemma chordLengths_compact {S : Set E} (hS : IsCompact S) {u : E}
    (hu : ‖u‖ = 1) : IsCompact {r : ℝ | ChordLength S u r} := by
  let K : Set (E × ℝ) := (S ×ˢ Icc 0 (diam S)) ∩
    {p | p.1 + p.2 • u ∈ S}
  have hK : IsCompact K := by
    apply (hS.prod isCompact_Icc).inter_right
    exact hS.isClosed.preimage (continuous_fst.add (continuous_snd.smul continuous_const))
  have heq : {r : ℝ | ChordLength S u r} = Prod.snd '' K := by
    ext r
    constructor
    · intro hr
      obtain ⟨hr0, x, hx, hxr⟩ := hr
      exact ⟨(x, r), ⟨⟨hx, hr0, chordLength_le_diam hS.isBounded hu
        ⟨hr0, x, hx, hxr⟩⟩, hxr⟩, rfl⟩
    · rintro ⟨⟨x, s⟩, ⟨⟨hx, hs0, _⟩, hxs⟩, rfl⟩
      exact ⟨hs0, x, hx, hxs⟩
  rw [heq]
  exact hK.image continuous_snd

lemma maxChord_attained {S : Set E} (hS : IsCompact S) (hne : S.Nonempty)
    {u : E} (hu : ‖u‖ = 1) : ChordLength S u (maxChord S u) := by
  exact (chordLengths_compact hS hu).sSup_mem ⟨0, chordLength_zero hne u⟩

lemma maxChord_nonneg {S : Set E} (hS : IsCompact S) (hne : S.Nonempty)
    {u : E} (hu : ‖u‖ = 1) : 0 ≤ maxChord S u :=
  (maxChord_attained hS hne hu).1

lemma maxChord_le_diam {S : Set E} (hS : IsCompact S) (hne : S.Nonempty)
    {u : E} (hu : ‖u‖ = 1) : maxChord S u ≤ diam S :=
  chordLength_le_diam hS.isBounded hu (maxChord_attained hS hne hu)

lemma chordLength_le_maxChord {S : Set E} (hS : IsCompact S)
    {u : E} (hu : ‖u‖ = 1) {r : ℝ} (hr : ChordLength S u r) :
    r ≤ maxChord S u := by
  exact le_csSup (chordLengths_compact hS hu).bddAbove hr

omit [NormedSpace ℝ E] in
lemma compact_diameter_attained {S : Set E} (hS : IsCompact S) (hne : S.Nonempty) :
    ∃ x ∈ S, ∃ y ∈ S, dist x y = diam S := by
  obtain ⟨⟨x, y⟩, hxy, hmax⟩ := (hS.prod hS).exists_isMaxOn
    (hne.prod hne) (continuous_fst.dist continuous_snd).continuousOn
  refine ⟨x, hxy.1, y, hxy.2, le_antisymm
    (dist_le_diam_of_mem hS.isBounded hxy.1 hxy.2) ?_⟩
  apply diam_le_of_forall_dist_le (dist_nonneg (x := x) (y := y))
  intro a ha b hb
  exact hmax (show (a, b) ∈ S ×ˢ S from ⟨ha, hb⟩)

lemma exists_maxChord_eq_diam {S : Set E} (hS : IsCompact S) (hne : S.Nonempty)
    (hd : 0 < diam S) : ∃ u : E, ‖u‖ = 1 ∧ maxChord S u = diam S := by
  obtain ⟨x, hx, y, hy, hxy⟩ := compact_diameter_attained hS hne
  have hn : ‖y - x‖ = diam S := by
    simpa [dist_eq_norm, norm_sub_rev] using hxy
  have hne0 : y - x ≠ 0 := norm_pos_iff.mp (hn ▸ hd)
  let u := NormedSpace.normalize (y - x)
  have hu : ‖u‖ = 1 := NormedSpace.norm_normalize hne0
  refine ⟨u, hu, le_antisymm (maxChord_le_diam hS hne hu) ?_⟩
  apply chordLength_le_maxChord hS hu
  refine ⟨hd.le, x, hx, ?_⟩
  rw [← hn, show u = NormedSpace.normalize (y - x) from rfl,
    NormedSpace.norm_smul_normalize]
  simpa using hy

lemma convexHull_pair_distance {ι : Type*} (v : ι → E) {x y : E}
    (hx : x ∈ convexHull ℝ (range v)) (hy : y ∈ convexHull ℝ (range v)) :
    ∃ i j, dist x y ≤ dist (v i) (v j) := by
  obtain ⟨a, ⟨i, rfl⟩, b, ⟨j, rfl⟩, h⟩ :=
    convexHull_exists_dist_ge2 hx hy
  exact ⟨i, j, h⟩

lemma finite_convexHull_diameter_attained {ι : Type*} [Finite ι] [Nonempty ι]
    (v : ι → E) : ∃ i j, diam (convexHull ℝ (range v)) = dist (v i) (v j) := by
  have hc : IsCompact (range v) := (finite_range v).isCompact
  obtain ⟨x, ⟨i, rfl⟩, y, ⟨j, rfl⟩, h⟩ := compact_diameter_attained hc
    (range_nonempty v)
  exact ⟨i, j, by simpa using h.symm⟩

lemma regular_convexHull_diameter {ι : Type*} [Finite ι] [Nontrivial ι]
    (v : ι → E) {edge : ℝ} (he : 0 ≤ edge)
    (hv : ∀ i j, i ≠ j → dist (v i) (v j) = edge) :
    diam (convexHull ℝ (range v)) = edge := by
  rw [convexHull_diam]
  apply le_antisymm
  · apply diam_le_of_forall_dist_le he
    rintro x ⟨i, rfl⟩ y ⟨j, rfl⟩
    by_cases hij : i = j
    · simpa [hij] using he
    · exact (hv i j hij).le
  · obtain ⟨i, j, hij⟩ := exists_pair_ne ι
    rw [← hv i j hij]
    exact dist_le_diam_of_mem (finite_range v).isBounded (mem_range_self i)
      (mem_range_self j)

lemma maxChord_pos_of_interior {S : Set E} (hS : IsCompact S)
    (hint : (interior S).Nonempty) {u : E} (hu : ‖u‖ = 1) :
    0 < maxChord S u := by
  obtain ⟨x, hx⟩ := hint
  obtain ⟨ε, hε, hball⟩ := Metric.mem_nhds_iff.mp (mem_interior_iff_mem_nhds.mp hx)
  have hhalf : ChordLength S u (ε / 2) := by
    refine ⟨by positivity, x, mem_of_mem_of_subset hx interior_subset, hball ?_⟩
    rw [mem_ball, dist_eq_norm]
    simp only [add_sub_cancel_left, norm_smul, Real.norm_eq_abs, hu, mul_one]
    rw [abs_of_pos (by positivity : 0 < ε / 2)]
    linarith
  exact (by positivity : 0 < ε / 2).trans_le (chordLength_le_maxChord hS hu hhalf)

lemma projection_minimum_of_chord_identity {S : Set E} (hS : IsCompact S)
    (hne : S.Nonempty) (hd : 0 < diam S) (A : E → ℝ) (C : ℝ)
    (hA : ∀ u, ‖u‖ = 1 → 0 ≤ A u)
    (hidentity : ∀ u, ‖u‖ = 1 → A u * maxChord S u = C) :
    IsLeast {a : ℝ | ∃ u : E, ‖u‖ = 1 ∧ A u = a} (C / diam S) := by
  obtain ⟨u, hu, hmax⟩ := exists_maxChord_eq_diam hS hne hd
  have hmin : A u = C / diam S := by
    apply (eq_div_iff hd.ne').mpr
    simpa [hmax] using hidentity u hu
  refine ⟨⟨u, hu, hmin⟩, ?_⟩
  rintro a ⟨v, hv, rfl⟩
  apply (div_le_iff₀ hd).mpr
  rw [← hidentity v hv]
  exact mul_le_mul_of_nonneg_left (maxChord_le_diam hS hne hv) (hA v hv)

lemma finite_edge_maxChord {ι : Type*} [Finite ι] [Nonempty ι]
    (v : ι → E) (hd : 0 < diam (convexHull ℝ (range v))) :
    ∃ i j, i ≠ j ∧
      ‖NormedSpace.normalize (v j - v i)‖ = 1 ∧
      maxChord (convexHull ℝ (range v)) (NormedSpace.normalize (v j - v i)) =
        diam (convexHull ℝ (range v)) := by
  let S := convexHull ℝ (range v)
  have hc : IsCompact S := (finite_range v).isCompact_convexHull ℝ
  have hne : S.Nonempty := (range_nonempty v).mono (subset_convexHull ℝ _)
  obtain ⟨i, j, hdij⟩ := finite_convexHull_diameter_attained v
  have hn : ‖v j - v i‖ = diam S := by
    simpa [S, dist_eq_norm, norm_sub_rev] using hdij.symm
  have hn0 : v j - v i ≠ 0 := norm_pos_iff.mp (hn ▸ hd)
  have hij : i ≠ j := by
    intro h
    apply hn0
    simp [h]
  have hu : ‖NormedSpace.normalize (v j - v i)‖ = 1 :=
    NormedSpace.norm_normalize hn0
  refine ⟨i, j, hij, hu, le_antisymm (maxChord_le_diam hc hne hu) ?_⟩
  apply chordLength_le_maxChord hc hu
  refine ⟨hd.le, v i, subset_convexHull ℝ _ (mem_range_self i), ?_⟩
  rw [← hn, NormedSpace.norm_smul_normalize]
  simpa using subset_convexHull ℝ (range v) (mem_range_self j)

lemma finite_edge_projection_minimizer {ι : Type*} [Finite ι] [Nonempty ι]
    (v : ι → E) (hd : 0 < diam (convexHull ℝ (range v)))
    (A : E → ℝ) (C : ℝ) (hA : ∀ u, ‖u‖ = 1 → 0 ≤ A u)
    (hidentity : ∀ u, ‖u‖ = 1 → A u * maxChord (convexHull ℝ (range v)) u = C) :
    ∃ i j, i ≠ j ∧
      ‖NormedSpace.normalize (v j - v i)‖ = 1 ∧
      A (NormedSpace.normalize (v j - v i)) = C / diam (convexHull ℝ (range v)) ∧
      ∀ u, ‖u‖ = 1 → A (NormedSpace.normalize (v j - v i)) ≤ A u := by
  obtain ⟨i, j, hij, hu, hchord⟩ := finite_edge_maxChord v hd
  have hval : A (NormedSpace.normalize (v j - v i)) =
      C / diam (convexHull ℝ (range v)) := by
    apply (eq_div_iff hd.ne').mpr
    simpa [hchord] using hidentity _ hu
  refine ⟨i, j, hij, hu, hval, ?_⟩
  intro u hu'
  rw [hval]
  exact (projection_minimum_of_chord_identity
    ((finite_range v).isCompact_convexHull ℝ)
    ((range_nonempty v).mono (subset_convexHull ℝ _)) hd A C hA hidentity).2
      ⟨u, hu', rfl⟩

lemma affineIndependent_diameter_pos {ι : Type*} [Finite ι] [Nontrivial ι]
    {v : ι → E} (hv : AffineIndependent ℝ v) :
    0 < diam (convexHull ℝ (range v)) := by
  obtain ⟨i, j, hij⟩ := exists_pair_ne ι
  apply Metric.diam_pos
  · exact ⟨v i, subset_convexHull ℝ _ (mem_range_self i),
      v j, subset_convexHull ℝ _ (mem_range_self j), fun h => hij (hv.injective h)⟩
  · exact ((finite_range v).isCompact_convexHull ℝ).isBounded

lemma regular_edge_maxChord {ι : Type*} [Finite ι] [Nontrivial ι]
    (v : ι → E) {edge : ℝ} (he : 0 < edge)
    (hv : ∀ i j, i ≠ j → dist (v i) (v j) = edge)
    {i j : ι} (hij : i ≠ j) :
    ‖NormedSpace.normalize (v j - v i)‖ = 1 ∧
    maxChord (convexHull ℝ (range v)) (NormedSpace.normalize (v j - v i)) = edge := by
  have hn : ‖v j - v i‖ = edge := by
    simpa [dist_eq_norm, norm_sub_rev] using hv i j hij
  have hvne : v j - v i ≠ 0 := norm_pos_iff.mp (hn ▸ he)
  have hu := NormedSpace.norm_normalize hvne
  have hc := (finite_range v).isCompact_convexHull ℝ
  have hne := (range_nonempty v).mono (subset_convexHull ℝ _)
  refine ⟨hu, le_antisymm ?_ ?_⟩
  · exact (maxChord_le_diam hc hne hu).trans_eq (regular_convexHull_diameter v he.le hv)
  · apply chordLength_le_maxChord hc hu
    refine ⟨he.le, v i, subset_convexHull ℝ _ (mem_range_self i), ?_⟩
    rw [← hn, NormedSpace.norm_smul_normalize]
    simpa using subset_convexHull ℝ (range v) (mem_range_self j)

end CylinderCovering.SimplexDiameter

end OAI