import OAI.MathematicalPhysics.AlternatingFlow.Encoding

namespace OAI

open scoped BigOperators ENNReal NNReal Topology ContDiff
open MeasureTheory
namespace AlternatingNS
namespace Profiles

noncomputable def clock (t : ℝ) : ℝ :=
  letI := twoAtLeastTwo
  Real.smoothTransition (2 * t - 1 / 2)

lemma clock_smooth : ContDiff ℝ ∞ clock := by
  unfold clock
  fun_prop

lemma clock_mem (t : ℝ) : clock t ∈ Set.Icc (0 : ℝ) 1 :=
  ⟨Real.smoothTransition.nonneg _, Real.smoothTransition.le_one _⟩

lemma clock_zero (t : ℝ) (ht : t ≤ 1 / 4) : clock t = 0 := by
  apply Real.smoothTransition.zero_of_nonpos
  linarith

lemma clock_one (t : ℝ) (ht : 3 / 4 ≤ t) : clock t = 1 := by
  apply Real.smoothTransition.one_of_one_le
  linarith

lemma clock_monotone : Monotone clock := by
  intro a b hab
  apply Real.smoothTransition.monotone
  linarith

noncomputable def periodizer (a c x : ℝ) : ℝ :=
  Int.fract x - Real.smoothTransition ((Int.fract x - a) / (c - a))

lemma periodizer_periodic (a c : ℝ) : Function.Periodic (periodizer a c) 1 := by
  intro x
  simp only [periodizer, Int.fract_add_one]

lemma periodizer_int_add (a c : ℝ) (k : ℤ) (x : ℝ) :
    periodizer a c ((k : ℝ) + x) = periodizer a c x := by
  simp only [periodizer, Int.fract_intCast_add]

lemma periodizer_self (a c x : ℝ) (hac : a < c) (ha : a < 1)
    (hx : x ∈ Set.Icc 0 a) : periodizer a c x = x := by
  have hf : Int.fract x = x := Int.fract_eq_self.2 ⟨hx.1, hx.2.trans_lt ha⟩
  rw [periodizer, hf, Real.smoothTransition.zero_of_nonpos]
  · ring
  · exact div_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr hx.2) (sub_pos.mpr hac).le

lemma periodizer_near_zero (a c : ℝ) (ha : 0 < a) (hac : a < c) (hc : c < 1)
    (x : ℝ) (hx : x ∈ Set.Ioo (c - 1) a) : periodizer a c x = x := by
  by_cases hx0 : 0 ≤ x
  · exact periodizer_self a c x hac (hac.trans hc) ⟨hx0, hx.2.le⟩
  · have hn : ⌊x⌋ = (-1 : ℤ) := Int.floor_eq_iff.2 (by norm_num; constructor <;> linarith [hx.1])
    have hf : Int.fract x = x + 1 := by rw [Int.fract, hn]; norm_num
    have hh : 1 ≤ (x + 1 - a) / (c - a) :=
      (le_div_iff₀ (sub_pos.mpr hac)).2 (by linarith [hx.1])
    rw [periodizer, hf, Real.smoothTransition.one_of_one_le hh]
    ring

lemma periodizer_smooth (a c : ℝ) (ha : 0 < a) (hac : a < c) (hc : c < 1) :
    ContDiff ℝ ∞ (periodizer a c) := by
  rw [contDiff_iff_contDiffAt]
  intro x
  by_cases hx : x = (⌊x⌋ : ℝ)
  · have hg : ContDiff ℝ ∞ (fun y : ℝ => y - (⌊x⌋ : ℝ)) := by fun_prop
    apply hg.contDiffAt.congr_of_eventuallyEq
    have hlo : (⌊x⌋ : ℝ) + (c - 1) < x := by linarith
    have hhi : x < (⌊x⌋ : ℝ) + a := by linarith
    filter_upwards [Ioo_mem_nhds hlo hhi] with y hy
    have hy' : y - (⌊x⌋ : ℝ) ∈ Set.Ioo (c - 1) a := by
      constructor <;> linarith [hy.1, hy.2]
    calc
      periodizer a c y = periodizer a c ((⌊x⌋ : ℝ) + (y - (⌊x⌋ : ℝ))) := by congr 1; ring
      _ = periodizer a c (y - (⌊x⌋ : ℝ)) := periodizer_int_add a c _ _
      _ = y - (⌊x⌋ : ℝ) := periodizer_near_zero a c ha hac hc _ hy'
  · have hg : ContDiff ℝ ∞ (fun y : ℝ => (y - (⌊x⌋ : ℝ)) -
        Real.smoothTransition (((y - (⌊x⌋ : ℝ)) - a) / (c - a))) := by fun_prop
    apply hg.contDiffAt.congr_of_eventuallyEq
    have hlo : (⌊x⌋ : ℝ) < x := (Int.floor_le x).lt_of_ne (Ne.symm hx)
    filter_upwards [Ioo_mem_nhds hlo (Int.lt_floor_add_one x)] with y hy
    have hy' : ⌊y⌋ = ⌊x⌋ := Int.floor_eq_iff.2 ⟨hy.1.le, hy.2⟩
    simp only [periodizer, Int.fract, hy']

noncomputable def decoder (b : ℕ) : ℝ → ℝ :=
  letI := twoAtLeastTwo
  letI := threeAtLeastTwo
  periodizer ((2 * Encoding.tailMax b + 1) / 3) ((Encoding.tailMax b + 2) / 3)

lemma decoder_law (b : ℕ) (hb : 2 ≤ b) : Encoding.DecoderLaw b (decoder b) := by
  have hm := Encoding.tailMax_lt_one b hb
  refine ⟨periodizer_periodic _ _, ?_⟩
  intro x hx
  apply periodizer_self
  · linarith
  · linarith
  · exact ⟨hx.1, by linarith [hx.2]⟩

lemma decoder_smooth (b : ℕ) (hb : 2 ≤ b) : ContDiff ℝ ∞ (decoder b) := by
  have hm0 := Encoding.tailMax_nonneg b hb
  have hm1 := Encoding.tailMax_lt_one b hb
  apply periodizer_smooth <;> linarith

lemma iteratedDeriv_periodic (f : ℝ → ℝ) (hf : Function.Periodic f 1) (r : ℕ) :
    Function.Periodic (iteratedDeriv r f) 1 := by
  have heq : (fun x => f (x + 1)) = f := funext hf
  have h := iteratedDeriv_comp_add_const r f 1
  rw [heq] at h
  exact fun x => (congr_fun h x).symm

lemma periodic_derivatives_bounded (f : ℝ → ℝ) (hf : Function.Periodic f 1)
    (hs : ContDiff ℝ ∞ f) (r : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ x, |iteratedDeriv r f x| ≤ C := by
  have hcont : Continuous (fun x => |iteratedDeriv r f x|) :=
    (hs.continuous_iteratedDeriv r (WithTop.coe_le_coe.mpr le_top)).abs
  obtain ⟨C, hC⟩ := isCompact_Icc.bddAbove_image (hcont.continuousOn (s := Set.Icc 0 1))
  refine ⟨max 0 C, le_max_left _ _, ?_⟩
  intro x
  obtain ⟨y, hy, hxy⟩ := (iteratedDeriv_periodic f hf r).exists_mem_Ico (by norm_num) x 0
  rw [hxy]
  apply le_trans _ (le_max_right _ _)
  apply hC
  exact ⟨y, ⟨hy.1, by simpa using hy.2.le⟩, rfl⟩

lemma decoder_derivatives_bounded (b : ℕ) (hb : 2 ≤ b) (r : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ x, |iteratedDeriv r (decoder b) x| ≤ C :=
  periodic_derivatives_bounded (decoder b) (decoder_law b hb).1 (decoder_smooth b hb) r

end Profiles

namespace Encoding

lemma read_donor_configuration (b N n : ℕ) (hb : 2 ≤ b)
    (g : ℕ → ℕ) (L R : ℕ → List ℕ)
    (hL : ∀ j, (L j).length = Scales.K N j)
    (hR : ∀ j, (R j).length = Scales.K N j)
    (hd : ∀ j, ∀ d ∈ g j :: (L j ++ R j), d + 2 ≤ b) :
    let C := fun j => code b (g j :: (L j ++ R j))
    let D := donor b N C n
    Profiles.decoder b ((b : ℝ) ^ Scales.s N n * D) = C n ∧
    Profiles.decoder b ((b : ℝ) ^ (Scales.s N n + 1 + Scales.K N n) * D) =
      code b (R n) ∧
    Profiles.decoder b ((b : ℝ) ^ (Scales.s N n + 1) * D) -
      ((b : ℝ) ^ Scales.K N n)⁻¹ *
        Profiles.decoder b ((b : ℝ) ^ (Scales.s N n + 1 + Scales.K N n) * D) =
      code b (L n) := by
  dsimp only
  have hC : ∀ j, ∃ a : ℤ,
      (b : ℝ) ^ (1 + 2 * Scales.K N j) * code b (g j :: (L j ++ R j)) = a := by
    intro j
    obtain ⟨a, ha⟩ := code_denominator b (by omega) (g j :: (L j ++ R j))
    refine ⟨a, ?_⟩
    simp only [List.length_cons, List.length_append, hL, hR] at ha
    have he : 1 + 2 * Scales.K N j = Scales.K N j + Scales.K N j + 1 := by omega
    simpa only [he, Int.cast_natCast] using ha
  have h := read_configuration b (Scales.s N n) (g n) hb (L n) (R n)
    (donor b N (fun j => code b (g j :: (L j ++ R j))) n)
    (donor_integer_add b N n (by omega) _ hC) (hd n)
    (Profiles.decoder b) (Profiles.decoder_law b hb)
  simpa only [hL] using h

end Encoding
end AlternatingNS

end OAI