import OAI.Geometry.Relativity.CKS.TailDifferentiation
import OAI.Geometry.Relativity.CKS.TailSymbols

namespace OAI

noncomputable section
namespace CKSADM
noncomputable section
open Set Filter Finset CKSSphericalHarmonics CKSInducedSphere CKSSphericalChart
open scoped Topology ContDiff

def angularPower (c : E → ℝ) (d : ℝ) (x : E) : ℝ := ‖x‖^(-d)*c (unitVector x)

def angularNext (c : E → ℝ) (d : ℝ) (j : Ix) (n : E) : ℝ :=
  (-d*n j)*c n + ∑ i : Ix, ((if i=j then 1 else 0)-n i*n j)*pd i c n

lemma angularNext_smooth {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) (j : Ix) :
    ContDiffOn ℝ ∞ (angularNext c d j) U := by
  apply ContDiffOn.add
  · exact (contDiffOn_const.mul (coordinate_smooth j)).mul hc
  · apply ContDiffOn.sum
    intro i hi
    exact (contDiffOn_const.sub ((coordinate_smooth i).mul (coordinate_smooth j))).mul
      (partial_smooth hc i)

lemma angularPower_regular {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) :
    TailRegular (angularPower c d) := by
  filter_upwards [eventually_norm_gt 0] with x hx
  have hn : x ≠ 0 := norm_pos_iff.mp hx
  have hh : ContDiffOn ℝ ∞ (fun z : ℝ × E => c z.2) heatDomain :=
    hc.comp contDiffOn_snd (fun z hz => hz)
  exact radialHeat_smooth (F := fun _ y => c y) hh 0 0 d hn

lemma angularPower_decay {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) :
    Decay d (angularPower c d) := by
  let cr := smoothRestriction c hc
  refine ⟨‖cr‖,norm_nonneg _,?_⟩
  filter_upwards [eventually_norm_gt 0] with x hx
  have hn := unitVector_norm (norm_pos_iff.mp hx)
  let s : Sphere := ⟨unitVector x,by simpa [Metric.mem_sphere,dist_zero_right] using hn⟩
  have hh : |c (unitVector x)| ≤ ‖cr‖ := cr.norm_coe_le_norm s
  rw [angularPower,abs_mul,abs_of_nonneg (Real.rpow_nonneg (norm_nonneg _) _)]
  exact (mul_le_mul_of_nonneg_left hh (Real.rpow_nonneg (norm_nonneg _) _)).trans_eq (mul_comm _ _)

lemma pd_angularPower {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) {x : E} (hx : x ≠ 0) (j : Ix) :
    pd j (angularPower c d) x = angularPower (angularNext c d j) (d+1) x := by
  have hh : ContDiffOn ℝ ∞ (fun z : ℝ × E => c z.2) heatDomain :=
    hc.comp contDiffOn_snd (fun z hz => hz)
  have he := pd_radialHeat (F := fun _ y => c y) hh 0 0 d hx j
  have heq : radialHeat (fun _ y => c y) 0 0 d = angularPower c d := rfl
  rw [heq] at he
  simpa only [radialHeat,radialNext,zero_mul,zero_add,add_zero,angularPower,angularNext] using he

theorem angularPower_symbol {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) :
    Symbol d (angularPower c d) := by
  refine ⟨angularPower_regular hc d,?_⟩
  intro n
  induction n generalizing c d with
  | zero => exact angularPower_decay hc d
  | succ n ih =>
    refine ⟨angularPower_decay hc d,?_⟩
    intro j
    apply (ih (angularNext_smooth hc d j) (d+1)).congr
    filter_upwards [eventually_norm_gt 0] with x hx
    exact (pd_angularPower hc d (norm_pos_iff.mp hx) j).symm

lemma norm_power_symbol (d : ℝ) : Symbol d (fun x : E => ‖x‖^(-d)) := by
  have hh := angularPower_symbol (c := fun _ => 1) contDiffOn_const d
  convert hh using 1
  funext x
  simp [angularPower]

lemma normal_symbol (i : Ix) : Symbol 0 (fun x : E => normal x i) := by
  have hh := angularPower_symbol (coordinate_smooth i) 0
  convert hh using 1
  funext x
  simp [angularPower,unitVector_component]

lemma SymbolN.word {F : E → ℝ} {d : ℝ} (hF : Symbol d F) (w : List Ix) :
    Decay (d+w.length) (cartWord w F) := by
  induction w generalizing F d with
  | nil =>
    simp only [cartWord,List.length_nil,Nat.cast_zero,add_zero]
    exact hF.2 0
  | cons j w ih =>
    have hh := ih (hF.pd j)
    convert hh using 1 <;> simp only [cartWord,List.length_cons,Nat.cast_add,Nat.cast_one]
    ring

lemma symbol_of_words {F : E → ℝ} {d : ℝ} (hr : TailRegular F)
    (hw : ∀ w : List Ix, Decay (d+w.length) (cartWord w F)) : Symbol d F := by
  refine ⟨hr,?_⟩
  intro n
  induction n generalizing F d with
  | zero =>
    change Decay d F
    simpa only [cartWord,List.length_nil,Nat.cast_zero,add_zero] using hw []
  | succ n ih =>
    refine ⟨?_,?_⟩
    · simpa only [cartWord,List.length_nil,Nat.cast_zero,add_zero] using hw []
    · intro j
      apply ih (hr.pd j)
      intro w
      convert hw (j::w) using 1 <;> simp only [cartWord,List.length_cons,Nat.cast_add,Nat.cast_one]
      ring

end
end CKSADM

end

end OAI