import OAI.Combinatorics.BalancedRyser.Candidates.Candidates
import OAI.Combinatorics.BalancedRyser.Incidence.AffineIncidence
import OAI.Combinatorics.BalancedRyser.Probability.VacantBins

namespace OAI

namespace Balanced.LineOccupancy

open scoped BigOperators

variable {F : Type*} [Field F]

def transverseHitEquiv (l : Line F) (d : Direction F) (hne : l.1 ≠ d) :
    F ≃ {p : Point F // OnLine p l} where
  toFun a := ⟨lineIntersection l (d, a), onLine_lineIntersection_left l (d, a) hne⟩
  invFun p := lineEval d p.val
  left_inv a := onLine_lineIntersection_right l (d, a) hne
  right_inv p := by
    apply Subtype.ext
    apply common_point_eq_of_lines_ne l (d, lineEval d p.val)
      (fun h => hne (congrArg Prod.fst h))
    · exact onLine_lineIntersection_left _ _ hne
    · exact onLine_lineIntersection_right _ _ hne
    · exact p.property
    · rfl

theorem transverseHitEquiv_eq_iff (l : Line F) (d : Direction F)
    (hne : l.1 ≠ d) (a : F) (p : {p : Point F // OnLine p l}) :
    transverseHitEquiv l d hne a = p ↔ OnLine p.val (d, a) := by
  rw [← Equiv.eq_symm_apply]
  change a = lineEval d p.val ↔ lineEval d p.val = a
  exact eq_comm

variable [Fintype F] [DecidableEq F]

abbrev TransverseDirections (l : Line F) := {d : Direction F // d ≠ l.1}

omit [Field F] in
@[simp] theorem card_transverseDirections (l : Line F) :
    Fintype.card (TransverseDirections l) = Fintype.card F := by
  simp [TransverseDirections, Fintype.card_subtype_compl]

def hitAssignmentsEquiv (l : Line F) :
    (TransverseDirections l → F) ≃
      (TransverseDirections l → {p : Point F // OnLine p l}) :=
  Equiv.piCongrRight fun d => transverseHitEquiv l d.val (Ne.symm d.property)

noncomputable def unhitCount (l : Line F) (a : TransverseDirections l → F) : ℕ := by
  classical
  exact (Finset.univ.filter (fun p : {p : Point F // OnLine p l} =>
    ∀ d : TransverseDirections l, ¬ OnLine p.val (d.val, a d))).card

theorem unhitCount_eq_missedCount (l : Line F) (a : TransverseDirections l → F) :
    unhitCount l a = VacantBins.missedCount (hitAssignmentsEquiv l a) := by
  classical
  unfold unhitCount VacantBins.missedCount
  congr 1
  ext p
  simp only [Finset.mem_filter, Finset.mem_univ, true_and, VacantBins.mem_missed]
  apply forall_congr'
  intro d
  exact not_congr (transverseHitEquiv_eq_iff l d.val (Ne.symm d.property) (a d) p).symm

theorem unhitCount_eq_filter_card (l : Line F) (a : TransverseDirections l → F) :
    unhitCount l a = ((linePoints l).filter
      (fun p => ∀ d : TransverseDirections l, ¬ OnLine p (d.val, a d))).card := by
  classical
  unfold unhitCount
  refine Finset.card_bij (fun p _ => p.val) ?_ ?_ ?_
  · intro p hp
    simp only [Finset.mem_filter, Finset.mem_univ, true_and] at hp
    simp only [Finset.mem_filter, linePoints, Finset.mem_univ, true_and]
    exact ⟨p.property, hp⟩
  · intro p hp r hr h
    exact Subtype.ext h
  · intro p hp
    simp only [Finset.mem_filter, linePoints, Finset.mem_univ, true_and] at hp
    refine ⟨⟨p, hp.1⟩, ?_, rfl⟩
    simpa only [Finset.mem_filter, Finset.mem_univ, true_and] using hp.2

def transverseOffsets (l : Line F) (M : MergedPairs F) : TransverseDirections l → F :=
  fun d => M d.val true

theorem unhitCount_eq_initiallyRetained (l : Line F) (M : MergedPairs F)
    (hl : l ∉ initialDeletedLines M) :
    unhitCount l (transverseOffsets l M) = (linePoints l ∩ initiallyRetained M).card := by
  classical
  rw [unhitCount_eq_filter_card]
  congr 1
  ext p
  simp only [Finset.mem_filter, Finset.mem_inter, initiallyRetained,
    Finset.mem_univ, true_and]
  constructor
  · rintro ⟨hp, ht⟩
    refine ⟨hp, ?_⟩
    intro k hk
    rcases Finset.mem_image.mp hk with ⟨d, _, rfl⟩
    by_cases hd : d = l.1
    · intro hpd
      have hpl : OnLine p l := (Finset.mem_filter.mp hp).2
      have heq : l = constituent M d true :=
        eq_of_onLine_same_direction p l (constituent M d true) hd.symm hpl hpd
      apply hl
      rw [heq]
      exact Finset.mem_image.mpr ⟨d, Finset.mem_univ d, rfl⟩
    · exact ht ⟨d, hd⟩
  · rintro ⟨hp, ht⟩
    refine ⟨hp, ?_⟩
    intro d
    exact ht (constituent M d.val true)
      (Finset.mem_image.mpr ⟨d.val, Finset.mem_univ _, rfl⟩)

theorem uniformMean_unhitCount (l : Line F) :
    VacantBins.uniformMean (fun a : TransverseDirections l → F => (unhitCount l a : ℝ)) =
      (Fintype.card F : ℝ) * (1 - 1 / (Fintype.card F : ℝ)) ^ Fintype.card F := by
  classical
  let : Nonempty {p : Point F // OnLine p l} := ⟨(linePointsEquiv l).symm 0⟩
  simp_rw [unhitCount_eq_missedCount]
  rw [VacantBins.uniformMean_equiv (hitAssignmentsEquiv l)
    (fun f => (VacantBins.missedCount f : ℝ))]
  rw [VacantBins.uniformMean_missedCount, card_transverseDirections,
    Fintype.card_congr (linePointsEquiv l)]

theorem integral_unhitCount (l : Line F)
    [MeasurableSpace (TransverseDirections l → F)]
    [MeasurableSingletonClass (TransverseDirections l → F)] :
    (∫ a : TransverseDirections l → F, (unhitCount l a : ℝ)
      ∂(PMF.uniformOfFintype (TransverseDirections l → F)).toMeasure) =
      (Fintype.card F : ℝ) * (1 - 1 / (Fintype.card F : ℝ)) ^ Fintype.card F := by
  rw [VacantBins.integral_uniform_eq_uniformMean, uniformMean_unhitCount]

theorem abs_unhitCount_sub_le_one (l : Line F)
    (a b : TransverseDirections l → F) (j : TransverseDirections l)
    (hab : ∀ i, i ≠ j → a i = b i) :
    |(unhitCount l a : ℝ) - (unhitCount l b : ℝ)| ≤ 1 := by
  simp_rw [unhitCount_eq_missedCount]
  apply VacantBins.abs_missedCount_sub_le_one _ _ j
  intro i hi
  change transverseHitEquiv l i.val (Ne.symm i.property) (a i) =
    transverseHitEquiv l i.val (Ne.symm i.property) (b i)
  rw [hab i hi]

end Balanced.LineOccupancy

end OAI