import OAI.Geometry.Relativity.CKS.BoostDivergence

namespace OAI

noncomputable section
namespace CKSLorentz
noncomputable section
open scoped RealInnerProductSpace ContDiff Topology
open Set

def normalizeAmbient (x : E) : E := ‖x‖⁻¹ • x

def weightedPullback (p : E) (t : ℝ) (F : E → ℝ) (x : E) : ℝ :=
  (flowD p t x)⁻¹ ^2 * F (flowPhi p t x)

def normalizedPullback (p : E) (F : E → ℝ) (z : ℝ × E) : ℝ :=
  weightedPullback p z.1 F (normalizeAmbient z.2)

lemma boostField_tangent (p : E) (n : Sphere) : inner ℝ (n:E) (boostField p n) = 0 := by
  simp [boostField, inner_sub_right, inner_smul_right, real_inner_comm]

lemma normalizeAmbient_smooth {x : E} (hx : x ≠ 0) : ContDiffAt ℝ ∞ normalizeAmbient x :=
  ((contDiffAt_norm ℝ hx).inv (norm_ne_zero_iff.mpr hx)).smul contDiffAt_id

@[simp] lemma normalizeAmbient_sphere (n : Sphere) : normalizeAmbient n = n := by
  simp [normalizeAmbient]

lemma norm_derivative_sphere (n : Sphere) : HasFDerivAt (norm : E → ℝ) (innerSL ℝ (n:E)) n := by
  have h := (Real.hasDerivAt_sqrt (show ‖(n:E)‖^2 ≠ 0 by rw [sphere_norm]; norm_num)).comp_hasFDerivAt (n:E)
    (hasStrictFDerivAt_norm_sq (n:E)).hasFDerivAt
  convert! h using 1
  · funext x
    exact (Real.sqrt_sq (norm_nonneg x)).symm
  · ext x
    simp

lemma normalizeAmbient_fderiv_tangent (n : Sphere) (Y : E) (hY : inner ℝ (n:E) Y = 0) :
    fderiv ℝ normalizeAmbient n Y = Y := by
  have hi := (hasDerivAt_inv (show ‖(n:E)‖ ≠ 0 by rw [sphere_norm]; norm_num)).comp_hasFDerivAt (n:E)
    (norm_derivative_sphere n)
  have h := hi.smul (hasFDerivAt_id (n:E))
  change HasFDerivAt normalizeAmbient _ n at h
  rw [h.fderiv]
  simp [ContinuousLinearMap.smulRight_apply, hY]

lemma flowPhi_smooth_at (p : E) (t : ℝ) (n : Sphere) :
    ContDiffAt ℝ ∞ (fun z : ℝ × E => flowPhi p z.1 z.2) (t,(n:E)) :=
  (((flowD_smooth p).contDiffAt).inv (flowD_pos p t n).ne').smul (flowS_smooth p).contDiffAt

lemma flowPhi_nonzero (p : E) (t : ℝ) (n : Sphere) : flowPhi p t n ≠ 0 := by
  apply norm_ne_zero_iff.mp
  rw [flowPhi_norm]; norm_num

lemma flowPhi_fderiv (p : E) (t : ℝ) (n : Sphere) (Y : E) :
    fderiv ℝ (flowPhi p t) n Y =
      (flowD p t n)⁻¹ • flowSLinear p t Y -
        (flowDLinear p t Y/(flowD p t n)^2) • flowS p t n := by
  have hi := (hasDerivAt_inv (flowD_pos p t n).ne').comp_hasFDerivAt (n:E) (flowD_fderivative p t n)
  have h := hi.smul (flowS_fderivative p t n)
  change HasFDerivAt (flowPhi p t) _ n at h
  rw [h.fderiv]
  simp only [add_apply, smul_apply,
    ContinuousLinearMap.smulRight_apply, smul_eq_mul, Function.comp_apply]
  module

lemma flowPhi_derivative (p : E) (t : ℝ) (n : Sphere) :
    HasDerivAt (fun t => flowPhi p t n)
      ((flowD p t n)⁻¹ • ((1+t/flowEnergy p t*inner ℝ p (n:E)) • p) -
        ((t*‖p‖^2/flowEnergy p t+inner ℝ p (n:E))/(flowD p t n)^2) • flowS p t n) t := by
  convert! ((flowD_derivative p t n).inv (flowD_pos p t n).ne').smul (flowS_derivative p t n) using 1
  module

lemma flowPhi_transport (p : E) (t : ℝ) (n : Sphere) :
    HasDerivAt (fun t => flowPhi p t n)
      ((flowEnergy p t)⁻¹ • fderiv ℝ (flowPhi p t) n (boostField p n)) t := by
  convert! flowPhi_derivative p t n using 1
  rw [flowPhi_fderiv]
  have hS := flowS_transport p t (n:E)
  have hD := flowD_transport p t (n:E)
  have hS' : flowSLinear p t (boostField p n) =
      flowEnergy p t • ((1+t/flowEnergy p t*inner ℝ p (n:E)) • p) - inner ℝ p (n:E) • flowS p t n :=
    eq_sub_of_add_eq hS.symm
  have hD' : flowDLinear p t (boostField p n) =
      flowEnergy p t * (t*‖p‖^2/flowEnergy p t+inner ℝ p (n:E)) - inner ℝ p (n:E)*flowD p t n :=
    eq_sub_of_add_eq hD.symm
  rw [hS', hD']
  have hE := (flowEnergy_pos p t).ne'
  have hden := (flowD_pos p t n).ne'
  ext i
  simp only [PiLp.sub_apply, PiLp.smul_apply, smul_eq_mul]
  field_simp [hE, hden]
  ring

lemma weightedPullback_smooth_at (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) (t : ℝ) (n : Sphere) :
    ContDiffAt ℝ ∞ (fun z : ℝ × E => weightedPullback p z.1 F z.2) (t,(n:E)) := by
  have hc := hF.contDiffAt (CKSSphericalHarmonics.puncturedSpace.isOpen.mem_nhds (flowPhi_nonzero p t n))
  have hd : ContDiffAt ℝ ∞ (fun z : ℝ × E => (flowD p z.1 z.2)⁻¹ ^2) (t,(n:E)) :=
    ((flowD_smooth p).contDiffAt.inv (flowD_pos p t n).ne').pow 2
  exact hd.mul (hc.comp (t,(n:E)) (flowPhi_smooth_at p t n))

lemma weightedPullback_spatial_derivative (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) (t : ℝ) (n : Sphere) (Y : E) :
    fderiv ℝ (weightedPullback p t F) n Y =
      (2*(flowD p t n)⁻¹*(-flowDLinear p t Y/(flowD p t n)^2))*F (flowPhi p t n) +
        (flowD p t n)⁻¹ ^2 * fderiv ℝ F (flowPhi p t n) (fderiv ℝ (flowPhi p t) n Y) := by
  have hphi : DifferentiableAt ℝ (flowPhi p t) (n:E) := by
    convert! ((flowPhi_smooth_at p t n).comp (n:E) (contDiffAt_const.prodMk contDiffAt_id)).differentiableAt (by simp)
  have hf := (hF.contDiffAt (CKSSphericalHarmonics.puncturedSpace.isOpen.mem_nhds (flowPhi_nonzero p t n))).differentiableAt (by simp)
  have ha := ((hasDerivAt_inv (flowD_pos p t n).ne').pow 2).comp_hasFDerivAt (n:E) (flowD_fderivative p t n)
  have h := ha.mul (hf.hasFDerivAt.comp (n:E) hphi.hasFDerivAt)
  change HasFDerivAt (weightedPullback p t F) _ n at h
  rw [h.fderiv]
  simp only [add_apply, smul_apply, ContinuousLinearMap.comp_apply, smul_eq_mul,
    Function.comp_apply, Nat.cast_ofNat, Nat.reduceSub, pow_one, Pi.pow_apply]
  ring

lemma weightedPullback_transport (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) (t : ℝ) (n : Sphere) :
    HasDerivAt (fun t => weightedPullback p t F n)
      ((flowEnergy p t)⁻¹ * (fderiv ℝ (weightedPullback p t F) n (boostField p n) -
        2*inner ℝ p (n:E)*weightedPullback p t F n)) t := by
  have hf := (hF.contDiffAt (CKSSphericalHarmonics.puncturedSpace.isOpen.mem_nhds (flowPhi_nonzero p t n))).differentiableAt (by simp)
  have h := (((flowD_derivative p t n).inv (flowD_pos p t n).ne').pow 2).mul
    (hf.hasFDerivAt.comp_hasDerivAt t (flowPhi_transport p t n))
  convert! h using 1
  rw [weightedPullback_spatial_derivative p hF]
  simp only [map_smul, smul_eq_mul, weightedPullback, Nat.cast_ofNat, Nat.reduceSub, pow_one, Pi.pow_apply, Pi.inv_apply, Function.comp_apply]
  have hD := flowD_transport p t (n:E)
  have hD' : flowDLinear p t (boostField p n) =
      flowEnergy p t * (t*‖p‖^2/flowEnergy p t+inner ℝ p (n:E)) - inner ℝ p (n:E)*flowD p t n :=
    eq_sub_of_add_eq hD.symm
  rw [hD']
  field_simp [(flowEnergy_pos p t).ne', (flowD_pos p t n).ne']
  ring

lemma normalizedPullback_smooth (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) :
    ContDiffOn ℝ ∞ (normalizedPullback p F) (Set.univ ×ˢ (CKSSphericalHarmonics.puncturedSpace : Set E)) := by
  intro z hz
  let n : Sphere := CKSSphericalHarmonics.normalizeSphere ⟨z.2,hz.2⟩
  have h := weightedPullback_smooth_at p hF z.1 n
  exact (h.comp z (contDiffAt_fst.prodMk ((normalizeAmbient_smooth hz.2).comp z contDiffAt_snd))).contDiffWithinAt

lemma normalizedPullback_spatial (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) (t : ℝ) :
    ContDiffOn ℝ ∞ (fun x => normalizedPullback p F (t,x)) CKSSphericalHarmonics.puncturedSpace :=
  (normalizedPullback_smooth p hF).comp (contDiffOn_const.prodMk contDiffOn_id) (fun _ hx => ⟨Set.mem_univ _,hx⟩)

@[simp] lemma normalizedPullback_sphere (p : E) (F : E → ℝ) (t : ℝ) (n : Sphere) :
    normalizedPullback p F (t,(n:E)) = weightedPullback p t F n := by
  simp [normalizedPullback]

lemma normalizedPullback_fderiv_tangent (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) (t : ℝ) (n : Sphere) :
    fderiv ℝ (fun x => normalizedPullback p F (t,x)) n (boostField p n) =
      fderiv ℝ (weightedPullback p t F) n (boostField p n) := by
  have hf := ((weightedPullback_smooth_at p hF t n).comp (n:E) (contDiffAt_const.prodMk contDiffAt_id)).differentiableAt (by simp)
  have hn := (normalizeAmbient_smooth (CKSSphericalHarmonics.sphere_ne_zero n)).differentiableAt (by simp)
  change fderiv ℝ ((weightedPullback p t F) ∘ normalizeAmbient) n _ = _
  have hf' : DifferentiableAt ℝ (weightedPullback p t F) (normalizeAmbient n) := by
    rw [normalizeAmbient_sphere]
    convert! hf
  rw [fderiv_comp (n:E) hf' hn, ContinuousLinearMap.comp_apply, normalizeAmbient_sphere,
    normalizeAmbient_fderiv_tangent n _ (boostField_tangent p n)]

lemma normalizedPullback_transport (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F CKSSphericalHarmonics.puncturedSpace) (t : ℝ) (n : Sphere) :
    HasDerivAt (fun t => normalizedPullback p F (t,(n:E)))
      ((flowEnergy p t)⁻¹ * (fderiv ℝ (fun x => normalizedPullback p F (t,x)) n (boostField p n) -
        2*inner ℝ p (n:E)*normalizedPullback p F (t,(n:E)))) t := by
  simp only [normalizedPullback_sphere, normalizedPullback_fderiv_tangent p hF]
  exact weightedPullback_transport p hF t n

end
end CKSLorentz

end

end OAI