import OAI.MathematicalPhysics.RapidForcing.Flow

namespace OAI

open scoped BigOperators ENNReal Topology NNReal
open Set MeasureTheory
namespace RapidForcing

instance compactSpace_K : CompactSpace K := isCompact_iff_compactSpace.mp K_compact

section CompactLp
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]

noncomputable def boxExtension (g : C(K, E)) : Space → E :=
  Function.extend Subtype.val g (fun _ => 0)

omit [NormedSpace ℝ E] in
lemma boxExtension_mem (g : C(K, E)) {x : Space} (hx : x ∈ K) :
    boxExtension g x = g ⟨x, hx⟩ :=
  Subtype.val_injective.extend_apply _ _ ⟨x, hx⟩

omit [NormedSpace ℝ E] in
lemma boxExtension_notMem (g : C(K, E)) {x : Space} (hx : x ∉ K) :
    boxExtension g x = 0 := by
  apply Function.extend_apply'
  rintro ⟨y, rfl⟩
  exact hx y.property

omit [NormedSpace ℝ E] in
lemma boxExtension_measurable (g : C(K, E)) : StronglyMeasurable (boxExtension g) :=
  (MeasurableEmbedding.subtype_coe K_compact.isClosed.measurableSet).stronglyMeasurable_extend
    g.continuous.stronglyMeasurable stronglyMeasurable_const

omit [NormedSpace ℝ E] in
lemma boxExtension_bound (g : C(K, E)) (x : Space) :
    ‖boxExtension g x‖ ≤ K.indicator (fun _ => ‖g‖) x := by
  by_cases hx : x ∈ K
  · rw [boxExtension_mem g hx, Set.indicator_of_mem hx]
    exact g.norm_coe_le_norm _
  · rw [boxExtension_notMem g hx, Set.indicator_of_notMem hx, norm_zero]

omit [NormedSpace ℝ E] in
lemma boxExtension_memLp (g : C(K, E)) : MemLp (boxExtension g) 2 volume :=
  (memLp_indicator_const 2 K_compact.isClosed.measurableSet ‖g‖
    (Or.inr K_compact.measure_ne_top)).mono' (boxExtension_measurable g).aestronglyMeasurable
      (Filter.Eventually.of_forall (boxExtension_bound g))

noncomputable def boxToL2Linear : C(K, E) →ₗ[ℝ] Lp E 2 (volume : Measure Space) where
  toFun g := (boxExtension_memLp g).toLp (boxExtension g)
  map_add' g h := by
    apply Lp.ext
    filter_upwards [MemLp.coeFn_toLp (boxExtension_memLp (g + h)),
      Lp.coeFn_add ((boxExtension_memLp g).toLp _) ((boxExtension_memLp h).toLp _),
      MemLp.coeFn_toLp (boxExtension_memLp g), MemLp.coeFn_toLp (boxExtension_memLp h)]
      with x hsum hcoe hg hh
    rw [hsum, hcoe, Pi.add_apply, hg, hh]
    by_cases hx : x ∈ K
    · simp only [boxExtension_mem _ hx, ContinuousMap.add_apply]
    · simp only [boxExtension_notMem _ hx, add_zero]
  map_smul' c g := by
    apply Lp.ext
    filter_upwards [MemLp.coeFn_toLp (boxExtension_memLp (c • g)),
      Lp.coeFn_smul c ((boxExtension_memLp g).toLp _),
      MemLp.coeFn_toLp (boxExtension_memLp g)] with x hc hcoe hg
    simp only [RingHom.id_apply]
    rw [hc, hcoe, Pi.smul_apply, hg]
    by_cases hx : x ∈ K
    · simp only [boxExtension_mem _ hx, ContinuousMap.smul_apply]
    · simp only [boxExtension_notMem _ hx, smul_zero]

lemma coe_boxToL2Linear (g : C(K, E)) :
    (boxToL2Linear g : Space → E) =ᵐ[volume] boxExtension g :=
  MemLp.coeFn_toLp (boxExtension_memLp g)

lemma boxToL2Linear_bound (g : C(K, E)) :
    ‖boxToL2Linear g‖ ≤
      ‖indicatorConstLp 2 K_compact.isClosed.measurableSet
        (μ := (volume : Measure Space)) K_compact.measure_ne_top (1 : ℝ)‖ * ‖g‖ := by
  let e : Lp ℝ 2 (volume : Measure Space) :=
    indicatorConstLp 2 K_compact.isClosed.measurableSet K_compact.measure_ne_top 1
  have hbound : ‖boxToL2Linear g‖ ≤ ‖(‖g‖ : ℝ) • e‖ := by
    apply Lp.norm_le_norm_of_ae_le
    filter_upwards [coe_boxToL2Linear g, Lp.coeFn_smul (‖g‖ : ℝ) e,
      (indicatorConstLp_coeFn : (e : Space → ℝ) =ᵐ[volume] K.indicator (fun _ => 1))]
      with x hx hs he
    change e x = _ at he
    rw [hx, hs, Pi.smul_apply, he]
    by_cases hx : x ∈ K
    · simpa [Set.indicator_of_mem hx] using boxExtension_bound g x
    · simp [Set.indicator_of_notMem hx, boxExtension_notMem g hx]
  simpa [norm_smul, Real.norm_eq_abs, abs_of_nonneg (norm_nonneg g), mul_comm, e] using hbound

noncomputable def boxToL2 : C(K, E) →L[ℝ] Lp E 2 (volume : Measure Space) :=
  boxToL2Linear.mkContinuous _ boxToL2Linear_bound

lemma coe_boxToL2 (g : C(K, E)) :
    (boxToL2 g : Space → E) =ᵐ[volume] boxExtension g := coe_boxToL2Linear g

end CompactLp

lemma hasDerivAt_continuousMap {α E : Type} [TopologicalSpace α] [CompactSpace α]
    [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
    {f g : ℝ → C(α, E)} (hg : Continuous g)
    (hfg : ∀ t x, HasDerivAt (fun s => f s x) (g t x) t) (t : ℝ) :
    HasDerivAt f (g t) t := by
  have heq : f = fun t => f 0 + ∫ s in (0 : ℝ)..t, g s := by
    funext t
    ext x
    have hint := (ContinuousMap.evalCLM ℝ x).intervalIntegral_comp_comm (hg.intervalIntegrable (μ := volume) 0 t)
    change f t x = f 0 x + (ContinuousMap.evalCLM ℝ x) (∫ s in (0 : ℝ)..t, g s)
    rw [← hint]
    have h := intervalIntegral.integral_eq_sub_of_hasDerivAt
      (fun s (_hs : s ∈ uIcc (0 : ℝ) t) => hfg s x)
      (((ContinuousMap.evalCLM ℝ x).continuous.comp hg).intervalIntegrable (μ := volume) 0 t)
    change f t x = f 0 x + ∫ s in (0 : ℝ)..t, g s x
    rw [h, add_sub_cancel]
  rw [heq]
  exact (intervalIntegral.integral_hasDerivAt_right (hg.intervalIntegrable (μ := volume) 0 t)
    hg.aestronglyMeasurable.stronglyMeasurableAtFilter hg.continuousAt).const_add _

section L2Regularity
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]

noncomputable def boxCurve (v : Field E) (hv : Continuous (Function.uncurry v)) :
    C(ℝ, C(K, E)) :=
  ContinuousMap.curry ⟨fun p : ℝ × K => v p.1 p.2,
    hv.comp (continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd))⟩

omit [NormedSpace ℝ E] in
@[simp] lemma boxCurve_apply (v : Field E) (hv : Continuous (Function.uncurry v))
    (t : ℝ) (x : K) : boxCurve v hv t x = v t x := rfl

lemma boxToL2_curve_coe {v : Field E} (hv : Continuous (Function.uncurry v))
    (hs : Supported v) {t : ℝ} (ht : 0 ≤ t) :
    (boxToL2 (boxCurve v hv t) : Space → E) =ᵐ[volume] v t := by
  apply (coe_boxToL2 _).trans
  apply Filter.Eventually.of_forall
  intro x
  by_cases hx : x ∈ K
  · rw [boxExtension_mem _ hx, boxCurve_apply]
  · rw [boxExtension_notMem _ hx, hs.zero_off ht hx]

lemma l2Continuous_of_continuous_supported {v : Field E}
    (hv : Continuous (Function.uncurry v)) (hs : Supported v) (T : ℝ) :
    L2ContinuousOn v T := by
  refine ⟨fun t => boxToL2 (boxCurve v hv t),
    (boxToL2.continuous.comp (boxCurve v hv).continuous).continuousOn, ?_⟩
  intro t ht
  exact boxToL2_curve_coe hv hs ht.1

lemma spatialMulti_joint_smooth {v : Field E}
    (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) (α : MultiIndex) :
    ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (spatialMulti α v)) := by
  have h : ∀ (v : Field E), ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v) →
      ∀ i n, ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry ((spatialD i)^[n] v)) := by
    intro v hv i n
    induction n with
    | zero => exact hv
    | succ n ih =>
      rw [Function.iterate_succ_apply']
      exact spatialD_joint_smooth ih i
  exact h _ (h _ (h _ hv 2 (α 2)) 1 (α 1)) 0 (α 0)

end L2Regularity

lemma l2C1_of_smooth_supported {v : Field Space}
    (hv : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry v)) (hs : Supported v) (T : ℝ) :
    L2C1On v T := by
  let g : Field Space := fun t x => deriv (fun s => v s x) t
  have hg : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry g) := ordinaryTimeD_joint_smooth hv
  have hgs : Supported g := by
    rw [supported_iff_zero_off]
    intro t ht x hx
    rw [show g t x = timeD v t x from (timeD_eq_ordinary hv ht x).symm]
    exact hs.timeD.zero_off ht hx
  refine ⟨fun t => boxToL2 (boxCurve v hv.continuous t),
    fun t => boxToL2 (boxCurve g hg.continuous t),
    (boxToL2.continuous.comp (boxCurve v hv.continuous).continuous).continuousOn,
    (boxToL2.continuous.comp (boxCurve g hg.continuous).continuous).continuousOn,
    fun t ht => boxToL2_curve_coe hv.continuous hs ht.1, ?_, ?_⟩
  · intro t ht
    exact (boxToL2_curve_coe hg.continuous hgs ht.1).trans
      (Filter.Eventually.of_forall (fun x => (timeD_eq_ordinary hv ht.1 x).symm))
  · intro t _ht
    have hdiff : HasDerivAt (boxCurve v hv.continuous)
        (boxCurve g hg.continuous t) t := by
      apply hasDerivAt_continuousMap (boxCurve g hg.continuous).continuous
      intro s x
      change HasDerivAt (fun t => v t (x : Space)) (deriv (fun t => v t (x : Space)) s) s
      exact ((hv.comp (contDiff_id.prodMk contDiff_const)).differentiable
        (by simp) s).hasDerivAt
    exact (boxToL2.hasFDerivAt.comp_hasDerivAt t hdiff).hasDerivWithinAt

theorem energyRegularity_of_smooth_supported {u : Field Space} {p : Field ℝ}
    (hu : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry u))
    (hp : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry p))
    (hsu : Supported u) (hsp : Supported p) : EnergyRegularity u p := by
  intro T _hT
  refine ⟨?_, l2C1_of_smooth_supported hu hsu T, ?_⟩
  · intro α _hα
    exact l2Continuous_of_continuous_supported (spatialMulti_joint_smooth hu α).continuous
      (hsu.spatialMulti α) T
  · intro α _hα
    exact l2Continuous_of_continuous_supported (spatialMulti_joint_smooth hp α).continuous
      (hsp.spatialMulti α) T

theorem addressed_energyClass (M : Machine) (w : M.Input) :
    EnergyClass (addressedVelocity M w) (fun _ _ => 0) := by
  refine ⟨energyRegularity_of_smooth_supported (addressedVelocity_joint_smooth M w)
    contDiff_const (addressedVelocity_supported M w) ?_, ?_⟩
  · simp [Supported]
  · intro T _hT
    obtain ⟨L, C, h⟩ := finite_interval_bounds (addressedVelocity_joint_smooth M w)
      (addressedVelocity_supported M w) T
    exact ⟨(L : ℝ) + C, fun t ht x => add_le_add (h t ht x).1 (h t ht x).2⟩

end RapidForcing

end OAI