import OAI.Dynamics.EntropyCounterexample.Clock
import OAI.Dynamics.EntropyCounterexample.Embedding

namespace OAI

noncomputable section

namespace Problem340.Clock

def rotate (x : ClockAmbient) (a : ℝ) : ClockAmbient :=
  WithLp.toLp 2 ![x 0 * Real.cos a - x 1 * Real.sin a,
    x 0 * Real.sin a + x 1 * Real.cos a]

@[simp] lemma rotate_zero_apply (x : ClockAmbient) (a : ℝ) :
    rotate x a 0 = x 0 * Real.cos a - x 1 * Real.sin a := rfl

@[simp] lemma rotate_one_apply (x : ClockAmbient) (a : ℝ) :
    rotate x a 1 = x 0 * Real.sin a + x 1 * Real.cos a := rfl

lemma norm_rotate (x : ClockAmbient) (a : ℝ) : ‖rotate x a‖ = ‖x‖ := by
  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
  rw [EuclideanSpace.real_norm_sq_eq, EuclideanSpace.real_norm_sq_eq]
  simp only [Fin.sum_univ_two, rotate_zero_apply, rotate_one_apply]
  have hc := Real.sin_sq_add_cos_sq a
  nlinarith [sq_nonneg (x 0), sq_nonneg (x 1)]

lemma contDiff_rotate {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {n : ℕ∞} {x : E → ClockAmbient} {a : E → ℝ}
    (hx : ContDiff ℝ n x) (ha : ContDiff ℝ n a) :
    ContDiff ℝ n (fun y => rotate (x y) (a y)) := by
  apply (contDiff_piLp 2).mpr
  intro i
  fin_cases i
  · exact (((EuclideanSpace.proj (𝕜 := ℝ) (0 : Fin 2)).contDiff.comp hx).mul ha.cos).sub
      (((EuclideanSpace.proj (𝕜 := ℝ) (1 : Fin 2)).contDiff.comp hx).mul ha.sin)
  · exact (((EuclideanSpace.proj (𝕜 := ℝ) (0 : Fin 2)).contDiff.comp hx).mul ha.sin).add
      (((EuclideanSpace.proj (𝕜 := ℝ) (1 : Fin 2)).contDiff.comp hx).mul ha.cos)

def parametrization (t : ℝ) : ClockAmbient :=
  WithLp.toLp 2 ![Real.cos (2 * Real.pi * t / 100), Real.sin (2 * Real.pi * t / 100)]

@[simp] lemma parametrization_zero (t : ℝ) :
    parametrization t 0 = Real.cos (2 * Real.pi * t / 100) := rfl

@[simp] lemma parametrization_one (t : ℝ) :
    parametrization t 1 = Real.sin (2 * Real.pi * t / 100) := rfl

lemma norm_parametrization (t : ℝ) : ‖parametrization t‖ = 1 := by
  apply (sq_eq_sq₀ (norm_nonneg _) (by norm_num)).mp
  rw [EuclideanSpace.real_norm_sq_eq]
  simp only [Fin.sum_univ_two, parametrization_zero, parametrization_one, one_pow]
  nlinarith [Real.sin_sq_add_cos_sq (2 * Real.pi * t / 100)]

lemma rotate_parametrization (t h : ℝ) :
    rotate (parametrization t) (2 * Real.pi * h / 100) = parametrization (t + h) := by
  ext i
  fin_cases i
  · change Real.cos (2 * Real.pi * t / 100) * Real.cos (2 * Real.pi * h / 100) -
        Real.sin (2 * Real.pi * t / 100) * Real.sin (2 * Real.pi * h / 100) =
      Real.cos (2 * Real.pi * (t + h) / 100)
    rw [show 2 * Real.pi * (t + h) / 100 =
        2 * Real.pi * t / 100 + 2 * Real.pi * h / 100 by ring, Real.cos_add]
  · change Real.cos (2 * Real.pi * t / 100) * Real.sin (2 * Real.pi * h / 100) +
        Real.sin (2 * Real.pi * t / 100) * Real.cos (2 * Real.pi * h / 100) =
      Real.sin (2 * Real.pi * (t + h) / 100)
    rw [show 2 * Real.pi * (t + h) / 100 =
        2 * Real.pi * t / 100 + 2 * Real.pi * h / 100 by ring, Real.sin_add]
    ring

def advance (x : StandardClock) (h : ℝ) : StandardClock :=
  ⟨rotate x.1 (2 * Real.pi * h / 100), by
    rw [Metric.mem_sphere, dist_zero_right, norm_rotate]
    simp⟩

def ambientIncrement (x : ClockAmbient) (e : ℝ) : ℝ :=
  ambientBarrier x + (1 - ambientBarrier x) * e

lemma ambientIncrement_mem_Icc (x : ClockAmbient) (hx : ‖x‖ ≤ 1)
    {e : ℝ} (he : e ∈ Set.Icc (0 : ℝ) 1) :
    ambientIncrement x e ∈ Set.Icc (0 : ℝ) 1 := by
  have hb := ambientBarrier_mem_Icc x hx
  have hp : 0 ≤ (1 - ambientBarrier x) * e := mul_nonneg (by linarith [hb.2]) he.1
  have hp' := mul_le_mul_of_nonneg_left he.2 (show 0 ≤ 1 - ambientBarrier x by linarith [hb.2])
  unfold ambientIncrement
  constructor <;> linarith [hb.1]

lemma ambientBarrier_le_ambientIncrement (x : ClockAmbient) (hx : ‖x‖ ≤ 1)
    {e : ℝ} (he : 0 ≤ e) : ambientBarrier x ≤ ambientIncrement x e := by
  have hb := (ambientBarrier_mem_Icc x hx).2
  have hp : 0 ≤ (1 - ambientBarrier x) * e := mul_nonneg (by linarith) he
  unfold ambientIncrement
  linarith

@[simp] lemma ambientIncrement_one (x : ClockAmbient) : ambientIncrement x 1 = 1 := by
  simp [ambientIncrement]

@[simp] lemma ambientIncrement_zero (x : ClockAmbient) : ambientIncrement x 0 = ambientBarrier x := by
  simp [ambientIncrement]

lemma contDiff_ambientIncrement {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {n : ℕ∞} {x : E → ClockAmbient} {e : E → ℝ}
    (hx : ContDiff ℝ n x) (he : ContDiff ℝ n e) :
    ContDiff ℝ n (fun y => ambientIncrement (x y) (e y)) := by
  exact (contDiff_ambientBarrier.comp hx).add
    ((contDiff_const.sub (contDiff_ambientBarrier.comp hx)).mul he)

lemma ambientIncrement_parametrization (t e : ℝ) :
    ambientIncrement (parametrization t) e = increment t e := by
  simp only [ambientIncrement, increment,
    ambientBarrier_on_circle t (parametrization t) (parametrization_zero t)]

def ambientUpdate (x : ClockAmbient) (e : ℝ) : ClockAmbient :=
  rotate x (2 * Real.pi * ambientIncrement x e / 100)

lemma contDiff_ambientUpdate {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {n : ℕ∞} {x : E → ClockAmbient} {e : E → ℝ}
    (hx : ContDiff ℝ n x) (he : ContDiff ℝ n e) :
    ContDiff ℝ n (fun y => ambientUpdate (x y) (e y)) := by
  apply contDiff_rotate hx
  exact (contDiff_const.mul (contDiff_ambientIncrement hx he)).div_const 100

lemma ambientUpdate_parametrization (t e : ℝ) :
    ambientUpdate (parametrization t) e = parametrization (t + increment t e) := by
  rw [ambientUpdate, ambientIncrement_parametrization, rotate_parametrization]

lemma norm_ambientUpdate (x : ClockAmbient) (e : ℝ) : ‖ambientUpdate x e‖ = ‖x‖ :=
  norm_rotate _ _

def update (x : StandardClock) (e : ℝ) : StandardClock :=
  ⟨ambientUpdate x.1 e, by
    rw [Metric.mem_sphere, dist_zero_right, norm_ambientUpdate]
    simp⟩

lemma continuous_update : Continuous (fun p : StandardClock × ℝ => update p.1 p.2) := by
  apply Continuous.subtype_mk
  have hc : Continuous (fun p : ClockAmbient × ℝ => ambientUpdate p.1 p.2) :=
    (contDiff_ambientUpdate (n := 1) contDiff_fst contDiff_snd).continuous
  exact hc.comp ((continuous_subtype_val.comp continuous_fst).prodMk continuous_snd)

def clockStep (q : ℕ) (e : CounterexampleAmbient q → ℝ)
    (x : CounterexampleManifold q) : CounterexampleManifold q :=
  (update x.1 (e (standardEmbedding q x)), x.2)

lemma isC1SelfMap_clockStep (q : ℕ) (e : CounterexampleAmbient q → ℝ)
    (he : ContDiff ℝ 1 e) : IsC1SelfMap q (clockStep q e) := by
  apply isC1SelfMap_of_contDiff (clockStep q e)
    (fun p : CounterexampleAmbient q => (ambientUpdate p.1 (e p), p.2))
  · exact (contDiff_ambientUpdate contDiff_fst he).prodMk contDiff_snd
  · intro y
    rfl

end Problem340.Clock

end

end OAI