import OAI.Combinatorics.HalvingLines.Zoom

namespace OAI

namespace PlanarHalving

namespace Calculus

open Filter MeasureTheory Set Metric Asymptotics
open scoped Topology ENNReal NNReal

theorem ae_near_set (S : Set Point) (hS : MeasurableSet S) :
    ∀ᵐ x ∂(volume : Measure Point), x ∈ S →
      ∀ ε : ℝ, 0 < ε → ∀ᶠ y in 𝓝 x,
        ∃ z ∈ S, dist z y ≤ ε * dist y x := by
  have hd : ∀ᵐ x ∂(volume : Measure Point).restrict S, ∀ n : ℕ,
      ∀ {ι : Type} {l : Filter ι} (w : ι → Point) (δ : ι → ℝ),
      Tendsto δ l (𝓝[>] 0) →
      (∀ᶠ j in l, x ∈ closedBall (w j) ((n + 1 : ℝ) * δ j)) →
      Tendsto (fun j => volume (S ∩ closedBall (w j) (δ j)) /
        volume (closedBall (w j) (δ j))) l (𝓝 (1 : ℝ≥0∞)) := by
    rw [ae_all_iff]
    intro n
    exact IsUnifLocDoublingMeasure.ae_tendsto_measure_inter_div volume S (n + 1)
  rw [ae_restrict_iff' hS] at hd
  filter_upwards [hd] with x hx hxs
  intro ε hε
  obtain ⟨n, hn⟩ := exists_nat_gt (ε⁻¹)
  have hn0 : (0 : ℝ) < n + 1 := by positivity
  have hnε : (n + 1 : ℝ)⁻¹ ≤ ε := by
    apply (inv_le_iff_one_le_mul₀ hn0).mpr
    have hh := (inv_lt_iff_one_lt_mul₀ hε).mp hn
    nlinarith
  have hδ : Tendsto (fun y : Point => (n + 1 : ℝ)⁻¹ * dist y x)
      (𝓝[≠] x) (𝓝[>] (0 : ℝ)) := by
    rw [tendsto_nhdsWithin_iff]
    refine ⟨?_, ?_⟩
    · have hh : Tendsto (fun y : Point => (n + 1 : ℝ)⁻¹ * dist y x)
          (𝓝 x) (𝓝 ((n + 1 : ℝ)⁻¹ * dist x x)) :=
        (continuousAt_id.dist continuousAt_const).const_mul _
      simpa using hh.mono_left (nhdsWithin_le_nhds (s := {x}ᶜ))
    · filter_upwards [self_mem_nhdsWithin] with y hy
      exact mul_pos (inv_pos.mpr hn0) (dist_pos.mpr hy)
  have hcover : ∀ᶠ y : Point in 𝓝[≠] x,
      x ∈ closedBall y ((n + 1 : ℝ) * ((n + 1 : ℝ)⁻¹ * dist y x)) := by
    filter_upwards with y
    simp [Metric.mem_closedBall, mul_inv_cancel_left₀ hn0.ne', dist_comm]
  have hlim := hx hxs n (fun y : Point => y)
    (fun y => (n + 1 : ℝ)⁻¹ * dist y x) hδ hcover
  have he : ∀ᶠ y : Point in 𝓝[≠] x,
      ∃ z ∈ S, dist z y ≤ ε * dist y x := by
    have hh := hlim.eventually (Ioi_mem_nhds (show (0 : ℝ≥0∞) < 1 by simp))
    filter_upwards [hh] with y hy
    have hne : volume (S ∩ closedBall y ((n + 1 : ℝ)⁻¹ * dist y x)) ≠ 0 := by
      intro hz
      simp [hz] at hy
    obtain ⟨z, hzS, hzB⟩ := nonempty_of_measure_ne_zero hne
    exact ⟨z, hzS, (Metric.mem_closedBall.mp hzB).trans
      (mul_le_mul_of_nonneg_right hnε dist_nonneg)⟩
  rw [← nhdsNE_sup_pure x, Filter.eventually_sup]
  exact ⟨he, by simp only [Filter.eventually_pure]; exact ⟨x, hxs, by simp⟩⟩

theorem hasFDerivAt_of_within_near_set {f : Point → ℝ} {S : Set Point}
    {x : Point} {f' : Point →L[ℝ] ℝ} {C : ℝ} (hC : 0 ≤ C)
    (hLip : ∀ z ∈ S, ∀ y, ‖f y - f z‖ ≤ C * ‖y - z‖)
    (hnear : ∀ ε : ℝ, 0 < ε → ∀ᶠ y in 𝓝 x,
      ∃ z ∈ S, dist z y ≤ ε * dist y x)
    (hf : HasFDerivWithinAt f f' S x) : HasFDerivAt f f' x := by
  rw [hasFDerivAt_iff_isLittleO]
  apply IsLittleO.of_bound
  intro ε hε
  let η := min 1 (ε / (2 * (C + ‖f'‖ + 1)))
  have hden : 0 < 2 * (C + ‖f'‖ + 1) := by positivity
  have hη : 0 < η := lt_min zero_lt_one (div_pos hε hden)
  have hη1 : η ≤ 1 := min_le_left _ _
  have hsmall : (C + ‖f'‖) * η ≤ ε / 2 := by
    have hh := (le_div_iff₀ hden).mp (min_le_right 1 (ε / (2 * (C + ‖f'‖ + 1))))
    nlinarith only [hh, hη]
  have hlin := hf.isLittleO.def (show 0 < ε / 4 by positivity)
  obtain ⟨r, hr, hrlin⟩ := Metric.mem_nhdsWithin_iff.mp hlin
  filter_upwards [hnear η hη, Metric.ball_mem_nhds x (show 0 < r / 2 by positivity)] with y hy hyr
  obtain ⟨z, hzS, hzy⟩ := hy
  have hyz : ‖y - z‖ ≤ η * ‖y - x‖ := by
    simpa only [dist_eq_norm, norm_sub_rev] using hzy
  have hzx : ‖z - x‖ ≤ 2 * ‖y - x‖ := by
    have hh := dist_triangle z y x
    simp only [dist_eq_norm] at hh
    have hzy' : ‖z - y‖ ≤ ‖y - x‖ := by
      have hzyη : ‖z - y‖ ≤ η * ‖y - x‖ := by
        rw [norm_sub_rev]
        exact hyz
      exact hzyη.trans (mul_le_of_le_one_left (norm_nonneg _) hη1)
    linarith only [hh, hzy']
  have hzr : dist z x < r := by
    rw [Metric.mem_ball, dist_eq_norm] at hyr
    rw [dist_eq_norm]
    linarith only [hzx, hyr]
  have hzlin := hrlin ⟨hzr, hzS⟩
  have hdecomp : f y - f x - f' (y - x) =
      (f y - f z - f' (y - z)) + (f z - f x - f' (z - x)) := by
    rw [show y - x = (y - z) + (z - x) by abel, map_add]
    ring
  calc
    ‖f y - f x - f' (y - x)‖ ≤
        ‖f y - f z‖ + ‖f' (y - z)‖ + ‖f z - f x - f' (z - x)‖ := by
      rw [hdecomp]
      exact (norm_add_le _ _).trans (add_le_add_left (norm_sub_le _ _) _)
    _ ≤ C * ‖y - z‖ + ‖f'‖ * ‖y - z‖ + (ε / 4) * ‖z - x‖ := by
      gcongr
      · exact hLip z hzS y
      · exact f'.le_opNorm _
      · exact hzlin
    _ ≤ (C + ‖f'‖) * (η * ‖y - x‖) + (ε / 4) * (2 * ‖y - x‖) := by
      rw [← add_mul]
      gcongr
    _ ≤ ε * ‖y - x‖ := by
      nlinarith only [mul_le_mul_of_nonneg_right hsmall (norm_nonneg (y - x))]

theorem ae_differentiable_of_pointwise_lipschitz_pieces {f : Point → ℝ}
    (S : ℕ → Set Point) (hS : ∀ n, MeasurableSet (S n))
    (hLip : ∀ n, ∀ z ∈ S n, ∀ y, ‖f y - f z‖ ≤ (n : ℝ) * ‖y - z‖)
    (hcover : ∀ᵐ x ∂(volume : Measure Point), ∃ n, x ∈ S n) :
    ∀ᵐ x ∂(volume : Measure Point), DifferentiableAt ℝ f x := by
  have hd : ∀ n, ∀ᵐ x ∂(volume : Measure Point), x ∈ S n → DifferentiableAt ℝ f x := by
    intro n
    have hl : LipschitzOnWith (n : ℝ≥0) f (S n) := by
      apply LipschitzOnWith.of_dist_le_mul
      intro x hx y hy
      simpa only [dist_eq_norm, NNReal.coe_natCast] using hLip n y hy x
    filter_upwards [hl.ae_differentiableWithinAt_of_mem, ae_near_set (S n) (hS n)] with x hx hn hxs
    obtain ⟨f', hf'⟩ := hx hxs
    exact (hasFDerivAt_of_within_near_set (by positivity) (hLip n) (hn hxs) hf').differentiableAt
  filter_upwards [ae_all_iff.mpr hd, hcover] with x hx hc
  obtain ⟨n, hn⟩ := hc
  exact hx n hn

def slopePiece (f : Point → ℝ) (m : ℕ) : Set Point :=
  {x | ∀ q : ℚ, 0 < q →
    f (x + ((q : ℝ), (q : ℝ))) - f (x - ((q : ℝ), (q : ℝ))) ≤ m * (q : ℝ)}

theorem measurableSet_slopePiece {f : Point → ℝ} (hf : Measurable f) (m : ℕ) :
    MeasurableSet (slopePiece f m) := by
  simp only [slopePiece, ofPred_forall]
  apply MeasurableSet.iInter
  intro q
  apply MeasurableSet.iInter
  intro _
  exact measurableSet_le ((hf.comp (measurable_id.add_const _)).sub
    (hf.comp (measurable_id.sub_const _))) measurable_const

theorem monotone_chord_bound {f : Point → ℝ} (hf : Monotone f)
    (x y : Point) (q : ℝ) (hq : ‖y - x‖ ≤ q) :
    ‖f y - f x‖ ≤ f (x + (q, q)) - f (x - (q, q)) := by
  have hq0 : 0 ≤ q := (norm_nonneg _).trans hq
  have hxy := norm_prod_le_iff.mp hq
  change |y.1 - x.1| ≤ q ∧ |y.2 - x.2| ≤ q at hxy
  rw [abs_le, abs_le] at hxy
  have hlow : x - (q, q) ≤ y := by
    constructor <;> dsimp <;> linarith only [hxy.1.1, hxy.2.1]
  have hup : y ≤ x + (q, q) := by
    constructor <;> dsimp <;> linarith only [hxy.1.2, hxy.2.2]
  have hlowx : x - (q, q) ≤ x := by constructor <;> dsimp <;> linarith
  have hupx : x ≤ x + (q, q) := by constructor <;> dsimp <;> linarith
  rw [Real.norm_eq_abs, abs_le]
  constructor <;> linarith only [hf hlow, hf hup, hf hlowx, hf hupx]

theorem slopePiece_bound {f : Point → ℝ} (hf : Monotone f) (m : ℕ)
    {x : Point} (hx : x ∈ slopePiece f m) (y : Point) :
    ‖f y - f x‖ ≤ (m : ℝ) * ‖y - x‖ := by
  apply le_of_forall_pos_le_add
  intro ε hε
  have hm : 0 < (m : ℝ) + 1 := by positivity
  obtain ⟨q, hq, hq'⟩ := exists_rat_btwn
    (show ‖y - x‖ < ‖y - x‖ + ε / (m + 1 : ℝ) by linarith only [div_pos hε hm])
  have hq0 : 0 < q := by exact_mod_cast (lt_of_le_of_lt (norm_nonneg _) hq)
  have hh := (monotone_chord_bound hf x y q hq.le).trans (hx q hq0)
  have hq'' : (q : ℝ) - ‖y - x‖ < ε / (m + 1 : ℝ) := by linarith only [hq']
  have hmul := (lt_div_iff₀ hm).mp hq''
  nlinarith only [hh, hmul, hq]

theorem mem_slopePiece_of_diagonal_differentiable {f : Point → ℝ} {B : ℝ}
    (hb : ∀ x, ‖f x‖ ≤ B) {x : Point}
    (hd : DifferentiableAt ℝ (fun t : ℝ => f (x + (t, t))) 0) :
    ∃ m, x ∈ slopePiece f m := by
  obtain ⟨C, hC, hc⟩ := hd.hasFDerivAt.isBigO_sub.exists_pos
  obtain ⟨δ, hδ, hδC⟩ := Metric.eventually_nhds_iff.mp hc.bound
  obtain ⟨m, hm⟩ := exists_nat_ge (max (2 * C) (2 * B / δ))
  have hmC := (le_max_left (2 * C) (2 * B / δ)).trans hm
  have hmB := (le_max_right (2 * C) (2 * B / δ)).trans hm
  refine ⟨m, ?_⟩
  intro q hq
  have hq0 : 0 < (q : ℝ) := by exact_mod_cast hq
  by_cases hqd : (q : ℝ) < δ
  · have hp := hδC (y := (q : ℝ)) (by simpa only [dist_zero_right, Real.norm_eq_abs, abs_neg, abs_of_pos hq0] using hqd)
    have hn := hδC (y := -(q : ℝ)) (by simpa only [dist_zero_right, Real.norm_eq_abs, abs_neg, abs_of_pos hq0] using hqd)
    simp only [sub_zero, Real.norm_eq_abs, abs_of_pos hq0, abs_neg] at hp hn
    have he : x + (-(q : ℝ), -(q : ℝ)) = x - ((q : ℝ), (q : ℝ)) := by ext <;> simp [sub_eq_add_neg]
    rw [he] at hn
    have hpu := (abs_le.mp hp).2
    have hnl := (abs_le.mp hn).1
    nlinarith only [hpu, hnl, mul_le_mul_of_nonneg_right hmC hq0.le]
  · have hb1 := (abs_le.mp (show |f (x + ((q : ℝ), (q : ℝ)))| ≤ B by simpa using hb _)).2
    have hb2 := (abs_le.mp (show |f (x - ((q : ℝ), (q : ℝ)))| ≤ B by simpa using hb _)).1
    have hB := (div_le_iff₀ hδ).mp hmB
    have hmul := mul_le_mul_of_nonneg_left (le_of_not_gt hqd) (show 0 ≤ (m : ℝ) by positivity)
    nlinarith only [hb1, hb2, hB, hmul]

theorem bounded_monotone_ae_differentiable {f : Point → ℝ} (hf : Monotone f)
    (hfmeas : Measurable f) {B : ℝ} (hb : ∀ x, ‖f x‖ ≤ B) :
    ∀ᵐ x ∂(volume : Measure Point), DifferentiableAt ℝ f x := by
  apply ae_differentiable_of_pointwise_lipschitz_pieces (slopePiece f)
    (measurableSet_slopePiece hfmeas) (fun n z hz y => slopePiece_bound hf n hz y)
  let L : ℝ →ₗ[ℝ] Point := (LinearMap.id : ℝ →ₗ[ℝ] ℝ).prod LinearMap.id
  have hS : MeasurableSet {x | ∃ n, x ∈ slopePiece f n} := by
    simpa only [ofPred_exists, Set.ofPred_mem_eq] using
      MeasurableSet.iUnion (measurableSet_slopePiece hfmeas)
  apply ae_mem_of_ae_add_linearMap_mem L volume volume hS
  intro p
  have hg : Monotone (fun t : ℝ => f (p + (t, t))) := by
    intro s t hst
    apply hf
    constructor <;> dsimp <;> linarith only [hst]
  filter_upwards [hg.ae_differentiableAt] with s hs
  apply mem_slopePiece_of_diagonal_differentiable hb
  have hs' : DifferentiableAt ℝ (fun t => f (p + (t, t))) (s + (0 : ℝ)) := by simpa using hs
  have hh := hs'.comp 0 ((differentiableAt_id : DifferentiableAt ℝ (fun t : ℝ => t) 0).const_add s)
  have he : (fun t : ℝ => f (p + L s + (t, t))) =
      (fun t : ℝ => f (p + (t, t))) ∘ (fun t : ℝ => s + t) := by
    funext t
    congr 1
    ext <;> simp [L] <;> ring
  rw [he]
  exact hh

def clampPoint (a b x : Point) : Point :=
  (max a.1 (min b.1 x.1), max a.2 (min b.2 x.2))

lemma clampPoint_mem {a b : Point} (hab : a ≤ b) (x : Point) :
    clampPoint a b x ∈ Icc a b := by
  constructor
  · exact ⟨le_max_left _ _, le_max_left _ _⟩
  · exact ⟨max_le hab.1 (min_le_left _ _), max_le hab.2 (min_le_left _ _)⟩

lemma clampPoint_eq {a b x : Point} (hx : x ∈ Icc a b) : clampPoint a b x = x := by
  ext <;> simp only [clampPoint, min_eq_right, hx.2.1, hx.2.2,
    max_eq_right, hx.1.1, hx.1.2]

lemma clampPoint_monotone (a b : Point) : Monotone (clampPoint a b) := by
  intro x y hxy
  exact ⟨max_le_max le_rfl (min_le_min le_rfl hxy.1),
    max_le_max le_rfl (min_le_min le_rfl hxy.2)⟩

lemma clampPoint_continuous (a b : Point) : Continuous (clampPoint a b) := by
  exact (continuous_const.max (continuous_const.min continuous_fst)).prodMk
    (continuous_const.max (continuous_const.min continuous_snd))

theorem bounded_monotoneOn_Icc_ae_differentiable {f : Point → ℝ} {a b : Point}
    (hab : a ≤ b) (hf : MonotoneOn f (Icc a b)) (hfmeas : Measurable f)
    {B : ℝ} (hb : ∀ x ∈ Icc a b, ‖f x‖ ≤ B) :
    ∀ᵐ x ∂(volume : Measure Point), x ∈ interior (Icc a b) → DifferentiableAt ℝ f x := by
  let g := fun x => f (clampPoint a b x)
  have hg : Monotone g := fun x y hxy => hf (clampPoint_mem hab x)
    (clampPoint_mem hab y) (clampPoint_monotone a b hxy)
  have hgm : Measurable g := hfmeas.comp (clampPoint_continuous a b).measurable
  filter_upwards [bounded_monotone_ae_differentiable hg hgm
    (fun x => hb _ (clampPoint_mem hab x))] with x hx hxi
  apply hx.congr_of_eventuallyEq
  filter_upwards [mem_interior_iff_mem_nhds.mp hxi] with y hy
  exact congrArg f (clampPoint_eq hy).symm

theorem bounded_monotoneOn_rectangle_ae_differentiable {f : Point → ℝ} {a b : Point}
    (hf : MonotoneOn f (Ioo a.1 b.1 ×ˢ Ioo a.2 b.2)) (hfmeas : Measurable f)
    {B : ℝ} (hb : ∀ x ∈ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2, ‖f x‖ ≤ B) :
    ∀ᵐ x ∂(volume : Measure Point),
      x ∈ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2 → DifferentiableAt ℝ f x := by
  let castPoint : ℚ × ℚ → Point := fun q => ((q.1 : ℝ), (q.2 : ℝ))
  have hall : ∀ q r : ℚ × ℚ, ∀ᵐ x ∂(volume : Measure Point),
      Icc (castPoint q) (castPoint r) ⊆ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2 →
      x ∈ interior (Icc (castPoint q) (castPoint r)) → DifferentiableAt ℝ f x := by
    intro q r
    by_cases hqr : castPoint q ≤ castPoint r
    · by_cases hsub : Icc (castPoint q) (castPoint r) ⊆ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2
      · filter_upwards [bounded_monotoneOn_Icc_ae_differentiable hqr (hf.mono hsub)
          hfmeas (fun x hx => hb x (hsub hx))] with x hx _ hi
        exact hx hi
      · exact Filter.Eventually.of_forall (fun _ h => (hsub h).elim)
    · have hempty : Icc (castPoint q) (castPoint r) = ∅ := by
        apply Set.eq_empty_iff_forall_notMem.mpr
        intro x hx
        exact hqr (hx.1.trans hx.2)
      simp only [hempty, interior_empty, mem_empty_iff_false, IsEmpty.forall_iff,
        implies_true, Filter.eventually_true]
  filter_upwards [ae_all_iff.mpr (fun q => ae_all_iff.mpr (hall q))] with x hx hxi
  obtain ⟨q₁, haq₁, hq₁x⟩ := exists_rat_btwn hxi.1.1
  obtain ⟨r₁, hxr₁, hr₁b⟩ := exists_rat_btwn hxi.1.2
  obtain ⟨q₂, haq₂, hq₂x⟩ := exists_rat_btwn hxi.2.1
  obtain ⟨r₂, hxr₂, hr₂b⟩ := exists_rat_btwn hxi.2.2
  apply hx (q₁, q₂) (r₁, r₂)
  · intro y hy
    exact ⟨⟨haq₁.trans_le hy.1.1, hy.2.1.trans_lt hr₁b⟩,
      ⟨haq₂.trans_le hy.1.2, hy.2.2.trans_lt hr₂b⟩⟩
  · rw [Icc_prod_eq, interior_prod_eq, interior_Icc, interior_Icc]
    exact ⟨⟨hq₁x, hxr₁⟩, ⟨hq₂x, hxr₂⟩⟩

theorem ae_differentiable_linear_change (A : Point ≃L[ℝ] Point) (f : Point → ℝ)
    (U : Set Point)
    (hd : ∀ᵐ x ∂(volume : Measure Point), x ∈ U → DifferentiableAt ℝ (f ∘ A) x) :
    ∀ᵐ y ∂(volume : Measure Point), A.symm y ∈ U → DifferentiableAt ℝ f y := by
  have hA : Measure.QuasiMeasurePreserving A.symm volume volume :=
    Measure.LinearMap.quasiMeasurePreserving volume A.symm.toLinearEquiv.toLinearMap
      A.symm.toLinearEquiv.isUnit_det'.ne_zero
  filter_upwards [hA.ae hd] with y hy hyU
  have hh := (hy hyU).comp y (A.symm.differentiable y)
  simpa only [Function.comp_def, A.apply_symm_apply] using hh

end Calculus

end PlanarHalving

end OAI