import Mathlib
import OAI.Geometry.BallPacking.Surfaces.QuadricCurveManifold

namespace OAI

noncomputable section

namespace PackingSufficiencySupport.DiagonalQuadrics.Explicit
open scoped ContDiff Topology
open Set Function Filter
open scoped Manifold
open Manifold
variable (m : ℕ)

theorem plus_contDiffAt {s : ℂ} (hs : s≠0) : ContDiffAt ℂ ∞ plus s :=
  (contDiffAt_id.add (contDiffAt_id.inv hs)).div_const 2

theorem minus_contDiffAt {s : ℂ} (hs : s≠0) : ContDiffAt ℂ ∞ minus s :=
  (contDiffAt_id.sub (contDiffAt_id.inv hs)).div_const 2

theorem baseSquare_contDiffAt {s : ℂ} (hs : s≠0) : ContDiffAt ℂ ∞ baseSquare s :=
  contDiffAt_const.add ((plus_contDiffAt hs).pow 2)

theorem annulusDomain_isOpen : IsOpen (annulusDomain m) := by
  rw [isOpen_iff_mem_nhds]
  intro s hs
  have hc := (baseSquare_contDiffAt hs.1).continuousAt
  have hz : ∀ᶠ t in 𝓝 s,t≠0 := isOpen_compl_singleton.mem_nhds hs.1
  have hb : ∀ᶠ t in 𝓝 s,0<(baseSquare t).re :=
    (Complex.continuous_re.continuousAt.comp hc).eventually (Ioi_mem_nhds hs.2.1)
  have hj : ∀ j : Fin (m+2),∀ᶠ t in 𝓝 s,1<j.val → 0<(parameters m j-baseSquare t).re := by
    intro j
    by_cases h : 1<j.val
    · exact ((Complex.continuous_re.continuousAt.comp (continuousAt_const.sub hc)).eventually
        (Ioi_mem_nhds (hs.2.2 j h))).mono (fun _ ht _ => ht)
    · exact Filter.Eventually.of_forall (fun _ ht => (h ht).elim)
  filter_upwards [hz,hb,Filter.eventually_all.mpr hj] with t ht0 htb htj
  exact ⟨ht0,htb,htj⟩

theorem unitCircle_subset_domain {s : ℂ} (hs : ‖s‖=1) : s∈annulusDomain m := by
  have hs0 : s≠0 := by intro h; simp [h] at hs
  have hp : plus s=(s.re : ℂ) := by
    rw [plus,Complex.inv_eq_conj hs,Complex.add_conj]
    push_cast
    ring
  have hb : (baseSquare s).re=1+s.re^2 := by simp [baseSquare,hp,← Complex.ofReal_pow]
  have hn : s.re^2≤1 := by
    have he := Complex.normSq_eq_norm_sq s
    rw [hs,one_pow] at he
    simp only [Complex.normSq_apply] at he
    nlinarith [sq_nonneg s.im]
  refine ⟨hs0,?_,?_⟩
  · rw [hb]; positivity
  · intro j hj
    have hj' : (2 : ℝ)≤j.val := by exact_mod_cast hj
    simp only [parameters,Complex.sub_re,Complex.add_re,Complex.natCast_re,Complex.one_re,hb]
    linarith

theorem annulusPoint_contDiffAt {s : ℂ} (hs : s∈annulusDomain m) :
    ContDiffAt ℂ ∞ (annulusPoint m) s := by
  apply ContDiffAt.prodMk
  · exact (sqrt_contDiffAt hs.2.1).comp s (baseSquare_contDiffAt hs.1)
  · apply contDiffAt_pi.mpr
    intro j
    by_cases hj0 : j=0
    · subst j
      simpa using plus_contDiffAt hs.1
    by_cases hj1 : j=1
    · subst j
      have hn : (1 : Fin (m+2))≠0 := by simp
      simpa only [ite_eq_right hn,ite_true] using minus_contDiffAt hs.1
    · have hj : 1<j.val := by
        have h0 : j.val≠0 := fun h => hj0 (Fin.ext h)
        have h1 : j.val≠1 := fun h => hj1 (Fin.ext (by simpa using h))
        omega
      have hb : ContDiffAt ℂ ∞ (fun t : ℂ => parameters m j-baseSquare t) s :=
        contDiffAt_const.sub (baseSquare_contDiffAt hs.1)
      have hr := (sqrt_contDiffAt (hs.2.2 j hj)).comp s hb
      have hh : ContDiffAt ℂ ∞ (fun t => Complex.I*Complex.sqrt (parameters m j-baseSquare t)) s :=
        contDiffAt_const.mul hr
      simpa only [annulusPoint,ite_eq_right hj0,ite_eq_right hj1] using hh

def annulusCoordinate : Affine (m+2) →L[ℂ] ℂ :=
  ((ContinuousLinearMap.proj 0).comp (ContinuousLinearMap.snd ℂ ℂ (Fin (m+2) → ℂ)))+
  ((ContinuousLinearMap.proj 1).comp (ContinuousLinearMap.snd ℂ ℂ (Fin (m+2) → ℂ)))

@[simp] theorem annulusCoordinate_apply (x : Affine (m+2)) : annulusCoordinate m x=x.2 0+x.2 1 := rfl

@[simp] theorem annulusCoordinate_point (s : ℂ) : annulusCoordinate m (annulusPoint m s)=s := by
  simp

theorem annulusCoordinate_mul {x : Affine (m+2)} (hx : x∈locus (parameters m)) :
    annulusCoordinate m x*(x.2 0-x.2 1)=1 := by
  have h0 := mem_locus.mp hx 0
  have h1 := mem_locus.mp hx 1
  simp only [parameters_zero,parameters_one] at h0 h1
  change (x.2 0+x.2 1)*(x.2 0-x.2 1)=1
  linear_combination h0-h1

theorem annulusCoordinate_ne_zero {x : Affine (m+2)} (hx : x∈locus (parameters m)) :
    annulusCoordinate m x≠0 := by
  intro h
  have he := annulusCoordinate_mul m hx
  rw [h,zero_mul] at he
  exact zero_ne_one he

theorem inverse_coordinate {x : Affine (m+2)} (hx : x∈locus (parameters m)) :
    (annulusCoordinate m x)⁻¹=x.2 0-x.2 1 := by
  apply mul_left_cancel₀ (annulusCoordinate_ne_zero m hx)
  rw [mul_inv_cancel₀ (annulusCoordinate_ne_zero m hx),annulusCoordinate_mul m hx]

theorem plus_coordinate {x : Affine (m+2)} (hx : x∈locus (parameters m)) :
    plus (annulusCoordinate m x)=x.2 0 := by
  rw [plus,inverse_coordinate m hx,annulusCoordinate_apply]
  ring

theorem minus_coordinate {x : Affine (m+2)} (hx : x∈locus (parameters m)) :
    minus (annulusCoordinate m x)=x.2 1 := by
  rw [minus,inverse_coordinate m hx,annulusCoordinate_apply]
  ring

theorem baseSquare_coordinate {x : Affine (m+2)} (hx : x∈locus (parameters m)) :
    baseSquare (annulusCoordinate m x)=x.1^2 := by
  have h0 := mem_locus.mp hx 0
  rw [baseSquare,plus_coordinate m hx]
  simp only [parameters_zero] at h0
  linear_combination h0

abbrev Surface := locus (parameters m)

def annulusBranch : Set (Surface m) := {x | annulusCoordinate m x.val∈annulusDomain m ∧
  0<x.val.1.re ∧ ∀ j : Fin (m+2),1<j.val → 0<(x.val.2 j).im}

theorem annulusPoint_positive {s : ℂ} (hs : s∈annulusDomain m) :
    0<(annulusPoint m s).1.re ∧
    ∀ j : Fin (m+2),1<j.val → 0<((annulusPoint m s).2 j).im := by
  refine ⟨sqrt_re_pos hs.2.1,?_⟩
  intro j hj
  have hj0 : j≠0 := by intro h; subst j; simp at hj
  have hj1 : j≠1 := by intro h; subst j; simp at hj
  simpa only [annulusPoint,ite_eq_right hj0,ite_eq_right hj1,Complex.mul_im,
    Complex.I_re,Complex.I_im,zero_mul,one_mul,zero_add] using sqrt_re_pos (hs.2.2 j hj)

theorem annulusPoint_coordinate {x : Surface m} (hx : x∈annulusBranch m) :
    annulusPoint m (annulusCoordinate m x.val)=x.val := by
  apply Prod.ext
  · change Complex.sqrt (baseSquare (annulusCoordinate m x.val))=x.val.1
    rw [baseSquare_coordinate m x.property]
    exact sqrt_of_sq_pos hx.2.1
  · funext j
    by_cases hj0 : j=0
    · subst j
      exact (annulusPoint_zero m _).trans (plus_coordinate m x.property)
    by_cases hj1 : j=1
    · subst j
      exact (annulusPoint_one m _).trans (minus_coordinate m x.property)
    · have hj : 1<j.val := by
        have h0 : j.val≠0 := fun h => hj0 (Fin.ext h)
        have h1 : j.val≠1 := fun h => hj1 (Fin.ext (by simpa using h))
        omega
      have hp : 0<(-Complex.I*x.val.2 j).re := by
        simpa only [Complex.mul_re,Complex.neg_re,Complex.neg_im,Complex.I_re,
          Complex.I_im,neg_zero,zero_mul,neg_mul,one_mul,zero_sub,neg_neg] using hx.2.2 j hj
      have he : parameters m j-baseSquare (annulusCoordinate m x.val)=(-Complex.I*x.val.2 j)^2 := by
        rw [baseSquare_coordinate m x.property,mul_pow,neg_pow,Complex.I_sq]
        have hjx := mem_locus.mp x.property j
        linear_combination hjx
      simp only [annulusPoint,ite_eq_right hj0,ite_eq_right hj1,he,sqrt_of_sq_pos hp]
      rw [← mul_assoc]
      simp

def annulusBasepoint : Surface m := ⟨annulusPoint m 1,annulusPoint_mem m one_ne_zero⟩

def annulusInverse (s : ℂ) : Surface m := by
  classical
  exact if h : s≠0 then ⟨annulusPoint m s,annulusPoint_mem m h⟩ else annulusBasepoint m

@[simp] theorem annulusInverse_val {s : ℂ} (hs : s≠0) :
    (annulusInverse m s).val=annulusPoint m s := by
  simp only [annulusInverse,dite_eq_left hs]

theorem annulusBranch_isOpen : IsOpen (annulusBranch m) := by
  have hc : Continuous (fun x : Surface m => annulusCoordinate m x.val) :=
    (annulusCoordinate m).continuous.comp continuous_subtype_val
  have ht : Continuous (fun x : Surface m => x.val.1.re) :=
    Complex.continuous_re.comp (continuous_fst.comp continuous_subtype_val)
  have hw : ∀ j : Fin (m+2),Continuous (fun x : Surface m => (x.val.2 j).im) :=
    fun j => Complex.continuous_im.comp
      ((continuous_apply j).comp (continuous_snd.comp continuous_subtype_val))
  change IsOpen ((fun x : Surface m => annulusCoordinate m x.val) ⁻¹' annulusDomain m ∩
    ({x : Surface m | 0<x.val.1.re} ∩ {x : Surface m | ∀ j,1<j.val → 0<(x.val.2 j).im}))
  refine ((annulusDomain_isOpen m).preimage hc).inter ((isOpen_lt continuous_const ht).inter ?_)
  simp only [ofPred_forall]
  exact isOpen_iInter_of_finite fun j => isOpen_iInter_of_finite fun _ => isOpen_lt continuous_const (hw j)

def annulusChart : OpenPartialHomeomorph (Surface m) ℂ where
  toFun x := annulusCoordinate m x.val
  invFun := annulusInverse m
  source := annulusBranch m
  target := annulusDomain m
  map_source' _ hx := hx.1
  map_target' s hs := by
    refine ⟨?_,?_⟩
    · rw [annulusInverse_val m hs.1,annulusCoordinate_point]
      exact hs
    · rw [annulusInverse_val m hs.1]
      exact annulusPoint_positive m hs
  left_inv' x hx := by
    apply Subtype.ext
    rw [annulusInverse_val m hx.1.1]
    exact annulusPoint_coordinate m hx
  right_inv' s hs := by
    rw [annulusInverse_val m hs.1,annulusCoordinate_point]
  open_source := annulusBranch_isOpen m
  open_target := annulusDomain_isOpen m
  continuousOn_toFun := ((annulusCoordinate m).continuous.comp continuous_subtype_val).continuousOn
  continuousOn_invFun := by
    rw [continuousOn_iff_continuous_domRestrict]
    apply continuous_induced_rng.mpr
    have hc : ContinuousOn (annulusPoint m) (annulusDomain m) :=
      fun s hs => (annulusPoint_contDiffAt m hs).continuousAt.continuousWithinAt
    rw [continuousOn_iff_continuous_domRestrict] at hc
    exact hc.congr fun s => (annulusInverse_val m s.property.1).symm

@[simp] theorem annulusChart_apply (x : Surface m) : annulusChart m x=annulusCoordinate m x.val := rfl
@[simp] theorem annulusChart_source : (annulusChart m).source=annulusBranch m := rfl
@[simp] theorem annulusChart_target : (annulusChart m).target=annulusDomain m := rfl

end PackingSufficiencySupport.DiagonalQuadrics.Explicit

namespace PackingSufficiencySupport.CubicModel
open scoped ContDiff Manifold Topology
open Set Function Manifold
open DiagonalQuadrics DiagonalQuadrics.Explicit

abbrev PlaneBase := ℂ × ℂ
abbrev BaseCurve := Surface 0

 def polynomial (z : PlaneBase) : ℂ := z.1*z.2*(z.1-z.2)+z.2-2*z.1
 def homogeneous (u v w : ℂ) : ℂ := v*w*(v-w)+u^2*(w-2*v)
 def projection (z : Affine 2) : PlaneBase := (z.2 0-z.1,z.2 1-z.1)
 def inclusion (x : BaseCurve) : PlaneBase := projection x.val

 theorem polynomial_contDiff : ContDiff ℂ ∞ polynomial := by
  unfold polynomial
  fun_prop

 theorem projection_contDiff : ContDiff ℂ ∞ projection := by
  exact (((contDiff_apply ℂ ℂ 0).comp contDiff_snd).sub contDiff_fst).prodMk
    (((contDiff_apply ℂ ℂ 1).comp contDiff_snd).sub contDiff_fst)

 theorem source_equation_zero (x : BaseCurve) : (x.val.2 0)^2=x.val.1^2-1 := by
  simpa only [parameters_zero] using (mem_locus.mp x.property) 0
 theorem source_equation_one (x : BaseCurve) : (x.val.2 1)^2=x.val.1^2-2 := by
  simpa only [parameters_one] using (mem_locus.mp x.property) 1

 theorem inclusion_polynomial (x : BaseCurve) : polynomial (inclusion x)=0 := by
  have h0 := source_equation_zero x
  have h1 := source_equation_one x
  dsimp [polynomial,inclusion,projection]
  linear_combination (x.val.2 1-x.val.1)*h0-(x.val.2 0-x.val.1)*h1

 theorem inclusion_fst_ne_zero (x : BaseCurve) : (inclusion x).1≠0 := by
  intro h
  have he : x.val.2 0=x.val.1 := sub_eq_zero.mp h
  have h0 := source_equation_zero x
  rw [he] at h0
  have hh : (1:ℂ)=0 := by linear_combination h0
  exact one_ne_zero hh

 theorem inclusion_snd_ne_zero (x : BaseCurve) : (inclusion x).2≠0 := by
  intro h
  have he : x.val.2 1=x.val.1 := sub_eq_zero.mp h
  have h1 := source_equation_one x
  rw [he] at h1
  have hh : (1:ℂ)=0 := by linear_combination h1 / 2
  exact one_ne_zero hh

 def recovery (z : PlaneBase) : Affine 2 :=
  let t := -(z.1^2+1)/(2*z.1)
  (t,![t+z.1,t+z.2])

 theorem recovery_inclusion (x : BaseCurve) : recovery (inclusion x)=x.val := by
  have hv := inclusion_fst_ne_zero x
  have h0 := source_equation_zero x
  have ht : -((inclusion x).1^2+1)/(2*(inclusion x).1)=x.val.1 := by
    apply (div_eq_iff (mul_ne_zero (by norm_num) hv)).mpr
    dsimp [inclusion,projection]
    linear_combination -h0
  apply Prod.ext
  · exact ht
  · funext j
    change ![-((inclusion x).1^2+1)/(2*(inclusion x).1)+(inclusion x).1,
      -((inclusion x).1^2+1)/(2*(inclusion x).1)+(inclusion x).2] j=x.val.2 j
    rw [ht]
    fin_cases j <;> simp [inclusion,projection]

 theorem inclusion_contMDiff : ContMDiff 𝓘(ℂ,ℂ) 𝓘(ℂ,PlaneBase) ∞ inclusion :=
  projection_contDiff.contMDiff.comp (curve_inclusion_contMDiff (parameters 0))

 theorem recovery_contDiffOn : ContDiffOn ℂ ∞ recovery {z | z.1≠0} := by
  intro z hz
  have ht : ContDiffAt ℂ ∞ (fun z : PlaneBase => -(z.1^2+1)/(2*z.1)) z :=
    ((contDiffAt_fst.pow 2).add contDiffAt_const).neg.div
      (contDiffAt_const.mul contDiffAt_fst) (mul_ne_zero (by norm_num) hz)
  apply ContDiffAt.contDiffWithinAt
  apply ht.prodMk
  apply contDiffAt_pi.mpr
  intro j
  fin_cases j
  · exact ht.add contDiffAt_fst
  · exact ht.add contDiffAt_snd

 theorem inclusion_isEmbedding : Topology.IsEmbedding inclusion := by
  let f : BaseCurve → {z : PlaneBase // z.1≠0} := fun x => ⟨inclusion x,inclusion_fst_ne_zero x⟩
  have hf : Continuous f := inclusion_contMDiff.continuous.subtype_mk _
  have hR : Continuous (fun z : {z : PlaneBase // z.1≠0} => recovery z.val) :=
    recovery_contDiffOn.continuousOn.domRestrict
  have hcomp : (fun z : {z : PlaneBase // z.1≠0} => recovery z.val) ∘ f=
      (Subtype.val : BaseCurve → Affine 2) := funext recovery_inclusion
  have he := Topology.IsEmbedding.of_comp hf hR (hcomp ▸ Topology.IsEmbedding.subtypeVal)
  exact Topology.IsEmbedding.subtypeVal.comp he

 def gradV (z : PlaneBase) : ℂ := 2*z.1*z.2-z.2^2-2
 def gradW (z : PlaneBase) : ℂ := z.1^2-2*z.1*z.2+1
 def jacobian (z : PlaneBase) : PlaneBase →L[ℂ] ℂ :=
  gradV z • ContinuousLinearMap.fst ℂ ℂ ℂ+gradW z • ContinuousLinearMap.snd ℂ ℂ ℂ

 theorem polynomial_hasFDerivAt (z : PlaneBase) : HasFDerivAt polynomial (jacobian z) z := by
  have hv := hasFDerivAt_fst (𝕜 := ℂ) (p := z)
  have hw := hasFDerivAt_snd (𝕜 := ℂ) (p := z)
  have h := (((hv.mul hw).mul (hv.sub hw)).add hw).sub (hv.const_mul 2)
  apply h.congr_fderiv
  apply ContinuousLinearMap.ext
  intro v
  symm
  change (2*z.1*z.2-z.2^2-2)*v.1+(z.1^2-2*z.1*z.2+1)*v.2=
    z.1*z.2*(v.1-v.2)+(z.1-z.2)*(z.1*v.2+z.2*v.1)+v.2-2*v.1
  ring

 theorem gradient_nonzero {z : PlaneBase} (hz : polynomial z=0) : gradV z≠0 ∨ gradW z≠0 := by
  by_contra h
  push Not at h
  obtain ⟨hv,hw⟩ := h
  have he : z.2=2*z.1 := by
    dsimp [polynomial] at hz
    dsimp [gradV] at hv
    dsimp [gradW] at hw
    linear_combination (3*hz-z.1*hv-z.2*hw)/2
  have hv' : gradV z= -2 := by rw [gradV,he]; ring
  rw [hv'] at hv
  norm_num at hv

 theorem jacobian_surjective {z : PlaneBase} (hz : polynomial z=0) : Surjective (jacobian z) := by
  rcases gradient_nonzero hz with hv | hw
  · intro w
    refine ⟨(w/gradV z,0),?_⟩
    simp [jacobian,mul_div_cancel₀ _ hv]
  · intro w
    refine ⟨(0,w/gradW z),?_⟩
    simp [jacobian,mul_div_cancel₀ _ hw]

 theorem marked_points : homogeneous 0 1 0=0 ∧ homogeneous 0 0 1=0 := by
  norm_num [homogeneous]

 theorem homogeneous_affine (v w : ℂ) : homogeneous 1 v w=polynomial (v,w) := by
  simp only [homogeneous,polynomial,one_pow,one_mul]
  ring

end PackingSufficiencySupport.CubicModel
end

end OAI