import OAI.MeasureTheory.Falconer.Measures.DyadicMeasure
import Mathlib.MeasureTheory.Measure.Prod
import Mathlib.Data.Finset.Union

namespace OAI

namespace PlanarFalconer
open Set Metric MeasureTheory
open scoped ENNReal NNReal

def dyadicPaths : ℕ → Finset (List (Bool × Bool))
  | 0 => {[]}
  | n+1 => Finset.univ.biUnion fun a : Bool × Bool =>
      (dyadicPaths n).image (List.cons a)

@[simp] theorem mem_dyadicPaths (n : ℕ) (p : List (Bool × Bool)) :
    p ∈ dyadicPaths n ↔ p.length = n := by
  induction n generalizing p with
  | zero => simp [dyadicPaths]
  | succ n ih =>
    cases p with
    | nil => simp [dyadicPaths]
    | cons a p => simp [dyadicPaths, ih]

theorem DyadicSquare.descendant_side (Q : DyadicSquare) (p : List (Bool × Bool)) :
    (Q.descendant p).side = Q.side / (2 : ℝ)^p.length := by
  induction p generalizing Q with
  | nil => simp [descendant]
  | cons a p ih =>
    simp only [descendant, ih, child, List.length_cons, pow_succ]
    ring

theorem DyadicSquare.descendants_disjoint (Q : DyadicSquare) (hQ : 0 < Q.side)
    {p q : List (Bool × Bool)} (hlen : p.length = q.length) (hne : p ≠ q) :
    Disjoint (Q.descendant p).carrier (Q.descendant q).carrier := by
  induction p generalizing Q q with
  | nil =>
    have : q = [] := by cases q <;> simp_all
    exact (hne this.symm).elim
  | cons a p ih =>
    cases q with
    | nil => simp at hlen
    | cons b q =>
      by_cases hab : a = b
      · subst b
        exact ih _ (Q.child_side_pos hQ a.1 a.2) (by simpa using hlen)
          (by intro he; exact hne (he ▸ rfl))
      · exact (Q.children_disjoint hab).mono
          ((Q.child a.1 a.2).descendant_subset (Q.child_side_pos hQ a.1 a.2) p)
          ((Q.child b.1 b.2).descendant_subset (Q.child_side_pos hQ b.1 b.2) q)

theorem DyadicSquare.mem_descendant_at_depth (Q : DyadicSquare) (n : ℕ)
    {z : Plane} (hz : z ∈ Q.carrier) :
    ∃ p ∈ dyadicPaths n, z ∈ (Q.descendant p).carrier := by
  induction n generalizing Q with
  | zero => exact ⟨[],by simp, hz⟩
  | succ n ih =>
    have step (i j : Bool) (hz : z ∈ (Q.child i j).carrier) :
        ∃ p ∈ dyadicPaths (n+1), z ∈ (Q.descendant p).carrier := by
      obtain ⟨p,hp,hz⟩ := ih _ hz
      exact ⟨(i,j) :: p,by simpa using hp,hz⟩
    rw [Q.cover_children] at hz
    rcases hz with (hz | hz) | (hz | hz)
    · exact step false false hz
    · exact step false true hz
    · exact step true false hz
    · exact step true true hz

def DyadicSquare.box (Q : DyadicSquare) : Set (ℝ × ℝ) :=
  Ico Q.x (Q.x+Q.side) ×ˢ Ico Q.y (Q.y+Q.side)

def pairToPlane (z : ℝ × ℝ) : Plane := WithLp.toLp 2 ![z.1,z.2]

@[simp] theorem pairToPlane_mem (Q : DyadicSquare) (z : ℝ × ℝ) :
    pairToPlane z ∈ Q.carrier ↔ z ∈ Q.box := by
  simp only [pairToPlane, DyadicSquare.carrier, DyadicSquare.box,
    mem_ofPred_eq, mem_prod, mem_Ico,
    Matrix.cons_val_zero, Matrix.cons_val_one]
  tauto

theorem DyadicSquare.box_measurable (Q : DyadicSquare) : MeasurableSet Q.box :=
  measurableSet_Ico.prod measurableSet_Ico

theorem DyadicSquare.box_area (Q : DyadicSquare) :
    (volume.prod volume) Q.box = ENNReal.ofReal Q.side * ENNReal.ofReal Q.side := by
  simp [box, Measure.prod_prod, Real.volume_Ico]

theorem DyadicSquare.boxes_disjoint (Q : DyadicSquare) (hQ : 0 < Q.side)
    {p q : List (Bool × Bool)} (hlen : p.length = q.length) (hne : p ≠ q) :
    Disjoint (Q.descendant p).box (Q.descendant q).box := by
  apply Set.disjoint_left.mpr
  intro z hp hq
  exact Set.disjoint_left.mp (Q.descendants_disjoint hQ hlen hne)
    ((pairToPlane_mem _ _).mpr hp) ((pairToPlane_mem _ _).mpr hq)

theorem plane_coordinate_dist_le (z x : Plane) (i : Fin 2) :
    |z i - x i| ≤ dist z x := by
  simpa only [Real.dist_eq] using PiLp.dist_apply_le z x i

theorem box_subset_of_meets_ball (Q : DyadicSquare) (x : Plane) {r w : ℝ}
    (hside : Q.side = w) (hr : r ≤ w)
    (hmeet : (Q.carrier ∩ ball x r).Nonempty) :
    Q.box ⊆ Icc (x 0-2*w) (x 0+2*w) ×ˢ Icc (x 1-2*w) (x 1+2*w) := by
  obtain ⟨z,hz,hball⟩ := hmeet
  have h0 := (plane_coordinate_dist_le z x 0).trans_lt hball
  have h1 := (plane_coordinate_dist_le z x 1).trans_lt hball
  have hx0 := abs_lt.mp h0
  have hx1 := abs_lt.mp h1
  intro u hu
  simp only [DyadicSquare.box, mem_prod, mem_Ico] at hu
  simp only [DyadicSquare.carrier, mem_ofPred_eq] at hz
  simp only [mem_prod, mem_Icc]
  rw [hside] at hz hu
  constructor <;> constructor <;> linarith [hu.1.1,hu.1.2,hu.2.1,hu.2.2,
    hz.1,hz.2.1,hz.2.2.1,hz.2.2.2,hx0.1,hx0.2,hx1.1,hx1.2]

noncomputable def cellsMeeting (Q : DyadicSquare) (n : ℕ) (x : Plane) (r : ℝ) :
    Finset (List (Bool × Bool)) := by
  classical
  exact (dyadicPaths n).filter fun p =>
    ((Q.descendant p).carrier ∩ ball x r).Nonempty

theorem dyadic_ball_card_le (Q : DyadicSquare) (hQ : 0 < Q.side)
    (n : ℕ) (x : Plane) {r : ℝ} (hr : r ≤ Q.side/(2 : ℝ)^n) :
    (cellsMeeting Q n x r).card ≤ 16 := by
  classical
  let S := (dyadicPaths n).filter fun p =>
    ((Q.descendant p).carrier ∩ ball x r).Nonempty
  let w := Q.side/(2 : ℝ)^n
  have hw : 0 < w := by dsimp [w]; positivity
  have hlen {path : List (Bool × Bool)} (hp : path ∈ S) : path.length = n :=
    (mem_dyadicPaths n path).mp (Finset.mem_filter.mp hp).1
  have hside {path : List (Bool × Bool)} (hp : path ∈ S) :
      (Q.descendant path).side = w := by
    rw [Q.descendant_side, hlen hp]
  have hdis : PairwiseDisjoint (S : Set (List (Bool × Bool)))
      (fun p => (Q.descendant p).box) := by
    intro p hp q hq hpq
    exact Q.boxes_disjoint hQ ((hlen hp).trans (hlen hq).symm) hpq
  have harea : (∑ p ∈ S, ENNReal.ofReal w * ENNReal.ofReal w) ≤
      ENNReal.ofReal (4*w) * ENNReal.ofReal (4*w) := by
    calc
      _ = ∑ p ∈ S, (volume.prod volume) (Q.descendant p).box := by
        apply Finset.sum_congr rfl
        intro p hp
        rw [DyadicSquare.box_area, hside hp]
      _ = (volume.prod volume) (⋃ p ∈ S, (Q.descendant p).box) :=
        (measure_biUnion_finset hdis (fun p _ => (Q.descendant p).box_measurable)).symm
      _ ≤ (volume.prod volume)
          (Icc (x 0-2*w) (x 0+2*w) ×ˢ Icc (x 1-2*w) (x 1+2*w)) := by
        apply measure_mono
        intro u hu
        obtain ⟨p,hp,hu⟩ := mem_iUnion₂.mp hu
        exact box_subset_of_meets_ball _ x (hside hp) hr
          (Finset.mem_filter.mp hp).2 hu
      _ = _ := by
        rw [Measure.prod_prod, Real.volume_Icc, Real.volume_Icc]
        congr 2 <;> ring
  have hreal := ENNReal.toReal_mono (ENNReal.mul_ne_top ENNReal.ofReal_ne_top ENNReal.ofReal_ne_top) harea
  simp only [Finset.sum_const, nsmul_eq_mul, ENNReal.toReal_mul,
    ENNReal.toReal_natCast, ENNReal.toReal_ofReal hw.le,
    ENNReal.toReal_ofReal (by positivity : 0 ≤ 4*w)] at hreal
  have hcard : (S.card : ℝ) ≤ 16 := by
    by_contra h
    have hpos := mul_pos (show 0 < (S.card : ℝ)-16 by linarith) (mul_pos hw hw)
    nlinarith [hreal]

  exact_mod_cast hcard

theorem dyadic_ball_measure_le (Q : DyadicSquare) (hQ : 0 < Q.side)
    (μ : Measure Plane) (hcarry : μ Q.carrierᶜ = 0)
    (s C : ℝ) (hC : 0 ≤ C) (n : ℕ)
    (hb : ∀ p : List (Bool × Bool), p.length = n →
      μ (Q.descendant p).carrier ≤ ENNReal.ofReal (C*(Q.descendant p).side^s))
    (x : Plane) {r : ℝ} (hr : r ≤ Q.side/(2 : ℝ)^n) :
    μ (ball x r) ≤ ENNReal.ofReal (16*C*(Q.side/(2 : ℝ)^n)^s) := by
  classical
  let S := (dyadicPaths n).filter fun p =>
    ((Q.descendant p).carrier ∩ ball x r).Nonempty
  have hcover : ball x r ⊆ (⋃ p ∈ S, (Q.descendant p).carrier) ∪ Q.carrierᶜ := by
    intro z hz
    by_cases hQz : z ∈ Q.carrier
    · obtain ⟨p,hp,hzp⟩ := Q.mem_descendant_at_depth n hQz
      exact Or.inl (mem_iUnion₂.mpr ⟨p,Finset.mem_filter.mpr ⟨hp,⟨z,hzp,hz⟩⟩,hzp⟩)
    · exact Or.inr hQz
  calc
    μ (ball x r) ≤ μ ((⋃ p ∈ S, (Q.descendant p).carrier) ∪ Q.carrierᶜ) := measure_mono hcover
    _ ≤ μ (⋃ p ∈ S, (Q.descendant p).carrier) + μ Q.carrierᶜ := measure_union_le _ _
    _ = μ (⋃ p ∈ S, (Q.descendant p).carrier) := by rw [hcarry, add_zero]
    _ ≤ ∑ p ∈ S, μ (Q.descendant p).carrier := measure_biUnion_finset_le _ _
    _ ≤ ∑ p ∈ S, ENNReal.ofReal (C*(Q.side/(2 : ℝ)^n)^s) := by
      apply Finset.sum_le_sum
      intro p hp
      have hl := (mem_dyadicPaths n p).mp (Finset.mem_filter.mp hp).1
      simpa only [Q.descendant_side, hl] using hb p hl
    _ ≤ (16 : ℝ≥0∞) * ENNReal.ofReal (C*(Q.side/(2 : ℝ)^n)^s) := by
      simp only [Finset.sum_const, nsmul_eq_mul]
      exact mul_le_mul_left (by exact_mod_cast dyadic_ball_card_le Q hQ n x hr) _
    _ = _ := by
      rw [show (16 : ℝ≥0∞) = ENNReal.ofReal (16 : ℝ) by norm_num,
        ← ENNReal.ofReal_mul' (mul_nonneg hC (Real.rpow_nonneg (by positivity) _))]
      congr 1
      ring

end PlanarFalconer

end OAI