import OAI.Geometry.IsometricImmersion.Caps.EllipticEnergy
import Mathlib.Analysis.Calculus.LocalExtr.Basic
import Mathlib.Tactic.NormNum

namespace OAI

noncomputable section
open Set Filter MeasureTheory
open scoped ContDiff Topology Interval

namespace SmoothLocal.Weighted

open SmoothLocal.Geometry

theorem weighted_young (w x y : ℝ) (hw : 0 < w) :
    |x * y| ≤ (w * x ^ 2 + y ^ 2 / w) / 2 := by
  have hminus : 0 ≤ w * x ^ 2 - 2 * x * y + y ^ 2 / w := by
    have hn := div_nonneg (sq_nonneg (w * x - y)) hw.le
    have he : (w * x - y) ^ 2 / w = w * x ^ 2 - 2 * x * y + y ^ 2 / w := by
      field_simp [ne_of_gt hw]
      ring
    rw [he] at hn
    exact hn
  have hplus : 0 ≤ w * x ^ 2 + 2 * x * y + y ^ 2 / w := by
    have hn := div_nonneg (sq_nonneg (w * x + y)) hw.le
    have he : (w * x + y) ^ 2 / w = w * x ^ 2 + 2 * x * y + y ^ 2 / w := by
      field_simp [ne_of_gt hw]
      ring
    rw [he] at hn
    exact hn
  apply abs_le.mpr
  constructor <;> nlinarith

theorem elliptic_error_scalar_bound
    (A v u x y eT eS H : ℝ) (hv : 0 < v) (hA : 0 < A)
    (hratio : eT ^ 2 / v + eS ^ 2 / (A * v) ≤ H) :
    |u * (eT * x + eS * y)| ≤ v * (x ^ 2 + A * y ^ 2) / 2 + H * u ^ 2 / 2 := by
  have hx := weighted_young v x (u * eT) hv
  have hy := weighted_young (A * v) y (u * eS) (mul_pos hA hv)
  calc
    |u * (eT * x + eS * y)| = |x * (u * eT) + y * (u * eS)| := by congr 1; ring
    _ ≤ |x * (u * eT)| + |y * (u * eS)| := abs_add_le _ _
    _ ≤ (v * x ^ 2 + (u * eT) ^ 2 / v) / 2 +
        (A * v * y ^ 2 + (u * eS) ^ 2 / (A * v)) / 2 := add_le_add hx hy
    _ = v * (x ^ 2 + A * y ^ 2) / 2 +
        (eT ^ 2 / v + eS ^ 2 / (A * v)) * u ^ 2 / 2 := by
      field_simp [ne_of_gt hv, ne_of_gt hA]
      ring
    _ ≤ v * (x ^ 2 + A * y ^ 2) / 2 + H * u ^ 2 / 2 := by
      nlinarith [mul_le_mul_of_nonneg_right hratio (sq_nonneg u)]

variable {A B C v u f : Coord → ℝ} {U : Set Coord} {p : Coord}

theorem ellipticErrors_zero_of_nonneg
    (hU : IsOpen U) (hp : p ∈ U) (hA : DifferentiableAt ℝ A p)
    (hv : DifferentiableAt ℝ v p) (hvn : ∀ q ∈ U, 0 ≤ v q) (hzero : v p = 0) :
    ellipticErrorT B v p = 0 ∧ ellipticErrorS A C v p = 0 := by
  have hmin : IsLocalMin v p := by
    change ∀ᶠ q in 𝓝 p, v p ≤ v q
    filter_upwards [hU.mem_nhds hp] with q hq
    simpa only [hzero] using hvn q hq
  have hdv := hmin.fderiv_eq_zero
  have hpv (i : Fin 2) : coordPartial i v p = 0 := by simp [coordPartial, hdv]
  constructor
  · simp [ellipticErrorT, hpv 0, hzero]
  · rw [ellipticErrorS, HessianCalculus.coordPartial_mul_at hA hv 1]
    simp [hpv 1, hzero]

theorem ellipticError_abs_bound
    (hU : IsOpen U) (hp : p ∈ U) (hA : DifferentiableAt ℝ A p)
    (hv : DifferentiableAt ℝ v p) (hvn : ∀ q ∈ U, 0 ≤ v q)
    (H : ℝ) (hH : 0 ≤ H)
    (hpos : 0 < v p → 0 < A p)
    (hratio : 0 < v p → (ellipticErrorT B v p) ^ 2 / v p +
      (ellipticErrorS A C v p) ^ 2 / (A p * v p) ≤ H) :
    |ellipticError A B C v u p| ≤ ellipticEnergy A v u p / 2 + H * (u p) ^ 2 / 2 := by
  by_cases hzero : v p = 0
  · have hz := ellipticErrors_zero_of_nonneg (B := B) (C := C) hU hp hA hv hvn hzero
    simp only [ellipticError, ellipticEnergy, hz.1, hz.2, hzero,
      zero_mul, add_zero, mul_zero, abs_zero, zero_div, zero_add]
    exact div_nonneg (mul_nonneg hH (sq_nonneg _)) (by norm_num)
  · have hvpos : 0 < v p := lt_of_le_of_ne (hvn p hp) (Ne.symm hzero)
    exact elliptic_error_scalar_bound (A p) (v p) (u p)
      (coordPartial 0 u p) (coordPartial 1 u p)
      (ellipticErrorT B v p) (ellipticErrorS A C v p) H hvpos (hpos hvpos) (hratio hvpos)

theorem ellipticEnergy_nonneg (A v u : Coord → ℝ) (p : Coord)
    (hv : 0 ≤ v p) (hA : 0 < v p → 0 < A p) : 0 ≤ ellipticEnergy A v u p := by
  by_cases hz : v p = 0
  · simp [ellipticEnergy, hz]
  · have hvpos : 0 < v p := lt_of_le_of_ne hv (Ne.symm hz)
    exact mul_nonneg hv (add_nonneg (sq_nonneg _) (mul_nonneg (hA hvpos).le (sq_nonneg _)))

variable {tl tr sb st : ℝ}

theorem rectangleIntegral_sub {F G : Coord → ℝ} (ht : tl ≤ tr) (hs : sb ≤ st)
    (hF : ContinuousOn F (closedRectangle tl tr sb st))
    (hG : ContinuousOn G (closedRectangle tl tr sb st)) :
    rectangleIntegral tl tr sb st (fun p => F p - G p) =
      rectangleIntegral tl tr sb st F - rectangleIntegral tl tr sb st G := by
  simp only [sub_eq_add_neg]
  have hneg : ContinuousOn (fun p => -G p) (closedRectangle tl tr sb st) := hG.neg
  rw [rectangleIntegral_add ht hs hF hneg, rectangleIntegral_neg]

theorem rectangleIntegral_mono {F G : Coord → ℝ} (ht : tl ≤ tr) (hs : sb ≤ st)
    (hF : ContinuousOn F (closedRectangle tl tr sb st))
    (hG : ContinuousOn G (closedRectangle tl tr sb st))
    (hle : ∀ p ∈ closedRectangle tl tr sb st, F p ≤ G p) :
    rectangleIntegral tl tr sb st F ≤ rectangleIntegral tl tr sb st G := by
  rw [rectangleIntegral_eq_area ht hs hF, rectangleIntegral_eq_area ht hs hG]
  apply setIntegral_mono_on (rectangle_area_integrable hF) (rectangle_area_integrable hG)
    (measurableSet_Ioc.prod measurableSet_Ioc)
  intro p hp
  exact hle (boxPoint p.1 p.2) (boxPoint_mem
    (Ioc_subset_Icc_self hp.1) (Ioc_subset_Icc_self hp.2))

theorem integrated_elliptic_energy_bound
    (ht : tl ≤ tr) (hs : sb ≤ st) (hU : IsOpen U)
    (hA : ContDiffOn ℝ ∞ A U) (hB : ContDiffOn ℝ ∞ B U)
    (hC : ContDiffOn ℝ ∞ C U) (hv : ContDiffOn ℝ ∞ v U) (hu : ContDiffOn ℝ ∞ u U)
    (hbox : closedRectangle tl tr sb st ⊆ U) (hboundary : zeroRectangleBoundary tl tr sb st v)
    (hEq : ∀ p ∈ U, multiplierOperator A B C u p = f p)
    (V H : ℝ) (hV : 0 ≤ V) (hH : 0 ≤ H)
    (hvn : ∀ p ∈ U, 0 ≤ v p)
    (hvV : ∀ p ∈ closedRectangle tl tr sb st, v p ≤ V)
    (hpos : ∀ p ∈ closedRectangle tl tr sb st, 0 < v p → 0 < A p)
    (hratio : ∀ p ∈ closedRectangle tl tr sb st, 0 < v p →
      (ellipticErrorT B v p) ^ 2 / v p + (ellipticErrorS A C v p) ^ 2 / (A p * v p) ≤ H) :
    rectangleIntegral tl tr sb st (ellipticEnergy A v u) ≤
      V * rectangleIntegral tl tr sb st (fun p => (f p) ^ 2) +
        (V + H) * rectangleIntegral tl tr sb st (fun p => (u p) ^ 2) := by
  have hf : ContDiffOn ℝ ∞ f U :=
    (ellipticOperator_contDiffOn hU hA hB hC hu).congr (fun p hp => (hEq p hp).symm)
  obtain ⟨_, _, hE, hErr⟩ := elliptic_fields_contDiffOn hU hA hB hC hv hu
  have hSource := (hv.mul hu).mul hf
  have hpoint (p : Coord) (hp : p ∈ closedRectangle tl tr sb st) :
      -(v p * u p * f p) - ellipticError A B C v u p ≤
        (1 / 2 : ℝ) * ellipticEnergy A v u p +
          ((V + H) / 2) * (u p) ^ 2 + (V / 2) * (f p) ^ 2 := by
    have hpU := hbox hp
    have hErrBound := ellipticError_abs_bound (u := u) hU hpU
      ((hA.contDiffAt (hU.mem_nhds hpU)).differentiableAt (by simp))
      ((hv.contDiffAt (hU.mem_nhds hpU)).differentiableAt (by simp))
      hvn H hH (hpos p hp) (hratio p hp)
    have hyoung : -(u p * f p) ≤ ((u p) ^ 2 + (f p) ^ 2) / 2 := by
      nlinarith [sq_nonneg (u p + f p)]
    have hm := mul_le_mul_of_nonneg_left hyoung (hvn p hpU)
    have hcost := mul_le_mul (hvV p hp) (le_refl (((u p) ^ 2 + (f p) ^ 2) / 2))
      (div_nonneg (add_nonneg (sq_nonneg (u p)) (sq_nonneg (f p)))
        (by norm_num : (0 : ℝ) ≤ 2)) hV
    have hsource : -(v p * u p * f p) ≤ V * ((u p) ^ 2 + (f p) ^ 2) / 2 := by
      nlinarith [hm, hcost]
    nlinarith [hsource, neg_le_abs (ellipticError A B C v u p)]
  have hEhalf : ContinuousOn (fun p => (1 / 2 : ℝ) * ellipticEnergy A v u p)
      (closedRectangle tl tr sb st) := (contDiffOn_const.mul hE).continuousOn.mono hbox
  have hUhalf : ContinuousOn (fun p => ((V + H) / 2) * (u p) ^ 2)
      (closedRectangle tl tr sb st) := (contDiffOn_const.mul (hu.pow 2)).continuousOn.mono hbox
  have hFhalf : ContinuousOn (fun p => (V / 2) * (f p) ^ 2)
      (closedRectangle tl tr sb st) := (contDiffOn_const.mul (hf.pow 2)).continuousOn.mono hbox
  have hi := rectangleIntegral_mono ht hs
    ((hSource.neg.sub hErr).continuousOn.mono hbox) ((hEhalf.add hUhalf).add hFhalf) hpoint
  simp only [Pi.add_def] at hi
  have hsum : ContinuousOn (fun p => (1 / 2 : ℝ) * ellipticEnergy A v u p +
      ((V + H) / 2) * (u p) ^ 2) (closedRectangle tl tr sb st) := hEhalf.add hUhalf
  have heq := integrated_elliptic_equation ht hs hU hA hB hC hv hu hbox hboundary hEq
  have hleft : rectangleIntegral tl tr sb st
      (fun p => -(v p * u p * f p) - ellipticError A B C v u p) =
      rectangleIntegral tl tr sb st (ellipticEnergy A v u) := by
    rw [rectangleIntegral_sub ht hs (hSource.neg.continuousOn.mono hbox)
      (hErr.continuousOn.mono hbox), rectangleIntegral_neg]
    exact heq.symm
  rw [hleft,
    rectangleIntegral_add ht hs hsum hFhalf,
    rectangleIntegral_add ht hs hEhalf hUhalf,
    rectangleIntegral_const_mul tl tr sb st (1 / 2 : ℝ) (ellipticEnergy A v u),
    rectangleIntegral_const_mul tl tr sb st ((V + H) / 2) (fun p => (u p) ^ 2),
    rectangleIntegral_const_mul tl tr sb st (V / 2) (fun p => (f p) ^ 2)] at hi
  nlinarith

end SmoothLocal.Weighted

end

end OAI