import OAI.Geometry.IsometricImmersion.Curvature.CurvatureLowerTube
import OAI.Geometry.IsometricImmersion.Pulses.PulseDerivativeBounds
import OAI.Geometry.IsometricImmersion.Calculus.CoordinateJetNorm

namespace OAI

noncomputable section
open Set Filter
open scoped ContDiff Topology Matrix Matrix.Norms.Elementwise

namespace SmoothLocal.Pulse
open SmoothLocal.Geometry

def scalarPulseDerivativeBound (a : ℝ) (ha : 0 < a) (delta : ℝ) (k : ℕ) : ℝ :=
  pulseCoreDerivativeBound a ha k * pulseScaleBound 0 delta ^ k

theorem scalarPulseDerivativeBound_nonneg {a : ℝ} (ha : 0 < a) (delta : ℝ) (k : ℕ) :
    0 ≤ scalarPulseDerivativeBound a ha delta k :=
  mul_nonneg (pulseCoreDerivativeBound_nonneg ha k) (pow_nonneg (pulseScaleBound_pos 0 delta).le k)

theorem pulseScalar_eq_core (a : ℝ) (N : ℕ) (delta tau : ℝ) :
    pulseScalar a N delta tau = fun p => (1/tau^N) • pulseCore 0 a delta tau p := by
  funext p
  simp only [pulseScalar,pulseCore,xiCLM,thetaCLM,temporalCutoff,
    add_apply,smul_apply,
    ContinuousLinearMap.proj_apply,smul_eq_mul,zero_mul,add_zero]
  have ht : tau/delta*p 1 = tau*p 1/delta := by ring
  rw [ht]
  ring

theorem pulseScalar_derivative_le {a : ℝ} (ha : 0 < a) (N : ℕ) (delta : ℝ)
    {tau : ℝ} (ht : 1 ≤ tau) (k : ℕ) (p : Coord) :
    ‖iteratedFDeriv ℝ k (pulseScalar a N delta tau) p‖ ≤
      scalarPulseDerivativeBound a ha delta k * tau^k/tau^N := by
  have ht0 : 0 < tau := zero_lt_one.trans_le ht
  rw [pulseScalar_eq_core]
  rw [iteratedFDeriv_const_smul_apply' (i := k) (a := (1/tau^N : ℝ))
    ((pulseCore_contDiff 0 a delta tau).contDiffAt.of_le (WithTop.coe_le_coe.mpr le_top)),
    norm_smul,Real.norm_of_nonneg (div_nonneg zero_le_one (pow_nonneg ht0.le N))]
  calc
    _ ≤ (1/tau^N)*(pulseCoreDerivativeBound a ha k*(tau*pulseScaleBound 0 delta)^k) :=
      mul_le_mul_of_nonneg_left (pulseCore_derivative_le ha 0 delta ht k p)
        (div_nonneg zero_le_one (pow_nonneg ht0.le N))
    _ = _ := by rw [mul_pow]; unfold scalarPulseDerivativeBound; ring

def scalarPulseFirstJetBound (a : ℝ) (ha : 0 < a) (delta : ℝ) : ℝ :=
  max (scalarPulseDerivativeBound a ha delta 0) (scalarPulseDerivativeBound a ha delta 1)

theorem scalarPulseFirstJetBound_nonneg {a : ℝ} (ha : 0 < a) (delta : ℝ) :
    0 ≤ scalarPulseFirstJetBound a ha delta :=
  (scalarPulseDerivativeBound_nonneg ha delta 0).trans (le_max_left _ _)

def scalarPulseFirstJetBudget (a : ℝ) (ha : 0 < a) (N : ℕ) (delta tau : ℝ) : ℝ :=
  scalarPulseFirstJetBound a ha delta * tau/tau^N

theorem scalarPulseFirstJetBudget_nonneg {a : ℝ} (ha : 0 < a) (N : ℕ) (delta : ℝ)
    {tau : ℝ} (ht : 1 ≤ tau) : 0 ≤ scalarPulseFirstJetBudget a ha N delta tau :=
  div_nonneg (mul_nonneg (scalarPulseFirstJetBound_nonneg ha delta) (zero_le_one.trans ht))
    (pow_nonneg (zero_le_one.trans ht) N)

theorem pulseScalar_first_jet_bounds {a : ℝ} (ha : 0 < a) (N : ℕ) (delta : ℝ)
    {tau : ℝ} (ht : 1 ≤ tau) (p : Coord) :
    |pulseScalar a N delta tau p| ≤ scalarPulseFirstJetBudget a ha N delta tau ∧
      ∀ i, |coordPartial i (pulseScalar a N delta tau) p| ≤ scalarPulseFirstJetBudget a ha N delta tau := by
  have ht0 : 0 ≤ tau := zero_le_one.trans ht
  have hden : 0 ≤ tau^N := pow_nonneg ht0 N
  have hB0 : scalarPulseDerivativeBound a ha delta 0 ≤ scalarPulseFirstJetBound a ha delta :=
    le_max_left _ _
  have hB1 : scalarPulseDerivativeBound a ha delta 1 ≤ scalarPulseFirstJetBound a ha delta :=
    le_max_right _ _
  constructor
  · have h := pulseScalar_derivative_le ha N delta ht 0 p
    simp only [norm_iteratedFDeriv_zero,Real.norm_eq_abs,pow_zero,mul_one] at h
    exact h.trans (div_le_div_of_nonneg_right
      (hB0.trans (le_mul_of_one_le_right (scalarPulseFirstJetBound_nonneg ha delta) ht)) hden)
  · intro i
    have h := (norm_iteratedCoordPartial_le_jet
      (pulseScalar_contDiff a N delta tau).contDiffOn isOpen_univ [i] (mem_univ p)).trans
        (pulseScalar_derivative_le ha N delta ht 1 p)
    simp only [iteratedCoordPartial,Real.norm_eq_abs,pow_one] at h
    exact h.trans (div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_right hB1 ht0) hden)

theorem thetaPulse_first_increment_bound {a : ℝ} (ha : 0 < a) (N : ℕ) (delta : ℝ)
    {tau : ℝ} (ht : 1 ≤ tau) (p : Coord) :
    ‖thetaCurvatureFirstIncrement (pulseScalar a N delta tau) p‖ ≤
      scalarPulseFirstJetBudget a ha N delta tau :=
  thetaCurvatureFirstIncrement_norm_le _ p (scalarPulseFirstJetBudget_nonneg ha N delta ht)
    (pulseScalar_first_jet_bounds ha N delta ht p).1 (pulseScalar_first_jet_bounds ha N delta ht p).2

theorem scalarPulseFirstJetBudget_tendsto_zero {a : ℝ} (ha : 0 < a) (N : ℕ)
    (hN : 1 < N) (delta : ℝ) :
    Tendsto (scalarPulseFirstJetBudget a ha N delta) atTop (𝓝 0) := by
  have hn : N-1 ≠ 0 := by omega
  have hi := (tendsto_inv_atTop_zero : Tendsto (fun t : ℝ => t⁻¹) atTop (𝓝 0)).pow (N-1)
  have h : Tendsto (fun t : ℝ => scalarPulseFirstJetBound a ha delta*(t⁻¹)^(N-1)) atTop (𝓝 0) := by
    simpa only [zero_pow hn,mul_zero] using hi.const_mul (scalarPulseFirstJetBound a ha delta)
  apply h.congr'
  filter_upwards [eventually_gt_atTop (0 : ℝ)] with t ht
  have hN' : N = 1+(N-1) := by omega
  have hr : t/t^N = (t⁻¹)^(N-1) := by
    conv_lhs => rw [hN',pow_add,pow_one]
    rw [inv_pow]
    field_simp [ht.ne']
  simp only [scalarPulseFirstJetBudget,mul_div_assoc,hr]

theorem exists_uniform_actual_pulse_lower_bound (B : ℝ) {d : ℝ} (hd : 0 < d)
    {a : ℝ} (ha : 0 < a) (N : ℕ) (hN : 1 < N) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ delta : ℝ, ∃ T : ℝ, 1 ≤ T ∧
      ∀ tau : ℝ, T ≤ tau → ∀ (g : MetricField) (p : Coord),
        ‖actualCurvatureFirstInput g p‖ ≤ B → d ≤ (g p).det →
        |thetaPulseLowerDifference g (pulseScalar a N delta tau) p| ≤
          C*scalarPulseFirstJetBudget a ha N delta tau := by
  obtain ⟨C,hC,hbound⟩ := exists_uniform_thetaPulseLowerDifference_bound B hd
  refine ⟨C,hC,?_⟩
  intro delta
  let beta := max B 0+1
  have hbeta : 0 < beta := by dsimp only [beta]; linarith [le_max_right B 0]
  let e := min 1 (d/(2*beta))
  have he : 0 < e := lt_min zero_lt_one (div_pos hd (mul_pos (by norm_num) hbeta))
  have hev : ∀ᶠ tau : ℝ in atTop, scalarPulseFirstJetBudget a ha N delta tau < e :=
    (scalarPulseFirstJetBudget_tendsto_zero ha N hN delta).eventually (eventually_lt_nhds he)
  obtain ⟨T,hT⟩ := eventually_atTop.mp hev
  refine ⟨max T 1,le_max_right _ _,?_⟩
  intro tau ht g p hg hdet
  have ht1 : 1 ≤ tau := (le_max_right _ _).trans ht
  have htT : T ≤ tau := (le_max_left _ _).trans ht
  have hsmall1 : scalarPulseFirstJetBudget a ha N delta tau ≤ 1 :=
    (hT tau htT).le.trans (min_le_left _ _)
  have hsmallD : scalarPulseFirstJetBudget a ha N delta tau ≤ d/(2*beta) :=
    (hT tau htT).le.trans (min_le_right _ _)
  have hg00 : |g p 0 0| ≤ beta := by
    have h0 : |g p 0 0| ≤ ‖actualCurvatureFirstInput g p‖ := by
      simpa only [Real.norm_eq_abs] using
        ((norm_le_pi_norm (g p 0) 0).trans (norm_le_pi_norm (g p) 0)).trans
          (norm_fst_le (actualCurvatureFirstInput g p))
    exact (h0.trans hg).trans (by dsimp only [beta]; linarith [le_max_left B 0])
  have hproduct : |g p 0 0| * |pulseScalar a N delta tau p| ≤ d/2 := by
    calc
      _ ≤ beta*scalarPulseFirstJetBudget a ha N delta tau :=
        mul_le_mul hg00 (pulseScalar_first_jet_bounds ha N delta ht1 p).1
          (abs_nonneg _) hbeta.le
      _ ≤ beta*(d/(2*beta)) := mul_le_mul_of_nonneg_left hsmallD hbeta.le
      _ = d/2 := by field_simp [hbeta.ne']
  have hinc := thetaPulse_first_increment_bound ha N delta ht1 p
  exact (hbound g (pulseScalar a N delta tau) p hg hdet (hinc.trans hsmall1) hproduct).trans
    (mul_le_mul_of_nonneg_left hinc hC)

end SmoothLocal.Pulse

end

end OAI