import OAI.MathematicalPhysics.RapidForcing.VelocitySyntax
import OAI.MathematicalPhysics.RapidForcing.JetBounds

namespace OAI

section
open scoped BigOperators Topology ENNReal ContDiff
open Set Filter
namespace RapidForcing.EffectiveProfile.Formula

def spIndex (i : Fin 3) : Fin 10 := ⟨i.val+1, by omega⟩
def etaIndex (i : Fin 3) : Fin 10 := ⟨i.val+4, by omega⟩
def xiIndex (i : Fin 3) : Fin 10 := ⟨i.val+7, by omega⟩

noncomputable def profileLinear : (ℝ × Space) →L[ℝ] (Fin 10 → ℝ) :=
  ContinuousLinearMap.pi ![ContinuousLinearMap.fst ℝ ℝ Space,
    (EuclideanSpace.proj 0).comp (ContinuousLinearMap.snd ℝ ℝ Space),
    (EuclideanSpace.proj 1).comp (ContinuousLinearMap.snd ℝ ℝ Space),
    (EuclideanSpace.proj 2).comp (ContinuousLinearMap.snd ℝ ℝ Space), 0,0,0,0,0,0]
noncomputable def profileParams (η ξ : Space) : Fin 10 → ℝ :=
  ![0,0,0,0,η 0,η 1,η 2,ξ 0,ξ 1,ξ 2]
noncomputable def profilePack (η ξ : Space) (t : ℝ) (x : Space) : Fin 10 → ℝ :=
  profileLinear (t,x) + profileParams η ξ

lemma profilePack_eq (η ξ : Space) (t : ℝ) (x : Space) :
    profilePack η ξ t x = ![t,x 0,x 1,x 2,η 0,η 1,η 2,ξ 0,ξ 1,ξ 2] := by
  ext i
  fin_cases i <;> dsimp [profilePack, profileLinear, profileParams] <;> simp

lemma profileLinear_norm : ‖profileLinear‖ ≤ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
  intro p
  rw [one_mul]
  apply (pi_norm_le_iff_of_nonneg (norm_nonneg p)).mpr
  intro i
  fin_cases i
  · exact norm_fst_le p
  · exact (PiLp.norm_apply_le p.2 0).trans (norm_snd_le p)
  · exact (PiLp.norm_apply_le p.2 1).trans (norm_snd_le p)
  · exact (PiLp.norm_apply_le p.2 2).trans (norm_snd_le p)
  all_goals simp [profileLinear]

lemma profilePack_line (η ξ : Space) (t : ℝ) (x : Space) (i : Fin 3) (s : ℝ) :
    profilePack η ξ t (x + s • basis i) = profilePack η ξ t x + s • Pi.single (spIndex i) 1 := by
  ext j
  fin_cases i <;> fin_cases j <;> simp [profilePack_eq, spIndex, basis]

noncomputable def profileField (a : Fin 3 → Formula 10) (η ξ : Space) : Field Space :=
  fun t x => WithLp.toLp 2 (fun i => (a i).value (profilePack η ξ t x))
lemma profileField_smooth (a : Fin 3 → Formula 10) (η ξ : Space) :
    ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (profileField a η ξ)) := by
  apply (contDiff_piLp 2).mpr
  intro i
  exact (a i).contDiff.comp (profileLinear.contDiff.add contDiff_const)

lemma profile_partial (a : Formula 10) (η ξ : Space) (t : ℝ) (x : Space) (i : Fin 3) :
    fderiv ℝ (fun y => a.value (profilePack η ξ t y)) x (basis i) =
      (a.diff (spIndex i)).value (profilePack η ξ t x) := by
  have hline : HasDerivAt (fun s : ℝ => x + s • basis i) (basis i) 0 := by
    simpa using ((hasDerivAt_id (0 : ℝ)).smul_const (basis i)).const_add x
  have hsm : ContDiff ℝ (⊤ : ℕ∞) (fun y => a.value (profilePack η ξ t y)) :=
    a.contDiff.comp ((profileLinear.contDiff.comp (contDiff_const.prodMk contDiff_id)).add contDiff_const)
  have hp := a.hasDerivAt_line (spIndex i) (profilePack η ξ t x) 0
  have he : (fun s : ℝ => a.value (profilePack η ξ t x + s • Pi.single (spIndex i) 1)) =
      fun s => a.value (profilePack η ξ t (x+s • basis i)) := by
    funext s
    rw [← profilePack_line]
  rw [he] at hp
  have hf : HasFDerivAt (fun y => a.value (profilePack η ξ t y))
      (fderiv ℝ (fun y => a.value (profilePack η ξ t y)) x) (x+(0:ℝ) • basis i) := by
    simpa using (hsm.differentiable (by simp) x).hasFDerivAt
  have hc := hf.comp_hasDerivAt 0 hline
  simpa only [zero_smul, add_zero] using hc.unique hp

def profileCurl (a : Fin 3 → Formula 10) : Fin 3 → Formula 10 :=
  ![((a 2).diff (spIndex 1)).sub ((a 1).diff (spIndex 2)),
    ((a 0).diff (spIndex 2)).sub ((a 2).diff (spIndex 0)),
    ((a 1).diff (spIndex 0)).sub ((a 0).diff (spIndex 1))]
lemma profileCurl_value (a : Fin 3 → Formula 10) (η ξ : Space) (t : ℝ) (x : Space) :
    profileField (profileCurl a) η ξ t x = curl (profileField a η ξ t) x := by
  have hs (i j : Fin 3) : (fderiv ℝ (profileField a η ξ t) x (basis i)) j =
      ((a j).diff (spIndex i)).value (profilePack η ξ t x) := by
    have hd : DifferentiableAt ℝ (profileField a η ξ t) x :=
      ((profileField_smooth a η ξ).comp
        (contDiff_const.prodMk contDiff_id)).differentiable (by simp) x
    rw [← fderiv_coordinate hd]
    exact profile_partial (a j) η ξ t x i
  ext i
  fin_cases i <;> simp [profileField, profileCurl, curl, vec, hs, value_sub]

def scaledFormula : Fin 3 → Formula 10 :=
  let y := fun i => (Formula.var (spIndex i) : Formula 10).sub
    (Formula.mul (Formula.var 0).theta (Formula.var (etaIndex i)))
  let speed := fun i => Formula.mul (Formula.var 0).thetaDot (Formula.var (xiIndex i))
  profileCurl (fun i => Formula.mul (zeta y) (Formula.mul (Formula.const (1/2)) (crossF speed y i)))

lemma scaledFormula_value (η ξ : Space) (t : ℝ) (x : Space) :
    profileField scaledFormula η ξ t x = scaledCurl η ξ t x := by
  unfold scaledFormula
  rw [profileCurl_value]
  unfold scaledCurl
  congr 1
  funext y
  have hy : WithLp.toLp 2 (fun i => ((Formula.var (spIndex i) : Formula 10).sub
      (Formula.mul (Formula.var 0).theta (Formula.var (etaIndex i)))).value (profilePack η ξ t y)) =
      y - θ t • η := by
    ext i
    fin_cases i <;> simp [value_sub, value, value_theta, profilePack_eq, spIndex, etaIndex]
  have hv : WithLp.toLp 2 (fun i => (Formula.mul (Formula.var 0).thetaDot
      (Formula.var (xiIndex i)) : Formula 10).value (profilePack η ξ t y)) = deriv θ t • ξ := by
    ext i
    fin_cases i <;> simp [value, value_thetaDot, profilePack_eq, xiIndex]
  have hcross := value_crossF (fun i => (Formula.mul (Formula.var 0).thetaDot (Formula.var (xiIndex i)) : Formula 10))
    (fun i => (Formula.var (spIndex i) : Formula 10).sub (Formula.mul (Formula.var 0).theta (Formula.var (etaIndex i))))
    (profilePack η ξ t y)
  rw [hy, hv] at hcross
  ext i
  change (zeta _).value _ * ((1/2:ℚ) * (crossF _ _ i).value _) = _
  rw [value_zeta, hy]
  have hc := congrArg (fun v : Space => v i) hcross
  dsimp at hc
  rw [hc]
  norm_num [smul_apply, smul_eq_mul]

def curlJetBound (k : ℕ) : ℚ := ∑ i : Fin 3, (scaledFormula i).jetBound 3 k

lemma curlJetBound_nonneg (k : ℕ) : 0 ≤ curlJetBound k :=
  Finset.sum_nonneg (fun _ _ => jetBound_nonneg _ _ _)

lemma norm_jet_affine_le {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a : Formula 10) (L : E →L[ℝ] (Fin 10 → ℝ)) (hL : ‖L‖ ≤ 1)
    (b : Fin 10 → ℝ) (k : ℕ) (x : E) :
    ‖iteratedFDeriv ℝ k (fun y => a.value (L y+b)) x‖ ≤
      ‖iteratedFDeriv ℝ k a.value (L x+b)‖ := by
  change ‖iteratedFDeriv ℝ k ((fun z => a.value (z+b)) ∘ L) x‖ ≤ _
  have hsm : ContDiff ℝ (⊤ : ℕ∞) (fun z => a.value (z+b)) :=
    a.contDiff.comp (contDiff_id.add contDiff_const)
  rw [L.iteratedFDeriv_comp_right hsm _ (finite_order k),
    iteratedFDeriv_comp_add_right]
  have hb := (iteratedFDeriv ℝ k a.value (L x+b)).norm_compContinuousLinearMap_le (fun _ : Fin k => L)
  simp only [Finset.prod_const, Finset.card_univ, Fintype.card_fin] at hb
  exact hb.trans (by
    simpa using mul_le_mul_of_nonneg_left
      (pow_le_one₀ (norm_nonneg L) hL : ‖L‖ ^ k ≤ 1) (norm_nonneg (iteratedFDeriv ℝ k a.value (L x+b))))

lemma curlJetBound_spec (k : ℕ) (η ξ : Space) (hη : ‖η‖ ≤ 2) (hξ : ‖ξ‖ ≤ 2) (p : ℝ × Space) :
    ‖iteratedFDeriv ℝ k (Function.uncurry (scaledCurl η ξ)) p‖ ≤ (curlJetBound k : ℝ) := by
  by_cases hp : p ∈ Icc (0:ℝ) 1 ×ˢ Metric.closedBall (0:Space) 3
  · have hx : ∀ i, |profilePack η ξ p.1 p.2 i| ≤ |((3:ℚ):ℝ)| := by
      have ht : |p.1| ≤ 3 := by rw [abs_of_nonneg hp.1.1]; linarith [hp.1.2]
      have hy : ‖p.2‖ ≤ 3 := by simpa using hp.2
      have hi (v : Space) (hv : ‖v‖ ≤ 3) (i : Fin 3) : |v i| ≤ 3 := (PiLp.norm_apply_le v i).trans hv
      intro i
      fin_cases i <;> norm_num [profilePack_eq]
      · exact ht
      · exact hi _ hy 0
      · exact hi _ hy 1
      · exact hi _ hy 2
      · exact hi _ (hη.trans (by norm_num)) 0
      · exact hi _ (hη.trans (by norm_num)) 1
      · exact hi _ (hη.trans (by norm_num)) 2
      · exact hi _ (hξ.trans (by norm_num)) 0
      · exact hi _ (hξ.trans (by norm_num)) 1
      · exact hi _ (hξ.trans (by norm_num)) 2
    have he : Function.uncurry (scaledCurl η ξ) = fun q : ℝ × Space => ∑ i : Fin 3,
        (scaledFormula i).value (profilePack η ξ q.1 q.2) • basis i := by
      funext q
      change scaledCurl η ξ q.1 q.2 = _
      rw [← scaledFormula_value]
      ext j
      fin_cases j <;> simp [profileField, basis, Fin.sum_univ_three]
    rw [he]
    apply (jet_sum_le _ _ (fun i _ => ((scaledFormula i).contDiff.comp
      (profileLinear.contDiff.add contDiff_const)).smul contDiff_const) k p).trans
    rw [curlJetBound, Rat.cast_sum]
    apply Finset.sum_le_sum
    intro i _
    have hb : ‖basis i‖ = 1 := by simp [basis]
    apply (jet_smul_const_le ((scaledFormula i).contDiff.comp
      (profileLinear.contDiff.add contDiff_const)) (basis i) k p).trans
    rw [hb, one_mul]
    exact (norm_jet_affine_le (scaledFormula i) profileLinear profileLinear_norm _ _ _).trans
      (norm_jet_le 3 k (scaledFormula i) _ hx)
  · have hz : iteratedFDeriv ℝ k (Function.uncurry (scaledCurl η ξ)) p = 0 :=
      image_eq_zero_of_notMem_tsupport (fun h => hp (scaledCurl_tsupport_subset η ξ hη
        (tsupport_iteratedFDeriv_subset k h)))
    rw [hz, norm_zero]
    exact_mod_cast curlJetBound_nonneg k
end RapidForcing.EffectiveProfile.Formula

end

end OAI