import OAI.Geometry.KahlerSplitting.BoxGluing

namespace OAI

noncomputable section
open Set Topology Filter Metric
open Set MeasureTheory Metric Filter Topology
open scoped ENNReal
open scoped ENNReal NNReal
open Complex
open Set Metric Filter Topology Complex
open Set Metric Filter Topology MeasureTheory Complex
open Set Metric Filter Topology Asymptotics
open Set MeasureTheory
open scoped Interval
open Set Filter Topology Metric Complex
open Set Filter Topology Metric
open scoped ContDiff
open Set Metric
open Set Filter Topology
open Set Metric Filter Topology MeasureTheory
open scoped Manifold ENNReal
open scoped Manifold ENNReal NNReal
open Set Metric Filter Topology
open scoped Manifold
open scoped Manifold ContDiff
open Set

namespace UniversalCoverSplitting

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

def alternatingBilinear (B : E →L[ℝ] E →L[ℝ] ℝ) : E [⋀^Fin 2]→L[ℝ] ℝ :=
  (1/2 : ℝ) • ContinuousAlternatingMap.alternatizeUncurryFin
    (((ContinuousAlternatingMap.ofSubsingletonLIE (𝕜 := ℝ) (E := E) (F := ℝ) (0 : Fin 1)).toContinuousLinearEquiv.toContinuousLinearMap).comp B)

theorem alternatingBilinear_apply (B : E →L[ℝ] E →L[ℝ] ℝ) (v : Fin 2 → E) :
    alternatingBilinear B v = (B (v 0) (v 1) - B (v 1) (v 0)) / 2 := by
  simp [alternatingBilinear, ContinuousAlternatingMap.alternatizeUncurryFin_apply,
    Fin.sum_univ_two, Fin.removeNth, Fin.succAbove, div_eq_mul_inv]
  ring

theorem alternatingBilinear_contDiff {D : Type*} [NormedAddCommGroup D] [NormedSpace ℝ D]
    {B : D → E →L[ℝ] E →L[ℝ] ℝ} {U : Set D} {k : WithTop ℕ∞}
    (hB : ContDiffOn ℝ k B U) : ContDiffOn ℝ k (fun x ↦ alternatingBilinear (B x)) U := by
  exact ((ContinuousAlternatingMap.alternatizeUncurryFinCLM ℝ E ℝ).contDiff.comp_contDiffOn
    (contDiffOn_const.clm_comp hB)).const_smul (1/2 : ℝ)

end AlternatingBilinear

variable {n : ℕ} {X : ComplexManifold n}

theorem KahlerMetric.skew_I (g : KahlerMetric X) (x : X.Carrier) (u v : Tangent X x) :
    g.metric x (Complex.I • u) v = - g.metric x (Complex.I • v) u := by
  have h := g.hermitian x u (Complex.I • v)
  simp only [smul_smul, Complex.I_mul_I, neg_one_smul, map_neg] at h
  rw [g.symmetric x u (Complex.I • v)] at h
  linarith

theorem KahlerMetric.skew_fundamentalInChart (g : KahlerMetric X) (c : X.Carrier)
    (z u v : Model n) : fundamentalInChart g.metric c z u v =
      -fundamentalInChart g.metric c z v u := by
  let q : Model n →L[ℂ] Tangent X ((extChartAt (model n) c).symm z) :=
    mfderiv (model n) (model n) (extChartAt (model n) c).symm z
  change g.metric _ (q (Complex.I • u)) (q v) = - g.metric _ (q (Complex.I • v)) (q u)
  rw [q.map_smul, q.map_smul]
  exact g.skew_I _ _ _

def kahlerFormInChart (g : KahlerMetric X) (c : X.Carrier) (z : Model n) :
    (Model n) [⋀^Fin 2]→L[ℝ] ℝ :=
  alternatingBilinear ((continuousMetricInChart g.metric c z).comp
    ((Complex.I • ContinuousLinearMap.id ℂ (Model n)).restrictScalars ℝ))

theorem kahlerFormInChart_apply (g : KahlerMetric X) (c : X.Carrier)
    (z : Model n) (v : Fin 2 → Model n) :
    kahlerFormInChart g c z v = fundamentalInChart g.metric c z (v 0) (v 1) := by
  rw [kahlerFormInChart, alternatingBilinear_apply]
  change (fundamentalInChart g.metric c z (v 0) (v 1) -
    fundamentalInChart g.metric c z (v 1) (v 0)) / 2 = _
  rw [g.skew_fundamentalInChart c z (v 1) (v 0)]
  ring

theorem KahlerMetric.smooth_formInChart (g : KahlerMetric X) (c : X.Carrier) :
    ContDiffOn ℝ ∞ (kahlerFormInChart g c) (extChartAt (model n) c).target := by
  have hB : ContDiffOn ℝ ∞ (continuousMetricInChart g.metric c)
      (extChartAt (model n) c).target := by
    apply contDiffOn_clm_apply.mpr
    intro u
    apply contDiffOn_clm_apply.mpr
    intro v
    exact g.smooth c u v
  exact alternatingBilinear_contDiff (hB.clm_comp contDiffOn_const)

theorem KahlerMetric.closed_formInChart (g : KahlerMetric X) (c : X.Carrier)
    {z : Model n} (hz : z ∈ (extChartAt (model n) c).target) :
    extDeriv (kahlerFormInChart g c) z = 0 := by
  have hd := (g.smooth_formInChart c).differentiableOn (by simp) z hz
  have hda := hd.differentiableAt (isOpen_extChartAt_target c |>.mem_nhds hz)
  ext v
  rw [extDeriv_apply hda]
  norm_num [kahlerFormInChart_apply, Fin.sum_univ_succ, Fin.removeNth, Fin.succAbove]
  have hm : (fun y ↦ fundamentalInChart g.metric c y (v 0) (v 2)) =
      -(fun y ↦ fundamentalInChart g.metric c y (v 2) (v 0)) := by
    funext y
    exact g.skew_fundamentalInChart c y _ _
  rw [hm, fderiv_neg]
  simpa [add_assoc] using g.closed c z hz (v 0) (v 1) (v 2)

end UniversalCoverSplitting

open Set Filter Topology Metric Complex
open scoped Real

namespace UniversalCoverSplitting

section CauchyParameters
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] [CompleteSpace F]

omit [CompleteSpace F] in

theorem continuousOn_cauchy_partial {T S : Set (ℂ × ℂ)} {f : ℂ × ℂ → F}
    (hf : ContinuousOn f T) {r : ℝ} (hr : 0 < r)
    (hmap : ∀ z ∈ S, ∀ θ : ℝ, (circleMap z.1 r θ, z.2) ∈ T) :
    ContinuousOn (fun z : ℂ × ℂ ↦ cderiv r (fun w ↦ f (w, z.2)) z.1) S := by
  rw [continuousOn_iff_continuous_domRestrict]
  let G : S → ℝ → F := fun z θ ↦
    (circleMap 0 r θ * I) • (((circleMap 0 r θ) ^ 2)⁻¹ •
      f (circleMap z.val.1 r θ, z.val.2))
  have hG : Continuous G.uncurry := by
    have hshift : Continuous (fun p : S × ℝ ↦
        (circleMap p.1.val.1 r p.2, p.1.val.2)) := by
      unfold circleMap
      fun_prop
    have hm : MapsTo (fun p : S × ℝ ↦
        (circleMap p.1.val.1 r p.2, p.1.val.2)) univ T :=
      fun p _ ↦ hmap p.1.val p.1.property p.2
    have hcomp := continuousOn_univ.mp (hf.comp hshift.continuousOn hm)
    have hne (p : S × ℝ) : circleMap 0 r p.2 ≠ 0 := by
      exact circleMap_ne_mem_ball (mem_ball_self hr) p.2
    dsimp [G, Function.uncurry]
    apply Continuous.smul
    · fun_prop
    · exact (((continuous_circleMap 0 r).comp continuous_snd).pow 2).inv₀
        (fun p ↦ pow_ne_zero 2 (hne p)) |>.smul hcomp
  have hi := intervalIntegral.continuous_parametric_intervalIntegral_of_continuous'
    (μ := MeasureTheory.volume) hG (a₀ := 0) (b₀ := 2 * Real.pi)
  have hc := hi.const_smul ((2 * Real.pi * I : ℂ)⁻¹)
  change Continuous (fun z : S ↦ cderiv r (fun w ↦ f (w, z.val.2)) z.val.1)
  convert! hc using 1
  ext z
  simp only [cderiv, circleIntegral, deriv_circleMap, G, circleMap, zero_add,
    add_sub_cancel_left, Pi.smul_apply]

theorem continuousAt_partial_deriv {U V : Set ℂ} (hU : IsOpen U) (hV : IsOpen V)
    {f : ℂ × ℂ → F} (hf : ContinuousOn f (U ×ˢ V))
    (hd : ∀ y ∈ V, DifferentiableOn ℂ (fun x ↦ f (x, y)) U)
    {p : ℂ × ℂ} (hp : p ∈ U ×ˢ V) :
    ContinuousAt (fun z : ℂ × ℂ ↦ deriv (fun w ↦ f (w, z.2)) z.1) p := by
  obtain ⟨r, hr, hrU⟩ := Metric.mem_nhds_iff.mp (hU.mem_nhds hp.1)
  let S := Metric.ball p.1 (r / 2) ×ˢ V
  have hS : S ∈ 𝓝 p := prod_mem_nhds (ball_mem_nhds _ (by linarith)) (hV.mem_nhds hp.2)
  have hball (z : ℂ × ℂ) (hz : z ∈ S) : closedBall z.1 (r / 2) ⊆ U := by
    apply Subset.trans (Metric.closedBall_subset_ball' (y := p.1) ?_) hrU
    have : dist z.1 p.1 < r / 2 := hz.1
    linarith
  have hc := continuousOn_cauchy_partial (S := S) hf (by linarith : 0 < r / 2)
    (fun z hz θ ↦ ⟨hball z hz (circleMap_mem_closedBall _ (by linarith) _), hz.2⟩)
  have heq : (fun z : ℂ × ℂ ↦ cderiv (r / 2) (fun w ↦ f (w, z.2)) z.1)
      =ᶠ[𝓝 p] (fun z : ℂ × ℂ ↦ deriv (fun w ↦ f (w, z.2)) z.1) := by
    filter_upwards [hS] with z hz
    exact cderiv_eq_deriv hU (hd z.2 hz.2) (by linarith) (hball z hz)
  exact (hc.continuousAt hS).congr heq

def totalPartialDeriv (f : ℂ × ℂ → F) (p : ℂ × ℂ) : (ℂ × ℂ) →L[ℂ] F :=
  (ContinuousLinearMap.smulRightL ℂ (ℂ × ℂ) F (ContinuousLinearMap.fst ℂ ℂ ℂ))
    (deriv (fun w ↦ f (w, p.2)) p.1) +
  (ContinuousLinearMap.smulRightL ℂ (ℂ × ℂ) F (ContinuousLinearMap.snd ℂ ℂ ℂ))
    (deriv (fun w ↦ f (p.1, w)) p.2)

theorem hasStrictFDerivAt_of_continuousOn_of_separately
    {U V : Set ℂ} (hU : IsOpen U) (hV : IsOpen V)
    {f : ℂ × ℂ → F} (hf : ContinuousOn f (U ×ˢ V))
    (h₁ : ∀ y ∈ V, DifferentiableOn ℂ (fun x ↦ f (x, y)) U)
    (h₂ : ∀ x ∈ U, DifferentiableOn ℂ (fun y ↦ f (x, y)) V)
    {p : ℂ × ℂ} (hp : p ∈ U ×ˢ V) :
    HasStrictFDerivAt f (totalPartialDeriv f p) p := by
  let L : F →L[ℂ] (ℂ →L[ℂ] F) := ContinuousLinearMap.smulRightL ℂ ℂ F 1
  let D₁ : ℂ → ℂ → ℂ →L[ℂ] F := fun x y ↦ L (deriv (fun w ↦ f (w, y)) x)
  let D₂ : ℂ → ℂ → ℂ →L[ℂ] F := fun x y ↦ L (deriv (fun w ↦ f (x, w)) y)
  have hd₁ : ∀ᶠ z in 𝓝 p, HasFDerivAt (fun x ↦ f (x, z.2)) (D₁ z.1 z.2) z.1 := by
    filter_upwards [(hU.prod hV).mem_nhds hp] with z hz
    exact ((h₁ z.2 hz.2).differentiableAt (hU.mem_nhds hz.1)).hasDerivAt.hasFDerivAt
  have hd₂ : ∀ᶠ z in 𝓝 p, HasFDerivAt (fun y ↦ f (z.1, y)) (D₂ z.1 z.2) z.2 := by
    filter_upwards [(hU.prod hV).mem_nhds hp] with z hz
    exact ((h₂ z.1 hz.1).differentiableAt (hV.mem_nhds hz.2)).hasDerivAt.hasFDerivAt
  have hc₁ : ContinuousAt D₁.uncurry p :=
    L.continuous.continuousAt.comp (continuousAt_partial_deriv hU hV hf h₁ hp)
  have hfs : ContinuousOn (fun z : ℂ × ℂ ↦ f z.swap) (V ×ˢ U) :=
    hf.comp continuous_swap.continuousOn (fun z hz ↦ ⟨hz.2, hz.1⟩)
  have hds : ∀ y ∈ U, DifferentiableOn ℂ (fun x ↦ f (y, x)) V := h₂
  have hcs := continuousAt_partial_deriv hV hU hfs hds (p := p.swap) ⟨hp.2, hp.1⟩
  have hc₂ : ContinuousAt D₂.uncurry p := by
    exact L.continuous.continuousAt.comp (hcs.comp continuous_swap.continuousAt)
  have hs := (hasStrictFDerivAt_uncurry_coprod (𝕜 := ℂ) (f := fun x y ↦ f (x, y))
    (f₁ := D₁) (f₂ := D₂) (u := p) hd₁ hd₂ hc₁ hc₂)
  convert! hs using 1

theorem differentiableOn_of_continuousOn_of_separately
    {U V : Set ℂ} (hU : IsOpen U) (hV : IsOpen V)
    {f : ℂ × ℂ → F} (hf : ContinuousOn f (U ×ˢ V))
    (h₁ : ∀ y ∈ V, DifferentiableOn ℂ (fun x ↦ f (x, y)) U)
    (h₂ : ∀ x ∈ U, DifferentiableOn ℂ (fun y ↦ f (x, y)) V) :
    DifferentiableOn ℂ f (U ×ˢ V) := by
  intro p hp
  exact (hasStrictFDerivAt_of_continuousOn_of_separately hU hV hf h₁ h₂ hp
    ).hasFDerivAt.differentiableAt.differentiableWithinAt

theorem continuousAt_totalPartialDeriv
    {U V : Set ℂ} (hU : IsOpen U) (hV : IsOpen V)
    {f : ℂ × ℂ → F} (hf : ContinuousOn f (U ×ˢ V))
    (h₁ : ∀ y ∈ V, DifferentiableOn ℂ (fun x ↦ f (x, y)) U)
    (h₂ : ∀ x ∈ U, DifferentiableOn ℂ (fun y ↦ f (x, y)) V)
    {p : ℂ × ℂ} (hp : p ∈ U ×ˢ V) :
    ContinuousAt (totalPartialDeriv f) p := by
  have hfs : ContinuousOn (fun z : ℂ × ℂ ↦ f z.swap) (V ×ˢ U) :=
    hf.comp continuous_swap.continuousOn (fun z hz ↦ ⟨hz.2, hz.1⟩)
  have hcs := continuousAt_partial_deriv hV hU hfs h₂ (p := p.swap) ⟨hp.2, hp.1⟩
  exact ((ContinuousLinearMap.smulRightL ℂ (ℂ × ℂ) F
    (ContinuousLinearMap.fst ℂ ℂ ℂ)).continuous.continuousAt.comp
      (continuousAt_partial_deriv hU hV hf h₁ hp)).add
    ((ContinuousLinearMap.smulRightL ℂ (ℂ × ℂ) F
      (ContinuousLinearMap.snd ℂ ℂ ℂ)).continuous.continuousAt.comp
        (hcs.comp continuous_swap.continuousAt))

theorem continuousAt_fderiv_twoDim_prod
    {U V : Set ℂ} (hU : IsOpen U) (hV : IsOpen V)
    {f : ℂ × ℂ → F} (hf : DifferentiableOn ℂ f (U ×ˢ V))
    {p : ℂ × ℂ} (hp : p ∈ U ×ˢ V) : ContinuousAt (fderiv ℂ f) p := by
  have h₁ : ∀ y ∈ V, DifferentiableOn ℂ (fun x ↦ f (x, y)) U := by
    intro y hy
    exact hf.comp (differentiableOn_id.prodMk (differentiableOn_const y))
      (fun x hx ↦ ⟨hx, hy⟩)
  have h₂ : ∀ x ∈ U, DifferentiableOn ℂ (fun y ↦ f (x, y)) V := by
    intro x hx
    exact hf.comp ((differentiableOn_const x).prodMk differentiableOn_id)
      (fun y hy ↦ ⟨hx, hy⟩)
  have he : totalPartialDeriv f =ᶠ[𝓝 p] fderiv ℂ f := by
    filter_upwards [(hU.prod hV).mem_nhds hp] with z hz
    exact (hasStrictFDerivAt_of_continuousOn_of_separately hU hV
      hf.continuousOn h₁ h₂ hz).hasFDerivAt.fderiv.symm
  exact (continuousAt_totalPartialDeriv hU hV hf.continuousOn h₁ h₂ hp).congr he

theorem continuousOn_fderiv_twoDim {Ω : Set (ℂ × ℂ)} (hΩ : IsOpen Ω)
    {f : ℂ × ℂ → F} (hf : DifferentiableOn ℂ f Ω) :
    ContinuousOn (fderiv ℂ f) Ω := by
  intro p hp
  obtain ⟨r, hr, hrΩ⟩ := Metric.mem_nhds_iff.mp (hΩ.mem_nhds hp)
  have hsub : Metric.ball p.1 r ×ˢ Metric.ball p.2 r ⊆ Ω := by
    rw [ball_prod_same]
    exact hrΩ
  exact (continuousAt_fderiv_twoDim_prod isOpen_ball isOpen_ball (hf.mono hsub)
    ⟨mem_ball_self hr, mem_ball_self hr⟩).continuousWithinAt

end CauchyParameters
end UniversalCoverSplitting

end

end OAI