import Mathlib

namespace OAI

noncomputable section

open Set MeasureTheory Manifold Bundle
open scoped ContDiff Manifold ENNReal NNReal Topology

open Set Filter
open scoped Topology NNReal

open Set Filter
open scoped Topology

open Set Manifold MeasureTheory Bundle
open scoped ENNReal ContDiff Topology

open Set
open scoped Topology

open Set Filter Manifold Bundle ContinuousLinearMap
open scoped Topology ContDiff Manifold Bundle

open Set Filter ContinuousLinearMap InnerProductSpace
open scoped Topology ContDiff

open Set Filter ContinuousLinearMap
open scoped Topology ContDiff

namespace WeakMTWTransport
universe u w
variable {K : Type w} {E F : Type u} [TopologicalSpace K] [CompactSpace K]
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

local instance pathCalculusNormedAddCommGroupContinuousLinearMap :
    NormedAddCommGroup (E →L[ℝ] F) := ContinuousLinearMap.toNormedAddCommGroup
local instance pathCalculusNormedSpaceContinuousLinearMap :
    NormedSpace ℝ (E →L[ℝ] F) := ContinuousLinearMap.toNormedSpace
local instance pathCalculusNormedAddCommGroupContinuousMap :
    NormedAddCommGroup C(K,E →L[ℝ] F) := ContinuousMap.instNormedAddCommGroup

def pathLinearApply (A : C(K,E →L[ℝ] F)) : C(K,E) →L[ℝ] C(K,F) := by
  let L : C(K,E) →ₗ[ℝ] C(K,F) :=
    { toFun := fun u => ⟨fun t => A t (u t),A.continuous.clm_apply u.continuous⟩
      map_add' := by intro u v; ext t; exact map_add (A t) (u t) (v t)
      map_smul' := by intro c u; ext t; exact map_smul (A t) c (u t) }
  exact L.mkContinuous ‖A‖ (by
      intro u
      change ‖(⟨fun t => A t (u t),A.continuous.clm_apply u.continuous⟩ : C(K,F))‖ ≤ ‖A‖ * ‖u‖
      apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg A) (norm_nonneg u))).mpr
      intro t
      exact (A t).le_opNorm (u t) |>.trans
        (mul_le_mul (A.norm_coe_le_norm t) (u.norm_coe_le_norm t)
          (norm_nonneg _) (norm_nonneg _)))

@[simp] lemma pathLinearApply_apply (A : C(K,E →L[ℝ] F)) (u : C(K,E)) (t : K) :
    pathLinearApply A u t = A t (u t) := rfl

lemma norm_pathLinearApply_le (A : C(K,E →L[ℝ] F)) : ‖pathLinearApply A‖ ≤ ‖A‖ := by
  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg A)
  intro u
  apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg A) (norm_nonneg u))).mpr
  intro t
  exact (A t).le_opNorm (u t) |>.trans
    (mul_le_mul (A.norm_coe_le_norm t) (u.norm_coe_le_norm t)
      (norm_nonneg _) (norm_nonneg _))

def pathLinearApplyL : C(K,E →L[ℝ] F) →L[ℝ] C(K,E) →L[ℝ] C(K,F) := by
  let L : C(K,E →L[ℝ] F) →ₗ[ℝ] C(K,E) →L[ℝ] C(K,F) :=
    { toFun := fun (A : C(K,E →L[ℝ] F)) => pathLinearApply A
      map_add' := by intro A B; ext u t; rfl
      map_smul' := by intro c A; ext u t; rfl }
  refine LinearMap.mkContinuous (𝕜 := ℝ) (𝕜₂ := ℝ)
    (E := C(K,E →L[ℝ] F)) (F := C(K,E) →L[ℝ] C(K,F)) L 1 ?_
  intro A
  change ‖pathLinearApply A‖ ≤ 1 * ‖A‖
  simpa only [one_mul] using norm_pathLinearApply_le A

lemma hasFDerivAt_path_comp (f : C(E,F)) (f' : C(E,E →L[ℝ] F))
    (hder : ∀ x, HasFDerivAt f (f' x) x) (u : C(K,E)) :
    HasFDerivAt (fun v : C(K,E) => f.comp v) (pathLinearApply (f'.comp u)) u := by
  rw [hasFDerivAt_iff_isLittleO_nhds_zero,Asymptotics.isLittleO_iff]
  intro ε hε
  have hc : IsCompact (range u) := isCompact_range u.continuous
  have huni := hc.uniformContinuousAt_of_continuousAt f'
    (fun _ _ => f'.continuous.continuousAt)
    (r := {z : (E →L[ℝ] F) × (E →L[ℝ] F) | dist z.1 z.2 < ε})
    (Metric.mem_uniformity_dist.mpr ⟨ε,hε,fun {_ _} h => h⟩)
  obtain ⟨δ,hδ,hclose⟩ := Metric.mem_uniformity_dist.mp huni
  filter_upwards [Metric.ball_mem_nhds (0:C(K,E)) hδ] with v hv
  have hvnorm : ‖v‖ < δ := by simpa using hv
  apply (ContinuousMap.norm_le _ (mul_nonneg hε.le (norm_nonneg v))).mpr
  intro t
  have hbound : ∀ z ∈ Metric.ball (u t) δ, ‖f' z - f' (u t)‖ ≤ ε := by
    intro z hz
    have hh := hclose (by simpa only [Metric.mem_ball,dist_comm] using hz) (mem_range_self t)
    change dist (f' (u t)) (f' z) < ε at hh
    exact le_of_lt (by simpa only [dist_eq_norm, norm_sub_rev] using hh)
  have hb : u t + v t ∈ Metric.ball (u t) δ := by
    rw [Metric.mem_ball,dist_eq_norm,add_sub_cancel_left]
    exact (v.norm_coe_le_norm t).trans_lt hvnorm
  have hm := Convex.norm_image_sub_le_of_norm_hasFDerivWithin_le'
    (fun z (_ : z ∈ Metric.ball (u t) δ) => (hder z).hasFDerivWithinAt)
    hbound (convex_ball (u t) δ) (Metric.mem_ball_self hδ) hb
  have heq : ((f.comp (u+v) - f.comp u - pathLinearApply (f'.comp u) v) t) =
      f (u t + v t) - f (u t) - f' (u t) ((u t + v t) - u t) := by
    simp only [ContinuousMap.sub_apply,ContinuousMap.comp_apply,ContinuousMap.add_apply,
      pathLinearApply_apply,add_sub_cancel_left]
  rw [heq]
  exact hm.trans (by simpa only [add_sub_cancel_left] using
    mul_le_mul_of_nonneg_left (v.norm_coe_le_norm t) hε.le)

lemma contDiff_path_comp_nat (m : ℕ) (f : C(E,F)) (hf : ContDiff ℝ m f) :
    ContDiff ℝ m (fun v : C(K,E) => f.comp v) := by
  induction m generalizing F with
  | zero => exact contDiff_zero.mpr f.continuous_postcomp
  | succ m ih =>
    obtain ⟨f',hf',hder⟩ := contDiff_succ_iff_hasFDerivAt.mp hf
    let F' : C(E,E →L[ℝ] F) := ⟨f',hf'.continuous⟩
    apply contDiff_succ_iff_hasFDerivAt.mpr
    refine ⟨fun v => pathLinearApply (F'.comp v),?_,?_⟩
    · exact (pathLinearApplyL (K := K) (E := E) (F := F)).contDiff.comp
        (ih F' hf')
    · intro u; exact hasFDerivAt_path_comp f F' hder u

lemma contDiff_path_comp (f : C(E,F)) (hf : ContDiff ℝ ∞ f) :
    ContDiff ℝ ∞ (fun v : C(K,E) => f.comp v) :=
  contDiff_infty.mpr fun m => contDiff_path_comp_nat m f (contDiff_infty.mp hf m)

end WeakMTWTransport

end

end OAI