import Mathlib
import OAI.Geometry.Cannon.Conformal.Sphere

namespace OAI

section
section
section
section
noncomputable section
namespace CannonQM
open Metric
open scoped NNReal

def Distinct {X : Type*} (x y z w : X) : Prop :=
  x ≠ y ∧ x ≠ z ∧ x ≠ w ∧ y ≠ z ∧ y ≠ w ∧ z ≠ w

lemma Distinct.map {X Y : Type*} {f : X → Y} (hf : Function.Injective f)
    {x y z w : X} (h : Distinct x y z w) : Distinct (f x) (f y) (f z) (f w) := by
  rcases h with ⟨hxy,hxz,hxw,hyz,hyw,hzw⟩
  exact ⟨fun h => hxy (hf h),fun h => hxz (hf h),fun h => hxw (hf h),
    fun h => hyz (hf h),fun h => hyw (hf h),fun h => hzw (hf h)⟩

lemma Distinct.flip {X : Type*} {x y z w : X} (h : Distinct x y z w) : Distinct x w z y := by
  rcases h with ⟨hxy,hxz,hxw,hyz,hyw,hzw⟩
  exact ⟨hxw,hxz,hxy,hzw.symm,hyw.symm,hyz.symm⟩

lemma nndist_pos {X : Type*} [MetricSpace X] {x y : X} : 0 < nndist x y ↔ x ≠ y := by
  rw [pos_iff_ne_zero,ne_eq,nndist_eq_zero]

def crossRatio {X : Type*} [MetricSpace X] (x y z w : X) : ℝ≥0 :=
  nndist x y * nndist z w / (nndist x w * nndist y z)

lemma crossRatio_pos {X : Type*} [MetricSpace X] {x y z w : X}
    (h : Distinct x y z w) : 0 < crossRatio x y z w := by
  exact div_pos (mul_pos (nndist_pos.mpr h.1) (nndist_pos.mpr h.2.2.2.2.2))
    (mul_pos (nndist_pos.mpr h.2.2.1) (nndist_pos.mpr h.2.2.2.1))

lemma crossRatio_flip {X : Type*} [MetricSpace X] (x y z w : X) :
    crossRatio x w z y = (crossRatio x y z w)⁻¹ := by
  simp only [crossRatio,inv_div,nndist_comm z y,nndist_comm w z]

abbrev Distortion := ℝ≥0 ≃o ℝ≥0

lemma distortion_zero (η : Distortion) : η 0 = 0 := η.map_bot

def reciprocal (η : Distortion) : Distortion where
  toFun t := (η t⁻¹)⁻¹
  invFun t := (η.symm t⁻¹)⁻¹
  left_inv t := by simp
  right_inv t := by simp
  map_rel_iff' := by
    intro x y
    change (η x⁻¹)⁻¹ ≤ (η y⁻¹)⁻¹ ↔ x ≤ y
    by_cases hx : x=0
    · subst x
      simp only [inv_zero,distortion_zero,zero_le]
    by_cases hy : y=0
    · subst y
      have hη : η x⁻¹ ≠ 0 := by
        rw [← distortion_zero η]
        exact fun hh => hx (inv_eq_zero.mp (η.injective hh))
      simp only [inv_zero,distortion_zero,le_zero_iff,inv_eq_zero]
      exact ⟨fun hh => (hη hh).elim,fun hh => (hx hh).elim⟩
    have hxpos : 0 < x := pos_iff_ne_zero.mpr hx
    have hypos : 0 < y := pos_iff_ne_zero.mpr hy
    have hηx : 0 < η x⁻¹ := by simpa only [distortion_zero] using η.strictMono (inv_pos.mpr hxpos)
    have hηy : 0 < η y⁻¹ := by simpa only [distortion_zero] using η.strictMono (inv_pos.mpr hypos)
    rw [inv_le_inv₀ hηx hηy,η.le_iff_le,inv_le_inv₀ hypos hxpos]

variable {X Y Z : Type*} [MetricSpace X] [MetricSpace Y] [MetricSpace Z]

def Controlled (f : X → Y) (η : Distortion) : Prop :=
  ∀ x y z w, Distinct x y z w →
    crossRatio (f x) (f y) (f z) (f w) ≤ η (crossRatio x y z w)

def QuasiMobius (f : X → Y) : Prop := ∃ η : Distortion, Controlled f η

lemma Controlled.comp {f : X → Y} {g : Y → Z} {η θ : Distortion}
    (hg : Controlled g θ) (hf : Controlled f η) (hinj : Function.Injective f) :
    Controlled (g ∘ f) (η.trans θ) := by
  intro x y z w hh
  exact (hg _ _ _ _ (hh.map hinj)).trans (θ.monotone (hf _ _ _ _ hh))

lemma Controlled.inverse (f : X ≃ₜ Y) {η : Distortion} (hf : Controlled f η) :
    Controlled f.symm (reciprocal η.symm) := by
  intro x y z w hh
  have hh' := hh.map f.symm.injective
  have H := hf _ _ _ _ hh'.flip
  simp only [f.apply_symm_apply] at H
  rw [crossRatio_flip x y z w, crossRatio_flip (f.symm x) (f.symm y) (f.symm z) (f.symm w)] at H
  have H' := η.symm.monotone H
  simp only [OrderIso.symm_apply_apply] at H'
  change crossRatio (f.symm x) (f.symm y) (f.symm z) (f.symm w) ≤ (η.symm (crossRatio x y z w)⁻¹)⁻¹
  have hpos : 0 < η.symm (crossRatio x y z w)⁻¹ := by
    simpa only [distortion_zero] using η.symm.strictMono (inv_pos.mpr (crossRatio_pos hh))
  have hi := (inv_le_inv₀ (inv_pos.mpr (crossRatio_pos hh')) hpos).mpr H'
  simpa only [inv_inv] using hi

lemma QuasiMobius.inverse (f : X ≃ₜ Y) (hf : QuasiMobius f) : QuasiMobius f.symm := by
  obtain ⟨η,hη⟩ := hf
  exact ⟨reciprocal η.symm,hη.inverse f⟩

lemma QuasiMobius.comp {f : X → Y} {g : Y → Z} (hg : QuasiMobius g)
    (hf : QuasiMobius f) (hinj : Function.Injective f) : QuasiMobius (g ∘ f) := by
  obtain ⟨η,hη⟩ := hf
  obtain ⟨θ,hθ⟩ := hg
  exact ⟨η.trans θ,hθ.comp hη hinj⟩

lemma controlled_conjugates {ι : Type*} (ψ : X ≃ₜ Y) {η θ : Distortion}
    (hψ : Controlled ψ η) (f : ι → X ≃ₜ X) (hf : ∀ i, Controlled (f i) θ) :
    ∀ i, Controlled (ψ ∘ (f i) ∘ ψ.symm)
      (((reciprocal η.symm).trans θ).trans η) := by
  intro i
  exact hψ.comp ((hf i).comp (hψ.inverse ψ) ψ.symm.injective)
    ((f i).injective.comp ψ.symm.injective)

end CannonQM

namespace CannonQM
open scoped NNReal

variable {X Y : Type*} [MetricSpace X] [MetricSpace Y]

lemma controlled_of_product_bound (f : X → Y) (hf : Function.Injective f)
    (C : ℝ≥0) (hC : 0 < C)
    (h : ∀ x y z w, Distinct x y z w →
      nndist (f x) (f y)*nndist (f z) (f w)*nndist x w*nndist y z ≤
      C*(nndist (f x) (f w)*nndist (f y) (f z)*nndist x y*nndist z w)) :
    Controlled f (OrderIso.mulLeft₀ C hC) := by
  intro x y z w hh
  have hhf := hh.map hf
  change crossRatio (f x) (f y) (f z) (f w) ≤ C*crossRatio x y z w
  unfold crossRatio
  rw [← mul_div_assoc,div_le_div_iff₀
    (mul_pos (nndist_pos.mpr hhf.2.2.1) (nndist_pos.mpr hhf.2.2.2.1))
    (mul_pos (nndist_pos.mpr hh.2.2.1) (nndist_pos.mpr hh.2.2.2.1))]
  simpa only [mul_assoc,mul_left_comm,mul_comm] using h x y z w hh

end CannonQM

end
end
namespace CannonMetricQC
open Metric CannonQM

lemma cycle_sorted_bounds {a b c d T : ℝ} (ha : 0 < a) (hb : 0 < b)
    (hc : 0 < c) (hd : 0 < d) (hT : 1  ≤  T)
    (hab : a  ≤  b) (hcd : c  ≤  d) (hp : a*b  ≤  T*(c*d))
    (hbt : b  ≤  a+c+d) (hdt : d  ≤  a+b+c) :
    a  ≤  (2*T+3)*c ∧ b  ≤  (2*T+3)*d := by
  have hT0 : 0 < T := by linarith
  constructor
  · by_contra hn
    have hn' : (2*T+3)*c < a := lt_of_not_ge hn
    have hhdt : d  ≤  2*b+c := by linarith
    have hm := mul_le_mul_of_nonneg_left hhdt (mul_nonneg hT0.le hc.le)
    have hTb : T*c < b := by nlinarith
    have hm1 := mul_pos (sub_pos.mpr hn') hb
    have hm2 := mul_pos (sub_pos.mpr hTb) hc
    nlinarith
  · by_contra hn
    have hn' : (2*T+3)*d < b := lt_of_not_ge hn
    have hha : T*d < a := by nlinarith
    have hhb : d < b := by nlinarith
    have hm1 := mul_pos (sub_pos.mpr hha) hb
    have hm2 := mul_nonneg (mul_nonneg hT0.le hd.le) (sub_nonneg.mpr hhb.le)
    have hm3 := mul_le_mul_of_nonneg_left hcd (mul_nonneg hT0.le hd.le)
    nlinarith

lemma crossRatio_pair_bounds {X : Type*} [MetricSpace X] (x y z w : X)
    (hh : Distinct x y z w) {T : ℝ} (hT : 1  ≤  T)
    (hp : dist x y*dist z w  ≤  T*(dist x w*dist y z)) :
    (dist x y  ≤  (2*T+3)*dist x w ∧ dist z w  ≤  (2*T+3)*dist y z) ∨
    (dist x y  ≤  (2*T+3)*dist y z ∧ dist z w  ≤  (2*T+3)*dist x w) := by
  let a := dist x y
  let b := dist z w
  let c := dist x w
  let d := dist y z
  have ha : 0 < a := dist_pos.mpr hh.1
  have hb : 0 < b := dist_pos.mpr hh.2.2.2.2.2
  have hc : 0 < c := dist_pos.mpr hh.2.2.1
  have hd : 0 < d := dist_pos.mpr hh.2.2.2.1
  have ht1 : a  ≤  b+c+d := by
    have h1 := dist_triangle x w y
    have h2 := dist_triangle w z y
    dsimp [a,b,c,d]
    rw [dist_comm w z,dist_comm z y] at h2
    linarith
  have ht2 : b  ≤  a+c+d := by
    have h1 := dist_triangle z y w
    have h2 := dist_triangle y x w
    dsimp [a,b,c,d]
    rw [dist_comm z y] at h1
    rw [dist_comm y x] at h2
    linarith
  have ht3 : c  ≤  a+b+d := by
    have h1 := dist_triangle x y w
    have h2 := dist_triangle y z w
    dsimp [a,b,c,d]
    linarith
  have ht4 : d  ≤  a+b+c := by
    have h1 := dist_triangle y x z
    have h2 := dist_triangle x w z
    dsimp [a,b,c,d]
    rw [dist_comm y x] at h1
    rw [dist_comm w z] at h2
    linarith
  change (a  ≤  (2*T+3)*c ∧ b  ≤  (2*T+3)*d) ∨
    (a  ≤  (2*T+3)*d ∧ b  ≤  (2*T+3)*c)
  rcases le_total a b with hab | hba <;> rcases le_total c d with hcd | hdc
  · exact Or.inl (cycle_sorted_bounds ha hb hc hd hT hab hcd hp ht2 ht4)
  · exact Or.inr (cycle_sorted_bounds ha hb hd hc hT hab hdc (by nlinarith [hp])
      (by linarith) ht3)
  · have hh := cycle_sorted_bounds hb ha hc hd hT hba hcd (by nlinarith [hp])
      (by linarith) (by linarith)
    exact Or.inr ⟨hh.2,hh.1⟩
  · have hh := cycle_sorted_bounds hb ha hd hc hT hba hdc (by nlinarith [hp])
      (by linarith) (by linarith)
    exact Or.inl ⟨hh.2,hh.1⟩

end CannonMetricQC

end
end
end

end OAI