import OAI.Probability.RadialTransition.FreeGeometry

namespace OAI

noncomputable section
open scoped BigOperators ENNReal NNReal
open MeasureTheory Set Filter
namespace RadialTransition

lemma starWeight_ge_one {A : Set Position} {r : ℝ} {s : Multiset Position} {x : Position}
    (hx : x ∈ s) (hA : x ∈ A) (hr : ∀ y ∈ s, y ∈ nearCube r x) :
    1 ≤ starWeight A r s := by
  have hp : (s.map (nearMask r x)).prod = 1 := by
    apply Multiset.prod_eq_one
    intro a ha
    obtain ⟨y,hy,rfl⟩ := Multiset.mem_map.mp ha
    exact indicator_of_mem (hr y hy) _
  have hs := Multiset.single_le_sum (fun _ _ => (bot_le : (0:ℝ≥0∞) ≤ _))
    _ (Multiset.mem_map.mpr ⟨x,hx,rfl⟩ : regionMask A x*(s.map (nearMask r x)).prod ∈
      s.map (fun y => regionMask A y*(s.map (nearMask r y)).prod))
  simpa only [hp, regionMask, indicator_of_mem hA, mul_one, starWeight] using hs

lemma cellClusterWeight_empty (t α r : ℝ) (k : Cell) : 1 ≤ cellClusterWeight t α r k 0 := by
  simp [cellClusterWeight, emptyWeight, starWeight]

lemma cellClusterWeight_ge {t α r : ℝ} {k : Cell} {s : Multiset Position}
    (hc : s.card ≤ 4) {x : Position} (hx : x ∈ s) (hk : cellOf x=k)
    (hr : ∀ y ∈ s, y ∈ nearCube r x) :
    ENNReal.ofReal (Real.exp (-t*α)) ≤ cellClusterWeight t α r k s := by
  have hh := mul_le_mul' (le_rfl : ENNReal.ofReal (Real.exp (-t*α)) ≤ _) (starWeight_ge_one hx (show x ∈ gridRegion k from hk) hr)
  rw [mul_one] at hh
  exact hh.trans (by simp only [cellClusterWeight, ite_eq_left hc]; exact le_add_self)

lemma coreFree_cell_cover {ι : Type} [Fintype ι] {t α L : ℝ} {x : ι → Position}
    (hx : CoreFree t x) (ht : 2*((1+(1:ℝ)/1000)*microLength t) < 1)
    (hbox : ∀ i, x i ∈ cube L) (hta : 0 ≤ t*α) :
    ENNReal.ofReal (Real.exp (-t*α*(packingNumber L:ℝ))) ≤
      indexedClusterProduct (fun k : cubeCells L =>
        cellClusterWeight t α ((1+(1:ℝ)/1000)*microLength t) k.val) (configurationMultiset x) := by
  classical
  let Q := Quotient (coreFreeSetoid hx ht)
  let S (q : Q) := Finset.univ.filter (fun i => Quotient.mk (coreFreeSetoid hx ht) i = q)
  let s (q : Q) := (S q).val.map x
  let f (q : Q) : cubeCells L := ⟨cellOf (x q.out), cellOf_mem_cubeCells (hbox _)⟩
  let W (k : cubeCells L) := cellClusterWeight t α ((1+(1:ℝ)/1000)*microLength t) k.val
  have hroot := coreFree_roots hx ht hbox
  have hf : Function.Injective f := by
    intro q q' he
    exact hroot.2 (congrArg Subtype.val he)
  have hsum : ∑ q, s q = configurationMultiset x := by
    convert configurationMultiset_fibers x (Quotient.mk (coreFreeSetoid hx ht)) using 1
    apply Finset.sum_congr rfl
    intro q _
    dsimp [s, S]
    congr 1
    ext i
    simp only [Multiset.count_filter]
    split_ifs <;> rfl
  have hW (q : Q) : ENNReal.ofReal (Real.exp (-t*α)) ≤ W (f q) (s q) := by
    apply cellClusterWeight_ge
    · simpa only [s, Multiset.card_map, S, Finset.card_def] using coreFree_fiber_card hx ht q
    · apply Multiset.mem_map.mpr
      refine ⟨q.out, ?_, rfl⟩
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, Quotient.out_eq q⟩
    · rfl
    · intro y hy
      obtain ⟨j,hj,rfl⟩ := Multiset.mem_map.mp hy
      have hjq : Quotient.mk (coreFreeSetoid hx ht) j = q := (Finset.mem_filter.mp hj).2
      have hd : dist (x j) (x q.out) < 1 := Quotient.exact (hjq.trans (Quotient.out_eq q).symm)
      intro d
      simpa only [Real.dist_eq] using (PiLp.dist_apply_le (x j) (x q.out) d).trans (hx.dist_bound j q.out hd)
  have hprod : ENNReal.ofReal (Real.exp (-t*α*(Fintype.card Q:ℝ))) ≤ ∏ q, W (f q) (s q) := by
    have hh := Finset.prod_le_prod (fun q (_ : q ∈ (Finset.univ : Finset Q)) => hW q)
    simp only [Finset.prod_const, Finset.card_univ] at hh
    rw [← ENNReal.ofReal_pow (Real.exp_pos _).le, ← Real.exp_nat_mul] at hh
    rw [mul_comm (Fintype.card Q : ℝ)] at hh
    exact hh
  have hcount : ENNReal.ofReal (Real.exp (-t*α*(packingNumber L:ℝ))) ≤
      ENNReal.ofReal (Real.exp (-t*α*(Fintype.card Q:ℝ))) := by
    apply ENNReal.ofReal_le_ofReal
    apply Real.exp_le_exp.mpr
    have hc : (Fintype.card Q:ℝ) ≤ packingNumber L := by exact_mod_cast hroot.1
    nlinarith
  have hcover := indexedClusterProduct_embedding W (fun k => cellClusterWeight_empty _ _ _ _) f hf s
  rw [hsum] at hcover
  exact hcount.trans (hprod.trans hcover)

end RadialTransition
end

end OAI