import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.FlowPointwise
import Mathlib.Analysis.Calculus.ContDiff.Comp
import Mathlib.Analysis.Normed.Module.FiniteDimension
import Mathlib.Topology.UniformSpace.HeineCantor

namespace OAI

/-! Differentiation of a smooth finite-dimensional field on compact path space.
Compactness makes the derivative remainder uniform over the path; this is the
analytic ingredient needed to apply the implicit function theorem to Picard's
integral equation. -/

noncomputable section
namespace ForcedComputation.Flow

open Set Filter Metric
open scoped Topology ContDiff

variable {K E F : Type} [TopologicalSpace K] [CompactSpace K]
  [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

def postcompose (f : C(E, F)) (u : C(K, E)) : C(K, F) := f.comp u

omit [CompactSpace K] [NormedSpace ℝ E] [FiniteDimensional ℝ E] [NormedSpace ℝ F] in
theorem postcompose_continuous (f : C(E, F)) :
    Continuous (postcompose (K := K) f) := f.continuous_postcomp

theorem postcompose_hasFDerivAt (f : C(E, F))
    (hf : ContDiff ℝ 1 (f : E → F)) (u : C(K, E)) :
    HasFDerivAt (postcompose f)
      (applyPath ⟨fun t => fderiv ℝ f (u t),
        (hf.continuous_fderiv (by simp)).comp u.continuous⟩) u := by
  rw [hasFDerivAt_iff_isLittleO, Asymptotics.isLittleO_iff]
  intro ε hε
  have hdf := hf.continuous_fderiv (by simp)
  have huc : UniformContinuousOn (fderiv ℝ f)
      (closedBall (0 : E) (‖u‖ + 1)) :=
    (isCompact_closedBall (0 : E) (‖u‖ + 1)).uniformContinuousOn_of_continuous
      hdf.continuousOn
  obtain ⟨δ, hδ, hcontrol⟩ := Metric.uniformContinuousOn_iff.mp huc ε hε
  filter_upwards [Metric.ball_mem_nhds u (lt_min hδ zero_lt_one)] with v hv
  have hvnorm : ‖v - u‖ < min δ 1 := by simpa only [mem_ball, dist_eq_norm] using hv
  apply (ContinuousMap.norm_le _
    (mul_nonneg hε.le (norm_nonneg (v - u)))).mpr
  intro t
  change ‖f (v t) - f (u t) - fderiv ℝ f (u t) (v t - u t)‖ ≤ ε * ‖v - u‖
  have hu : u t ∈ closedBall (0 : E) (‖u‖ + 1) := by
    rw [mem_closedBall, dist_zero_right]
    exact (u.norm_coe_le_norm t).trans (by linarith)
  have hdiff : ‖v t - u t‖ ≤ ‖v - u‖ := (v - u).norm_coe_le_norm t
  have hv' : v t ∈ closedBall (0 : E) (‖u‖ + 1) := by
    rw [mem_closedBall, dist_zero_right]
    calc
      ‖v t‖ ≤ ‖v t - u t‖ + ‖u t‖ := by
        simpa only [sub_add_cancel] using norm_add_le (v t - u t) (u t)
      _ ≤ ‖v - u‖ + ‖u‖ := add_le_add hdiff (u.norm_coe_le_norm t)
      _ ≤ ‖u‖ + 1 := by linarith [lt_of_lt_of_le hvnorm (min_le_right δ 1)]
  have hsegment := (convex_closedBall (0 : E) (‖u‖ + 1)).segment_subset hu hv'
  have hr := remainder_bound (fun z => (hf.differentiable (by simp) z).hasFDerivAt)
    (u t) (v t) (ε := ε) (by
      intro z hz
      have hzδ : dist z (u t) < δ := by
        rw [dist_eq_norm]
        exact (norm_sub_le_of_mem_segment hz).trans_lt
          (hdiff.trans_lt (lt_of_lt_of_le hvnorm (min_le_left δ 1)))
      simpa only [dist_eq_norm] using (hcontrol z (hsegment hz) (u t) hu hzδ).le)
  exact hr.trans (mul_le_mul_of_nonneg_left hdiff hε.le)

theorem postcompose_contDiff_nat (n : ℕ) (f : C(E, F))
    (hf : ContDiff ℝ n (f : E → F)) :
    ContDiff ℝ n (postcompose (K := K) f) := by
  induction n generalizing F with
  | zero =>
      exact contDiff_zero.mpr (postcompose_continuous f)
  | succ n ih =>
      have h1 : ContDiff ℝ 1 (f : E → F) := hf.of_le (by norm_cast; omega)
      let df : C(E, E →L[ℝ] F) :=
        ⟨fderiv ℝ f, h1.continuous_fderiv (by simp)⟩
      have hdf : ContDiff ℝ n (df : E → E →L[ℝ] F) :=
        hf.fderiv_right (m := n) (by simp)
      apply contDiff_succ_iff_hasFDerivAt.mpr
      refine ⟨fun u => applyPathL (postcompose df u), ?_, ?_⟩
      · exact (applyPathL (K := K) (E := E) (F := F)).contDiff.comp (ih df hdf)
      · intro u
        exact postcompose_hasFDerivAt f h1 u

theorem postcompose_contDiff (f : C(E, F)) (hf : ContDiff ℝ ∞ (f : E → F)) :
    ContDiff ℝ ∞ (postcompose (K := K) f) := by
  rw [contDiff_infty]
  intro n
  exact postcompose_contDiff_nat n f (hf.of_le (by simp))

end ForcedComputation.Flow

end

end OAI