import OAI.Geometry.IsometricImmersion.Assembly.SupportedPerturbations
import OAI.Geometry.IsometricImmersion.Coordinates.AffinePullback
import Mathlib.Analysis.SpecialFunctions.SmoothTransition
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
import Mathlib.MeasureTheory.Integral.Bochner.Set

namespace OAI

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

namespace SmoothLocal.Pulse
open SmoothLocal.Geometry SmoothLocal.Perturbation

def axisBump (a t : ℝ) : ℝ := expNegInvGlue (a ^ 2 - t ^ 2)

theorem axisBump_contDiff (a : ℝ) : ContDiff ℝ ∞ (axisBump a) :=
  expNegInvGlue.contDiff.comp (contDiff_const.sub (contDiff_id.pow 2))

theorem axisBump_nonneg (a t : ℝ) : 0 ≤ axisBump a t := expNegInvGlue.nonneg _

theorem axisBump_pos {a t : ℝ} (ha : 0 < a) (ht : |t| < a) : 0 < axisBump a t := by
  have hs : |t| ^ 2 < a ^ 2 := (sq_lt_sq₀ (abs_nonneg t) ha.le).mpr ht
  exact expNegInvGlue.pos_of_pos (sub_pos.mpr (by simpa only [sq_abs] using hs))

theorem axisBump_zero {a t : ℝ} (ha : 0 ≤ a) (ht : a ≤ |t|) : axisBump a t = 0 := by
  have hs : a ^ 2 ≤ |t| ^ 2 := (sq_le_sq₀ ha (abs_nonneg t)).mpr ht
  exact expNegInvGlue.zero_of_nonpos (sub_nonpos.mpr (by simpa only [sq_abs] using hs))

theorem axisBump_support_bound {a t : ℝ} (ha : 0 < a) (ht : axisBump a t ≠ 0) :
    |t| < a := by
  by_contra h
  exact ht (axisBump_zero ha.le (le_of_not_gt h))

theorem axisBump_tsupport_subset {a : ℝ} (ha : 0 < a) :
    tsupport (axisBump a) ⊆ Icc (-a) a := by
  apply closure_minimal _ isClosed_Icc
  intro t ht
  exact ⟨(abs_lt.mp (axisBump_support_bound ha ht)).1.le,
    (abs_lt.mp (axisBump_support_bound ha ht)).2.le⟩

theorem axisBump_hasCompactSupport {a : ℝ} (ha : 0 < a) : HasCompactSupport (axisBump a) :=
  isCompact_Icc.of_isClosed_subset (isClosed_tsupport _) (axisBump_tsupport_subset ha)

theorem axisBump_pos_zero {a : ℝ} (ha : 0 < a) : 0 < axisBump a 0 :=
  axisBump_pos ha (by simpa using ha)

theorem axisBump_integral_pos {a : ℝ} (ha : 0 < a) : 0 < ∫ t : ℝ, axisBump a t :=
  (axisBump_contDiff a).continuous.integral_pos_of_hasCompactSupport_nonneg_nonzero
    (axisBump_hasCompactSupport ha) (axisBump_nonneg a) (axisBump_pos_zero ha).ne'

def spatialCutoff (L r : ℝ) : ℝ → ℝ := axisBump (L * r / 16)

def temporalCutoff : ℝ → ℝ := axisBump (1 / 2)

theorem temporalCutoff_integral_pos : 0 < ∫ t : ℝ, temporalCutoff t :=
  axisBump_integral_pos (by norm_num)

theorem spatialCutoff_tsupport_inside {L r : ℝ} (hL : 0 < L) (hr : 0 < r) :
    tsupport (spatialCutoff L r) ⊆ Ioo (-(L * r / 8)) (L * r / 8) := by
  intro t ht
  have h := axisBump_tsupport_subset (div_pos (mul_pos hL hr) (by norm_num)) ht
  constructor <;> nlinarith [mul_pos hL hr, h.1, h.2]

theorem temporalCutoff_tsupport_inside : tsupport temporalCutoff ⊆ Ioo (-1 : ℝ) 1 := by
  intro t ht
  have h := axisBump_tsupport_subset (by norm_num : (0 : ℝ) < 1 / 2) ht
  constructor <;> linarith [h.1, h.2]

def shearCoordinates (q0 : ℝ) (p : Coord) : Coord := ![p 0, p 1 + q0 * p 0]
def inverseShearCoordinates (q0 : ℝ) (p : Coord) : Coord := ![p 0, p 1 - q0 * p 0]
def inverseShearMatrix (q0 : ℝ) : Matrix (Fin 2) (Fin 2) ℝ := !![1, 0; -q0, 1]
def thetaCovector (q0 : ℝ) : Coord := ![q0, 1]

theorem shearCoordinates_contDiff (q0 : ℝ) : ContDiff ℝ ∞ (shearCoordinates q0) := by
  apply contDiff_pi.mpr
  intro i
  fin_cases i
  · change ContDiff ℝ ∞ (fun x : Coord => x 0)
    fun_prop
  · change ContDiff ℝ ∞ (fun x : Coord => x 1 + q0 * x 0)
    fun_prop

theorem inverseShearCoordinates_contDiff (q0 : ℝ) : ContDiff ℝ ∞ (inverseShearCoordinates q0) := by
  apply contDiff_pi.mpr
  intro i
  fin_cases i
  · change ContDiff ℝ ∞ (fun x : Coord => x 0)
    fun_prop
  · change ContDiff ℝ ∞ (fun x : Coord => x 1 - q0 * x 0)
    fun_prop

theorem shear_inverse (q0 : ℝ) (p : Coord) :
    shearCoordinates q0 (inverseShearCoordinates q0 p) = p := by
  ext i
  fin_cases i <;> simp [shearCoordinates, inverseShearCoordinates]

theorem inverse_shear (q0 : ℝ) (p : Coord) :
    inverseShearCoordinates q0 (shearCoordinates q0 p) = p := by
  ext i
  fin_cases i <;> simp [shearCoordinates, inverseShearCoordinates]

theorem inverseShearCoordinates_eq_affine (q0 : ℝ) :
    inverseShearCoordinates q0 = affineCoordinates 0 (inverseShearMatrix q0) := by
  ext p i
  fin_cases i <;> simp [inverseShearCoordinates, inverseShearMatrix,
    affineCoordinates, dotProduct, Fin.sum_univ_two]
  ring

def pulseScalar (a : ℝ) (N : ℕ) (delta tau : ℝ) (p : Coord) : ℝ :=
  (1 / tau ^ N) * axisBump a (p 0) * temporalCutoff (tau * p 1 / delta) *
    Real.cos (tau * p 0)

def pulseTensor (q0 a : ℝ) (N : ℕ) (delta tau : ℝ) : MetricField := fun p i j =>
  pulseScalar a N delta tau (shearCoordinates q0 p) * thetaCovector q0 i * thetaCovector q0 j

def testMetric (gStar : MetricField) (q0 a : ℝ) (N : ℕ) (delta tau : ℝ) : MetricField :=
  gStar + pulseTensor q0 a N delta tau

theorem pulseScalar_contDiff (a : ℝ) (N : ℕ) (delta tau : ℝ) :
    ContDiff ℝ ∞ (pulseScalar a N delta tau) := by
  unfold pulseScalar temporalCutoff
  exact ((contDiff_const.mul ((axisBump_contDiff a).comp (contDiff_apply ℝ ℝ 0))).mul
    ((axisBump_contDiff (1 / 2)).comp
      ((contDiff_const.mul (contDiff_apply ℝ ℝ 1)).div_const delta))).mul
    (Real.contDiff_cos.comp (contDiff_const.mul (contDiff_apply ℝ ℝ 0)))

theorem pulseTensor_contDiff (q0 a : ℝ) (N : ℕ) (delta tau : ℝ) :
    ContDiff ℝ ∞ (pulseTensor q0 a N delta tau) := by
  apply contDiff_pi.mpr
  intro i
  apply contDiff_pi.mpr
  intro j
  exact (((pulseScalar_contDiff a N delta tau).comp (shearCoordinates_contDiff q0)).mul
    contDiff_const).mul contDiff_const

theorem pulseTensor_symmetric (q0 a : ℝ) (N : ℕ) (delta tau : ℝ) (p : Coord) (i j : Fin 2) :
    pulseTensor q0 a N delta tau p i j = pulseTensor q0 a N delta tau p j i := by
  unfold pulseTensor
  ring

def pulseLocalBox (a delta tau : ℝ) : Set Coord :=
  Icc (![-a, -(delta / (2 * tau))]) (![a, delta / (2 * tau)])

def pulseOriginalBox (q0 a delta tau : ℝ) : Set Coord :=
  inverseShearCoordinates q0 '' pulseLocalBox a delta tau

theorem pulseLocalBox_isCompact (a delta tau : ℝ) : IsCompact (pulseLocalBox a delta tau) :=
  isCompact_Icc

theorem pulseOriginalBox_isCompact (q0 a delta tau : ℝ) :
    IsCompact (pulseOriginalBox q0 a delta tau) :=
  (pulseLocalBox_isCompact a delta tau).image (inverseShearCoordinates_contDiff q0).continuous

theorem pulseScalar_support_bound {a delta tau : ℝ} (ha : 0 < a)
    (hd : 0 < delta) (ht : 0 < tau) (N : ℕ) {p : Coord}
    (hp : pulseScalar a N delta tau p ≠ 0) : p ∈ pulseLocalBox a delta tau := by
  have hχ : axisBump a (p 0) ≠ 0 := by
    intro h
    apply hp
    simp only [pulseScalar, h, mul_zero, zero_mul]
  have hφ : temporalCutoff (tau * p 1 / delta) ≠ 0 := by
    intro h
    apply hp
    simp only [pulseScalar, h, mul_zero, zero_mul]
  have hx := abs_lt.mp (axisBump_support_bound ha hχ)
  have hy := axisBump_support_bound (by norm_num : (0 : ℝ) < 1 / 2) hφ
  have hy' : |p 1| < delta / (2 * tau) := by
    rw [abs_div, abs_mul, abs_of_pos ht, abs_of_pos hd] at hy
    apply (lt_div_iff₀ (mul_pos (by norm_num) ht)).mpr
    have hh := (div_lt_iff₀ hd).mp hy
    nlinarith
  constructor <;> intro i <;> fin_cases i
  · exact hx.1.le
  · exact (abs_lt.mp hy').1.le
  · exact hx.2.le
  · exact (abs_lt.mp hy').2.le

theorem pulseTensor_tsupport_subset {q0 a delta tau : ℝ}
    (ha : 0 < a) (hd : 0 < delta) (ht : 0 < tau) (N : ℕ) :
    tsupport (pulseTensor q0 a N delta tau) ⊆ pulseOriginalBox q0 a delta tau := by
  apply closure_minimal _ (pulseOriginalBox_isCompact q0 a delta tau).isClosed
  intro p hp
  have hs : pulseScalar a N delta tau (shearCoordinates q0 p) ≠ 0 := by
    intro h
    apply hp
    ext i j
    simp only [pulseTensor, h, zero_mul, Matrix.zero_apply]
  exact ⟨shearCoordinates q0 p, pulseScalar_support_bound ha hd ht N hs, inverse_shear q0 p⟩

theorem pulseTensor_hasCompactSupport {q0 a delta tau : ℝ}
    (ha : 0 < a) (hd : 0 < delta) (ht : 0 < tau) (N : ℕ) :
    HasCompactSupport (pulseTensor q0 a N delta tau) :=
  (pulseOriginalBox_isCompact q0 a delta tau).of_isClosed_subset (isClosed_tsupport _)
    (pulseTensor_tsupport_subset ha hd ht N)

theorem pulseOriginalBox_subset_patchBox {q0 a delta tau : ℝ}
    (ha : a ≤ 1 / 10) (hy : delta / (2 * tau) + |q0| * a ≤ 1 / 10) :
    pulseOriginalBox q0 a delta tau ⊆ patchBox := by
  rintro p ⟨u, hu, rfl⟩
  have hu0 : |u 0| ≤ a := abs_le.mpr ⟨hu.1 0, hu.2 0⟩
  have hu1 : |u 1| ≤ delta / (2 * tau) := abs_le.mpr ⟨hu.1 1, hu.2 1⟩
  have h0 : |inverseShearCoordinates q0 u 0| ≤ 1 / 10 := hu0.trans ha
  have h1 : |inverseShearCoordinates q0 u 1| ≤ 1 / 10 := by
    change |u 1 - q0 * u 0| ≤ _
    calc
      _ ≤ |u 1| + |q0 * u 0| := abs_sub _ _
      _ = |u 1| + |q0| * |u 0| := by rw [abs_mul]
      _ ≤ delta / (2 * tau) + |q0| * a :=
        add_le_add hu1 (mul_le_mul_of_nonneg_left hu0 (abs_nonneg q0))
      _ ≤ _ := hy
  constructor <;> intro i <;> fin_cases i
  · exact (abs_le.mp h0).1
  · exact (abs_le.mp h1).1
  · exact (abs_le.mp h0).2
  · exact (abs_le.mp h1).2

def supportedPulse (q0 a : ℝ) (N : ℕ) (delta tau : ℝ)
    (ha : 0 < a) (hd : 0 < delta) (ht : 0 < tau)
    (hax : a ≤ 1 / 10) (hay : delta / (2 * tau) + |q0| * a ≤ 1 / 10) :
    SymmetricPerturbation := by
  let f : SupportedTensor := ⟨pulseTensor q0 a N delta tau,
    pulseTensor_contDiff q0 a N delta tau, by
      intro p hp
      apply image_eq_zero_of_notMem_tsupport
      exact fun h => hp (pulseOriginalBox_subset_patchBox hax hay
        (pulseTensor_tsupport_subset ha hd ht N h))⟩
  exact ⟨f, pulseTensor_symmetric q0 a N delta tau⟩

theorem pulseTensor_inverseShear (q0 a : ℝ) (N : ℕ) (delta tau : ℝ) (p : Coord) :
    affinePullbackMetric (pulseTensor q0 a N delta tau) 0 (inverseShearMatrix q0) p =
      !![0, 0; 0, pulseScalar a N delta tau p] := by
  rw [affinePullbackMetric, ← inverseShearCoordinates_eq_affine]
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [pulseTensor, shear_inverse, inverseShearMatrix, thetaCovector,
      Matrix.mul_apply, Fin.sum_univ_two] <;> ring

theorem testMetric_inverseShear (gStar : MetricField) (q0 a : ℝ) (N : ℕ)
    (delta tau : ℝ) (p : Coord) :
    affinePullbackMetric (testMetric gStar q0 a N delta tau) 0 (inverseShearMatrix q0) p =
      affinePullbackMetric gStar 0 (inverseShearMatrix q0) p +
        !![0, 0; 0, pulseScalar a N delta tau p] := by
  rw [← pulseTensor_inverseShear q0 a N delta tau p]
  simp only [affinePullbackMetric, testMetric, Pi.add_apply, mul_add, add_mul]

end SmoothLocal.Pulse

end

end OAI