import OAI.Combinatorics.BalancedRyser.Selection.Selection
import OAI.Combinatorics.BalancedRyser.Selection.SelectionThinning

namespace OAI

open scoped BigOperators Classical

namespace Balanced.Selection

noncomputable section

variable {I V : Type*} [Fintype I] [Fintype V]

def vertexDrawMass (G : Input I V) (v : V) : ℝ :=
  (Fintype.card I : ℝ)⁻¹ * ((slotVertices G (G.slot v)).card : ℝ)⁻¹

lemma vertexDrawMass_nonneg (G : Input I V) (v : V) : 0 ≤ vertexDrawMass G v := by
  unfold vertexDrawMass
  positivity

lemma vertexDrawMass_in_slot (G : Input I V) (i : I) (v : V) (hv : v ∈ slotVertices G i) :
    vertexDrawMass G v = (Fintype.card I : ℝ)⁻¹ * ((slotVertices G i).card : ℝ)⁻¹ := by
  have hs : G.slot v = i := (Finset.mem_filter.mp hv).2
  simp [vertexDrawMass, hs]

lemma vertexDrawMass_fiber (G : Input I V) (i : I) (hi : (slotVertices G i).Nonempty) :
    (∑ v ∈ slotVertices G i, vertexDrawMass G v) = (Fintype.card I : ℝ)⁻¹ := by
  have hc : ((slotVertices G i).card : ℝ) ≠ 0 := by
    exact_mod_cast (Finset.card_pos.mpr hi).ne'
  calc
    _ = ∑ _v ∈ slotVertices G i,
      (Fintype.card I : ℝ)⁻¹ * ((slotVertices G i).card : ℝ)⁻¹ := by
      apply Finset.sum_congr rfl
      exact fun v hv => vertexDrawMass_in_slot G i v hv
    _ = _ := by
      rw [Finset.sum_const, nsmul_eq_mul]
      field_simp

lemma sum_vertexDrawMass [Nonempty I] (G : Input I V)
    (hslots : ∀ i, (slotVertices G i).Nonempty) :
    (∑ v, vertexDrawMass G v) = 1 := by
  have hf := Finset.sum_fiberwise Finset.univ G.slot (vertexDrawMass G)
  change (∑ i, ∑ v ∈ slotVertices G i, vertexDrawMass G v) = _ at hf
  rw [← hf]
  simp only [vertexDrawMass_fiber G _ (hslots _), Finset.sum_const,
    Finset.card_univ, nsmul_eq_mul]
  have hc : (Fintype.card I : ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero
  exact mul_inv_cancel₀ hc

lemma vertexDrawMass_slot (G : Input I V) (hslots : ∀ i, (slotVertices G i).Nonempty)
    (i : I) :
    SelectionThinning.eventMass (vertexDrawMass G) (fun v => G.slot v = i) =
      (Fintype.card I : ℝ)⁻¹ := by
  unfold SelectionThinning.eventMass
  rw [← Finset.sum_filter]
  exact vertexDrawMass_fiber G i (hslots i)

def conflictHazard (G : Input I V) (u : V) : ℝ :=
  SelectionThinning.eventMass (vertexDrawMass G) (G.graph.Adj u)

lemma conflictHazard_nonneg (G : Input I V) (u : V) : 0 ≤ conflictHazard G u := by
  apply Finset.sum_nonneg
  intro v _
  split
  · exact vertexDrawMass_nonneg G v
  · exact le_rfl

lemma conflictHazard_eq (G : Input I V) (u : V) :
    conflictHazard G u = (Fintype.card I : ℝ)⁻¹ *
      ∑ i, (((neighbors G u ∩ slotVertices G i).card : ℝ) /
        ((slotVertices G i).card : ℝ)) := by
  unfold conflictHazard SelectionThinning.eventMass
  rw [← Finset.sum_filter]
  change (∑ v ∈ neighbors G u, vertexDrawMass G v) = _
  have hf := Finset.sum_fiberwise (neighbors G u) G.slot (vertexDrawMass G)
  rw [← hf, Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro i _
  have he : (neighbors G u).filter (fun v => G.slot v = i) =
      neighbors G u ∩ slotVertices G i := by
    ext v
    simp [slotVertices]
  rw [he]
  calc
    _ = ∑ _v ∈ neighbors G u ∩ slotVertices G i,
        (Fintype.card I : ℝ)⁻¹ * ((slotVertices G i).card : ℝ)⁻¹ := by
      apply Finset.sum_congr rfl
      intro v hv
      exact vertexDrawMass_in_slot G i v (Finset.mem_inter.mp hv).2
    _ = _ := by simp only [Finset.sum_const, nsmul_eq_mul, div_eq_mul_inv]; ring

def nextStepMass (G : Input I V) (α : ℝ) (w : V) (b : V → Bool) : ℝ :=
  SelectionThinning.jointMass (vertexDrawMass G)
    (fun u => SelectionThinning.thinningRate α (conflictHazard G u)) w b

lemma nextStepMass_nonneg (G : Input I V) (α : ℝ) (ha : α < 1)
    (hcheck : ∀ u, conflictHazard G u ≤ α) (w : V) (b : V → Bool) :
    0 ≤ nextStepMass G α w b := by
  apply SelectionThinning.jointMass_nonneg _ (vertexDrawMass_nonneg G)
  intro u
  have hb := SelectionThinning.thinningRate_bounds (conflictHazard_nonneg G u) (hcheck u) ha
  exact ⟨hb.1, hb.2.trans ha.le⟩

lemma sum_nextStepMass [Nonempty I] (G : Input I V)
    (hslots : ∀ i, (slotVertices G i).Nonempty) (α : ℝ) :
    (∑ w, ∑ b, nextStepMass G α w b) = 1 :=
  SelectionThinning.sum_jointMass _ (sum_vertexDrawMass G hslots) _

def stepLaw [Nonempty I] (G : Input I V)
    (hslots : ∀ i, (slotVertices G i).Nonempty) (α : ℝ) (ha : α < 1)
    (hcheck : ∀ u, conflictHazard G u ≤ α) : PMF (V × (V → Bool)) :=
  PMF.ofFintype (fun z => ENNReal.ofReal (nextStepMass G α z.1 z.2)) (by
    rw [← ENNReal.ofReal_sum_of_nonneg
      (fun z _ => nextStepMass_nonneg G α ha hcheck z.1 z.2)]
    rw [Fintype.sum_prod_type, sum_nextStepMass G hslots]
    simp)

@[simp] lemma stepLaw_apply [Nonempty I] (G : Input I V)
    (hslots : ∀ i, (slotVertices G i).Nonempty) (α : ℝ) (ha : α < 1)
    (hcheck : ∀ u, conflictHazard G u ≤ α) (z : V × (V → Bool)) :
    stepLaw G hslots α ha hcheck z = ENNReal.ofReal (nextStepMass G α z.1 z.2) := rfl

lemma nextStep_pre_survival [Nonempty I] (G : Input I V)
    (hslots : ∀ i, (slotVertices G i).Nonempty) (α : ℝ) (ha : α < 1)
    (hcheck : ∀ u, conflictHazard G u ≤ α) (u : V) :
    (∑ w, ∑ b : V → Bool,
      if ¬ G.graph.Adj u w ∧ b u = false then nextStepMass G α w b else 0) = 1 - α := by
  have h := SelectionThinning.pre_removal_survival (vertexDrawMass G)
    (sum_vertexDrawMass G hslots) (fun w v => G.graph.Adj v w) α
    (fun v => lt_of_le_of_lt (hcheck v) ha) u
  convert h using 1
  apply Finset.sum_congr (by ext; simp)
  intro w _
  apply Finset.sum_congr (by ext; simp)
  intro b _
  by_cases he : ¬ G.graph.Adj u w ∧ b u = false <;>
    simp [he, nextStepMass, conflictHazard]

lemma nextStep_post_survival_le [Nonempty I] (G : Input I V)
    (hslots : ∀ i, (slotVertices G i).Nonempty)
    (hwithin : ∀ u w, G.slot u = G.slot w → ¬ G.graph.Adj u w)
    (α : ℝ) (ha : α < 1) (hcheck : ∀ u, conflictHazard G u ≤ α) (u : V) :
    (∑ w, ∑ b : V → Bool,
      if (¬ G.graph.Adj u w ∧ G.slot w ≠ G.slot u) ∧ b u = false then
        nextStepMass G α w b else 0) ≤
        (1 - α) * (1 - (Fintype.card I : ℝ)⁻¹) := by
  have h := SelectionThinning.post_removal_survival_le (vertexDrawMass G)
    (sum_vertexDrawMass G hslots) (fun w v => G.graph.Adj v w)
    (fun w v => G.slot w = G.slot v) (fun w v he => hwithin v w he.symm)
    α (Fintype.card I : ℝ)⁻¹ (by positivity) ha (conflictHazard_nonneg G)
    hcheck (fun v => vertexDrawMass_slot G hslots (G.slot v)) u
  convert h using 1
  apply Finset.sum_congr (by ext; simp)
  intro w _
  apply Finset.sum_congr (by ext; simp)
  intro b _
  by_cases he : (¬ G.graph.Adj u w ∧ G.slot w ≠ G.slot u) ∧ b u = false <;>
    simp [he, nextStepMass, conflictHazard]

end
end Balanced.Selection

end OAI