import OAI.Geometry.IsometricImmersion.Caps.EllipticCutoff

namespace OAI

noncomputable section
open Set Filter
open scoped ContDiff Topology

namespace SmoothLocal.Weighted
open SmoothLocal.Geometry

theorem coordLinear_norm_le (L : Coord →L[ℝ] ℝ) :
    ‖L‖ ≤ |L (Pi.single 0 1)| + |L (Pi.single 1 1)| := by
  apply L.opNorm_le_bound (add_nonneg (abs_nonneg _) (abs_nonneg _))
  intro v
  have he : v = v 0 • Pi.single 0 (1 : ℝ) + v 1 • Pi.single 1 (1 : ℝ) := by
    ext i
    fin_cases i <;> simp
  have hv0 : |v 0| ≤ ‖v‖ := by simpa only [Real.norm_eq_abs] using norm_le_pi_norm v 0
  have hv1 : |v 1| ≤ ‖v‖ := by simpa only [Real.norm_eq_abs] using norm_le_pi_norm v 1
  calc
    ‖L v‖ = |v 0 * L (Pi.single 0 1) + v 1 * L (Pi.single 1 1)| := by
      conv_lhs => rw [he]
      simp only [map_add, map_smul, smul_eq_mul, Real.norm_eq_abs]
    _ ≤ |v 0| * |L (Pi.single 0 1)| + |v 1| * |L (Pi.single 1 1)| := by
      simpa only [abs_mul] using abs_add_le
        (v 0 * L (Pi.single 0 1)) (v 1 * L (Pi.single 1 1))
    _ ≤ ‖v‖ * |L (Pi.single 0 1)| + ‖v‖ * |L (Pi.single 1 1)| :=
      add_le_add (mul_le_mul_of_nonneg_right hv0 (abs_nonneg _))
        (mul_le_mul_of_nonneg_right hv1 (abs_nonneg _))
    _ = (|L (Pi.single 0 1)| + |L (Pi.single 1 1)|) * ‖v‖ := by ring

def ellipticEdgeRaw (c : ℝ) : Coord → ℝ :=
  ellipticWeight 0 c (fun _ => 1) (fun p => p 0)

def ellipticEdgeKernel (c : ℝ) (p : Coord) : ℝ :=
  if p 1 < 0 then ellipticEdgeRaw c p else 0

def ellipticEdgeDerivative (c : ℝ) (p : Coord) : Coord →L[ℝ] ℝ :=
  if p 1 < 0 then fderiv ℝ (ellipticEdgeRaw c) p else 0

def ellipticEdgeDerivativeConstant (c : ℝ) : ℝ :=
  4 * (3 + (2 * transitionDerivativeBound / c) * (1 + c))

theorem ellipticEdgeRaw_contDiffOn (c : ℝ) :
    ContDiffOn ℝ ∞ (ellipticEdgeRaw c) {p | p 1 < 0} := by
  exact ellipticWeight_contDiffOn 0 c contDiffOn_const
    (contDiffOn_apply ℝ ℝ 0 _) (fun _ h => h)

theorem ellipticEdgeHalfPlane_isOpen : IsOpen {p : Coord | p 1 < 0} :=
  isOpen_lt (continuous_apply 1) continuous_const

theorem ellipticEdgeKernel_norm_le (c : ℝ) (p : Coord) :
    ‖ellipticEdgeKernel c p‖ ≤ |p 1| ^ 6 := by
  unfold ellipticEdgeKernel
  split_ifs with hp
  · unfold ellipticEdgeRaw
    rw [Real.norm_eq_abs, abs_of_nonneg (ellipticWeight_nonneg _ _ _ _ _)]
    have h := ellipticWeight_le_distance_six 0 c (fun _ => 1) (fun p => p 0) p
      ⟨by norm_num, le_rfl⟩
    simpa only [edgeDistance, zero_sub, abs_of_neg hp] using h
  · simp

theorem ellipticEdgeRaw_partial_bound {c : ℝ} (hc : 0 < c) {p : Coord}
    (hp : p 1 < 0) (i : Fin 2) :
    |coordPartial i (ellipticEdgeRaw c) p| ≤
      (ellipticEdgeDerivativeConstant c / 2) * (-p 1) ^ 5 := by
  have hd : 0 < edgeDistance 0 p := by simpa only [edgeDistance, zero_sub] using neg_pos.mpr hp
  have hk : |coordPartial i (fun q : Coord => q 0) p| ≤ (1 : ℝ) := by
    unfold coordPartial
    rw [(hasFDerivAt_apply (𝕜 := ℝ) 0 p).fderiv]
    fin_cases i <;> norm_num [Pi.single_apply]
  have hx : |coordPartial i (fun _ : Coord => (1 : ℝ)) p| ≤ (0 : ℝ) := by
    simp [coordPartial]
  have hh := ellipticWeight_partial_bound (b := 0) (c := c) (M := 1) (X := 0)
    hc hd (by norm_num) (differentiableAt_const 1)
    (differentiableAt_apply (𝕜 := ℝ) 0 p) ⟨by norm_num, le_rfl⟩ i hx hk
  have hsqrt : Real.sqrt (ellipticEdgeRaw c p) ≤ (edgeDistance 0 p) ^ 3 := by
    apply (Real.sqrt_le_iff).mpr
    refine ⟨(pow_pos hd 3).le, ?_⟩
    dsimp only [ellipticEdgeRaw]
    convert ellipticWeight_le_distance_six 0 c (fun _ => 1) (fun p => p 0) p
      ⟨by norm_num, le_rfl⟩ using 1
    ring
  have hP : 0 ≤ (2 * transitionDerivativeBound / c) * (1 + c) :=
    mul_nonneg (div_nonneg (mul_nonneg (by norm_num) transitionDerivativeBound_pos.le) hc.le)
      (by linarith)
  calc
    _ ≤ 2 * Real.sqrt (ellipticEdgeRaw c p) *
        (3 * edgeDistance 0 p ^ 2 + edgeDistance 0 p ^ 3 * 0 +
          edgeDistance 0 p ^ 2 * ((2 * transitionDerivativeBound / c) * (1 + c))) := hh
    _ ≤ 2 * edgeDistance 0 p ^ 3 *
        (3 * edgeDistance 0 p ^ 2 + edgeDistance 0 p ^ 3 * 0 +
          edgeDistance 0 p ^ 2 * ((2 * transitionDerivativeBound / c) * (1 + c))) :=
      mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hsqrt (by norm_num))
        (by positivity)
    _ = _ := by unfold ellipticEdgeDerivativeConstant edgeDistance; ring

theorem ellipticEdgeDerivative_norm_le {c : ℝ} (hc : 0 < c) (p : Coord) :
    ‖ellipticEdgeDerivative c p‖ ≤ ellipticEdgeDerivativeConstant c * |p 1| ^ 5 := by
  have hC : 0 ≤ ellipticEdgeDerivativeConstant c := by
    unfold ellipticEdgeDerivativeConstant
    have := transitionDerivativeBound_pos
    positivity
  unfold ellipticEdgeDerivative
  split_ifs with hp
  · calc
      _ ≤ |coordPartial 0 (ellipticEdgeRaw c) p| +
          |coordPartial 1 (ellipticEdgeRaw c) p| := coordLinear_norm_le _
      _ ≤ (ellipticEdgeDerivativeConstant c / 2) * (-p 1) ^ 5 +
          (ellipticEdgeDerivativeConstant c / 2) * (-p 1) ^ 5 :=
        add_le_add (ellipticEdgeRaw_partial_bound hc hp 0)
          (ellipticEdgeRaw_partial_bound hc hp 1)
      _ = _ := by rw [abs_of_neg hp]; ring
  · simp only [norm_zero]
    exact mul_nonneg hC (pow_nonneg (abs_nonneg _) _)

theorem ellipticEdgeKernel_hasFDerivAt_boundary (c : ℝ) {p : Coord} (hp : p 1 = 0) :
    HasFDerivAt (ellipticEdgeKernel c) (0 : Coord →L[ℝ] ℝ) p := by
  have hpzero : ellipticEdgeKernel c p = 0 := by simp [ellipticEdgeKernel, hp]
  rw [hasFDerivAt_iff_tendsto]
  simp only [hpzero, sub_zero, zero_apply]
  apply squeeze_zero (fun q => mul_nonneg (inv_nonneg.mpr (norm_nonneg _)) (norm_nonneg _))
  · intro q
    have hcoord : |q 1| ≤ ‖q - p‖ := by
      simpa only [Pi.sub_apply, hp, sub_zero, Real.norm_eq_abs] using norm_le_pi_norm (q - p) 1
    have hb : ‖ellipticEdgeKernel c q‖ ≤ ‖q - p‖ ^ 6 :=
      (ellipticEdgeKernel_norm_le c q).trans (pow_le_pow_left₀ (abs_nonneg _) hcoord 6)
    calc
      ‖q - p‖⁻¹ * ‖ellipticEdgeKernel c q‖ ≤ ‖q - p‖⁻¹ * ‖q - p‖ ^ 6 :=
        mul_le_mul_of_nonneg_left hb (inv_nonneg.mpr (norm_nonneg _))
      _ = ‖q - p‖ ^ 5 := by
        by_cases hz : ‖q - p‖ = 0
        · simp [hz]
        · field_simp [hz]
  · have hcont : Continuous (fun q : Coord => ‖q - p‖ ^ 5) :=
      (continuous_id.sub continuous_const).norm.pow 5
    simpa using hcont.tendsto p

theorem ellipticEdgeKernel_hasFDerivAt (c : ℝ) (p : Coord) :
    HasFDerivAt (ellipticEdgeKernel c) (ellipticEdgeDerivative c p) p := by
  rcases lt_trichotomy (p 1) 0 with hp | hp | hp
  · have hn := ellipticEdgeHalfPlane_isOpen.mem_nhds hp
    have hd := ((ellipticEdgeRaw_contDiffOn c).contDiffAt hn).differentiableAt (by simp)
    have he : ellipticEdgeKernel c =ᶠ[𝓝 p] ellipticEdgeRaw c := by
      filter_upwards [hn] with q hq
      simp [ellipticEdgeKernel, hq]
    simpa only [ellipticEdgeDerivative, hp, ite_eq_left] using hd.hasFDerivAt.congr_of_eventuallyEq he
  · simpa [ellipticEdgeDerivative, hp] using ellipticEdgeKernel_hasFDerivAt_boundary c hp
  · have hn : {q : Coord | 0 < q 1} ∈ 𝓝 p :=
      (isOpen_lt continuous_const (continuous_apply 1)).mem_nhds hp
    have he : ellipticEdgeKernel c =ᶠ[𝓝 p] (fun _ => 0) := by
      filter_upwards [hn] with q hq
      simp [ellipticEdgeKernel, not_lt_of_ge hq.le]
    simpa [ellipticEdgeDerivative, not_lt_of_ge hp.le] using
      (hasFDerivAt_const (𝕜 := ℝ) (0 : ℝ) p).congr_of_eventuallyEq he

theorem ellipticEdgeDerivative_continuous {c : ℝ} (hc : 0 < c) :
    Continuous (ellipticEdgeDerivative c) := by
  rw [continuous_iff_continuousAt]
  intro p
  rcases lt_trichotomy (p 1) 0 with hp | hp | hp
  · have hn := ellipticEdgeHalfPlane_isOpen.mem_nhds hp
    have hd := ((ellipticEdgeRaw_contDiffOn c).continuousOn_fderiv_of_isOpen
      ellipticEdgeHalfPlane_isOpen (by simp)).continuousAt hn
    apply hd.congr_of_eventuallyEq
    filter_upwards [hn] with q hq
    simp [ellipticEdgeDerivative, hq]
  · have hz : ellipticEdgeDerivative c p = 0 := by simp [ellipticEdgeDerivative, hp]
    change Tendsto (ellipticEdgeDerivative c) (𝓝 p) (𝓝 (ellipticEdgeDerivative c p))
    rw [hz, tendsto_zero_iff_norm_tendsto_zero]
    apply squeeze_zero (fun _ => norm_nonneg _) (ellipticEdgeDerivative_norm_le hc)
    have hcont : Continuous (fun q : Coord => ellipticEdgeDerivativeConstant c * |q 1| ^ 5) :=
      continuous_const.mul (((continuous_apply 1).abs).pow 5)
    simpa [hp] using hcont.tendsto p
  · have hn : {q : Coord | 0 < q 1} ∈ 𝓝 p :=
      (isOpen_lt continuous_const (continuous_apply 1)).mem_nhds hp
    apply (continuousAt_const (y := (0 : Coord →L[ℝ] ℝ))).congr_of_eventuallyEq
    filter_upwards [hn] with q hq
    simp [ellipticEdgeDerivative, not_lt_of_ge hq.le]

theorem ellipticEdgeKernel_contDiff_one {c : ℝ} (hc : 0 < c) :
    ContDiff ℝ 1 (ellipticEdgeKernel c) :=
  contDiff_one_iff_hasFDerivAt.mpr
    ⟨ellipticEdgeDerivative c, ellipticEdgeDerivative_continuous hc,
      ellipticEdgeKernel_hasFDerivAt c⟩

def ellipticWeightC1 (b c : ℝ) (chi K : Coord → ℝ) (p : Coord) : ℝ :=
  chi p ^ 2 * ellipticEdgeKernel c ![K p, p 1 - b]

theorem ellipticWeightC1_eq {b c : ℝ} {chi K : Coord → ℝ} {p : Coord}
    (hp : p 1 ≤ b) : ellipticWeightC1 b c chi K p = ellipticWeight b c chi K p := by
  rcases hp.eq_or_lt with he | hl
  · simp [ellipticWeightC1, ellipticEdgeKernel, ellipticWeight, edgeDistance, he]
  · have hs : p 1 - b < 0 := sub_neg.mpr hl
    simp only [ellipticWeightC1, ellipticEdgeKernel, Matrix.cons_val_one, Matrix.cons_val_zero,
      hs, ite_eq_left, ellipticEdgeRaw, ellipticWeight, edgeDistance]
    simp only [one_pow, mul_one]
    have hd : 0 - (p 1 - b) = b - p 1 := by ring
    rw [hd]
    ring

theorem ellipticWeightC1_zero {b c : ℝ} {chi K : Coord → ℝ} {p : Coord}
    (hp : b ≤ p 1) : ellipticWeightC1 b c chi K p = 0 := by
  simp [ellipticWeightC1, ellipticEdgeKernel, not_lt_of_ge (sub_nonneg.mpr hp)]

theorem ellipticWeightC1_nonneg (b c : ℝ) (chi K : Coord → ℝ) (p : Coord) :
    0 ≤ ellipticWeightC1 b c chi K p := by
  by_cases hp : p 1 ≤ b
  · rw [ellipticWeightC1_eq hp]
    exact ellipticWeight_nonneg _ _ _ _ _
  · rw [ellipticWeightC1_zero (lt_of_not_ge hp).le]

theorem ellipticWeightC1_le_distance_six (b c : ℝ) (chi K : Coord → ℝ) (p : Coord)
    (hchi : 0 ≤ chi p ∧ chi p ≤ 1) :
    ellipticWeightC1 b c chi K p ≤ edgeDistance b p ^ 6 := by
  by_cases hp : p 1 ≤ b
  · rw [ellipticWeightC1_eq hp]
    exact ellipticWeight_le_distance_six _ _ _ _ _ hchi
  · rw [ellipticWeightC1_zero (lt_of_not_ge hp).le]
    positivity

theorem ellipticWeightC1_partial_eq {b c : ℝ} {chi K : Coord → ℝ} {p : Coord}
    (hp : p 1 < b) (i : Fin 2) :
    coordPartial i (ellipticWeightC1 b c chi K) p =
      coordPartial i (ellipticWeight b c chi K) p := by
  have he : ellipticWeightC1 b c chi K =ᶠ[𝓝 p] ellipticWeight b c chi K := by
    filter_upwards [(isOpen_lt (continuous_apply 1) continuous_const).mem_nhds hp] with q hq
    exact ellipticWeightC1_eq hq.le
  unfold coordPartial
  rw [he.fderiv_eq]

theorem ellipticWeightC1_contDiffOn {b c : ℝ} {chi K : Coord → ℝ} {U : Set Coord}
    (hc : 0 < c) (hchi : ContDiffOn ℝ 1 chi U) (hK : ContDiffOn ℝ 1 K U) :
    ContDiffOn ℝ 1 (ellipticWeightC1 b c chi K) U := by
  have hmap : ContDiffOn ℝ 1 (fun p : Coord => ![K p, p 1 - b]) U := by
    apply contDiffOn_pi.mpr
    intro i
    fin_cases i
    · simpa using hK
    · simpa using (contDiffOn_apply ℝ ℝ 1 U).sub contDiffOn_const
  exact (hchi.pow 2).mul ((ellipticEdgeKernel_contDiff_one hc).comp_contDiffOn hmap)

end SmoothLocal.Weighted

end

end OAI