import OAI.Probability.MatroidProphet.Rounding
import OAI.Probability.MatroidProphet.Candidates

namespace OAI

namespace MatroidProphet
namespace Maximum

open MeasureTheory Finset Set

variable {n bits : ℕ} {K : Type*} [Countable K] [MeasurableSpace K]
  [MeasurableSingletonClass K]

noncomputable def firstRule (key : ℝ → K) (hkey : Measurable key)
    (allowed : Seed bits → (Fin n → K) → (Fin n × K) → Prop) : OnlineRule n bits := by
  classical
  exact discreteOnlineRule key hkey (fun k r s hist => decide
    (allowed r s (hist ⟨k.val, Nat.lt_succ_self _⟩) ∧
      ∀ j : Fin (k.val + 1), j.val < k.val → ¬ allowed r s (hist j)))

lemma firstRule_decision (key : ℝ → K) (hkey : Measurable key)
    (allowed : Seed bits → (Fin n → K) → (Fin n × K) → Prop)
    (r : Seed bits) (s v : Weights n) (π : ArrivalOrder n) (k : Fin n) :
    decisionAt (firstRule key hkey allowed) r s v π k = true ↔
      allowed r (fun e => key (s e)) (π k, key (v (π k))) ∧
      ∀ i : Fin n, i.val < k.val →
        ¬ allowed r (fun e => key (s e)) (π i, key (v (π i))) := by
  classical
  change decide (allowed r (fun e => key (s e)) (π k, key (v (π k))) ∧
    ∀ j : Fin (k.val + 1), j.val < k.val →
      ¬ allowed r (fun e => key (s e))
        (π (prefixIndex k j), key (v (π (prefixIndex k j))))) = true ↔ _
  rw [decide_eq_true_eq]
  constructor
  · rintro ⟨hc, hp⟩
    refine ⟨hc, fun i hi => ?_⟩
    exact hp ⟨i.val, by omega⟩ hi
  · rintro ⟨hc, hp⟩
    exact ⟨hc, fun j hj => hp (prefixIndex k j) hj⟩

lemma firstRule_unique (key : ℝ → K) (hkey : Measurable key)
    (allowed : Seed bits → (Fin n → K) → (Fin n × K) → Prop)
    (r : Seed bits) (s v : Weights n) (π : ArrivalOrder n) (t : ℕ)
    {e f : Fin n}
    (he : e ∈ acceptedThrough (firstRule key hkey allowed) r s v π t)
    (hf : f ∈ acceptedThrough (firstRule key hkey allowed) r s v π t) : e = f := by
  have he' := (firstRule_decision key hkey allowed r s v π (π.symm e)).1
    ((Finset.mem_filter.mp he).2).2
  have hf' := (firstRule_decision key hkey allowed r s v π (π.symm f)).1
    ((Finset.mem_filter.mp hf).2).2
  rcases lt_trichotomy (π.symm e).val (π.symm f).val with hlt | heq | hgt
  · exact False.elim (hf'.2 (π.symm e) hlt he'.1)
  · exact π.symm.injective (Fin.ext heq)
  · exact False.elim (he'.2 (π.symm f) hgt hf'.1)

lemma firstRule_feasible (M : Matroid (Fin n)) (key : ℝ → K) (hkey : Measurable key)
    (allowed : Seed bits → (Fin n → K) → (Fin n × K) → Prop)
    (ha : ∀ r s x, allowed r s x → M.Indep ({x.1} : Set (Fin n))) :
    Feasible M (firstRule key hkey allowed) := by
  intro r s v π t _ _
  classical
  by_cases h : (acceptedThrough (firstRule key hkey allowed) r s v π t).Nonempty
  · obtain ⟨e, he⟩ := h
    have ha' := (firstRule_decision key hkey allowed r s v π (π.symm e)).1
      ((Finset.mem_filter.mp he).2).2
    have hi : M.Indep ({e} : Set (Fin n)) := by
      simpa only [Equiv.apply_symm_apply] using ha r (fun f => key (s f)) _ ha'.1
    apply hi.subset
    intro f hf
    exact Set.mem_singleton_iff.mpr (firstRule_unique key hkey allowed r s v π t hf he)
  · have he : acceptedThrough (firstRule key hkey allowed) r s v π t = ∅ :=
      Finset.not_nonempty_iff_eq_empty.mp h
    simp [he]

lemma firstRule_single_qualifier (key : ℝ → K) (hkey : Measurable key)
    (allowed : Seed bits → (Fin n → K) → (Fin n × K) → Prop)
    (r : Seed bits) (s v : Weights n) (g : Fin n)
    (ha : ∀ e, allowed r (fun f => key (s f)) (e, key (v e)) ↔ e = g)
    (π : ArrivalOrder n) : accepted (firstRule key hkey allowed) r s v π = {g} := by
  classical
  ext e
  simp only [accepted, acceptedThrough, Finset.mem_filter, Finset.mem_univ, true_and,
    Finset.mem_singleton]
  constructor
  · rintro ⟨_, hd⟩
    have hc := ((firstRule_decision key hkey allowed r s v π (π.symm e)).1 hd).1
    exact (ha e).1 (by simpa using hc)
  · intro heg
    subst e
    refine ⟨(π.symm g).isLt, (firstRule_decision key hkey allowed r s v π (π.symm g)).2 ?_⟩
    constructor
    · simpa using (ha g).2 rfl
    · intro i hi hallowed
      have heq : π i = g := (ha (π i)).1 hallowed
      have hieq : i = π.symm g := by simpa using congrArg π.symm heq
      exact Nat.lt_irrefl _ (hieq ▸ hi)

def higher [LinearOrder K] (x y : Fin n × K) : Prop :=
  y.2 < x.2 ∨ (x.2 = y.2 ∧ x.1 < y.1)

def threshold [LinearOrder K] (M : Matroid (Fin n)) (active : K → Prop)
    (mask : Seed bits → Finset (Fin n)) (r : Seed bits) (s : Fin n → K)
    (x : Fin n × K) : Prop :=
  x.1 ∉ mask r ∧ M.Indep ({x.1} : Set (Fin n)) ∧ active x.2 ∧
    ∀ f ∈ mask r, M.Indep ({f} : Set (Fin n)) → active (s f) → higher x (f, s f)

noncomputable def maximumRule [LinearOrder K] (M : Matroid (Fin n))
    (key : ℝ → K) (hkey : Measurable key) (active : K → Prop)
    (mask : Seed bits → Finset (Fin n)) : OnlineRule n bits :=
  firstRule key hkey (threshold M active mask)

lemma maximumRule_feasible [LinearOrder K] (M : Matroid (Fin n))
    (key : ℝ → K) (hkey : Measurable key) (active : K → Prop)
    (mask : Seed bits → Finset (Fin n)) : Feasible M (maximumRule M key hkey active mask) :=
  firstRule_feasible M key hkey _ (fun _ _ _ hx => hx.2.1)

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in
lemma higher_irrefl [LinearOrder K] (x : Fin n × K) : ¬ higher x x := by
  simp [higher]

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in
lemma higher_trans [LinearOrder K] {x y z : Fin n × K}
    (hxy : higher x y) (hyz : higher y z) : higher x z := by
  rcases hxy with hxy | ⟨hxy, hxy'⟩ <;> rcases hyz with hyz | ⟨hyz, hyz'⟩
  · exact Or.inl (hyz.trans hxy)
  · exact Or.inl (hyz ▸ hxy)
  · exact Or.inl (hxy ▸ hyz)
  · exact Or.inr ⟨hxy.trans hyz, hxy'.trans hyz'⟩

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in
lemma higher_total [LinearOrder K] {x y : Fin n × K} (h : x ≠ y) :
    higher x y ∨ higher y x := by
  rcases lt_trichotomy x.2 y.2 with hlt | heq | hgt
  · exact Or.inr (Or.inl hlt)
  · have hn : x.1 ≠ y.1 := fun hxy => h (Prod.ext hxy heq)
    rcases lt_or_gt_of_ne hn with hxy | hyx
    · exact Or.inl (Or.inr ⟨heq, hxy⟩)
    · exact Or.inr (Or.inr ⟨heq.symm, hyx⟩)
  · exact Or.inl (Or.inl hgt)

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in

lemma threshold_top_two [LinearOrder K] (M : Matroid (Fin n))
    (active : K → Prop) (mask : Seed bits → Finset (Fin n))
    (r : Seed bits) (a : Fin n → K) (g h : Fin n)
    (hg : M.Indep ({g} : Set (Fin n))) (hag : active (a g))
    (hh : M.Indep ({h} : Set (Fin n))) (hah : active (a h))
    (htop : ∀ f, M.Indep ({f} : Set (Fin n)) → active (a f) → f ≠ g →
      higher (g, a g) (f, a f))
    (hsecond : ∀ f, M.Indep ({f} : Set (Fin n)) → active (a f) → f ≠ g → f ≠ h →
      higher (h, a h) (f, a f))
    (hgm : g ∉ mask r) (hhm : h ∈ mask r) :
    ∀ e, threshold M active mask r a (e, a e) ↔ e = g := by
  intro e
  constructor
  · intro he
    by_contra heg
    have heh : e ≠ h := fun heq => he.1 (heq ▸ hhm)
    have heh' := he.2.2.2 h hhm hh hah
    exact higher_irrefl _ (higher_trans heh' (hsecond e he.2.1 he.2.2.1 heg heh))
  · rintro rfl
    refine ⟨hgm, hg, hag, ?_⟩
    intro f hfm hf haf
    exact htop f hf haf (fun hfg => hgm (hfg ▸ hfm))

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in
lemma threshold_congr_samples [LinearOrder K] (M : Matroid (Fin n))
    (active : K → Prop) (mask : Seed bits → Finset (Fin n)) (r : Seed bits)
    (s t : Fin n → K) (hst : ∀ f ∈ mask r, s f = t f) (x : Fin n × K) :
    threshold M active mask r s x ↔ threshold M active mask r t x := by
  unfold threshold
  constructor <;> rintro ⟨hm, hi, ha, h⟩ <;> refine ⟨hm, hi, ha, ?_⟩
  · intro f hf hfi hfa
    simpa only [hst f hf] using h f hf hfi (by simpa only [hst f hf] using hfa)
  · intro f hf hfi hfa
    simpa only [hst f hf] using h f hf hfi (by simpa only [hst f hf] using hfa)

noncomputable def maximumHidden [LinearOrder K] (M : Matroid (Fin n))
    (key : ℝ → K) (hkey : Measurable key) (active : K → Prop)
    (mask : Seed bits → Finset (Fin n)) : HiddenRule n bits :=
  ⟨mask, maximumRule M key hkey active mask⟩

lemma maximumHidden_feasible [LinearOrder K] (M : Matroid (Fin n))
    (key : ℝ → K) (hkey : Measurable key) (active : K → Prop)
    (mask : Seed bits → Finset (Fin n)) (w : Weights n) (hw : ∀ e, 0 ≤ w e)
    (r : Seed bits) (π : ArrivalOrder n) (t : ℕ) :
    M.Indep (hiddenAcceptedThrough (maximumHidden M key hkey active mask) r w π t :
      Set (Fin n)) := by
  apply (maximumRule_feasible M key hkey active mask r
    (observed (maximumHidden M key hkey active mask) r w) w π t ?_ hw).subset
  · intro e he
    exact (Finset.mem_sdiff.mp he).1
  · intro e
    classical
    simp only [observed]
    split_ifs
    · exact hw e
    · exact le_rfl

lemma maximumHidden_single_qualifier [LinearOrder K] (M : Matroid (Fin n))
    (key : ℝ → K) (hkey : Measurable key) (active : K → Prop)
    (mask : Seed bits → Finset (Fin n)) (w : Weights n) (r : Seed bits) (g : Fin n)
    (hg : g ∉ mask r)
    (ha : ∀ e, threshold M active mask r (fun f => key (w f)) (e, key (w e)) ↔ e = g)
    (π : ArrivalOrder n) :
    hiddenReward (maximumHidden M key hkey active mask) r w π = w g := by
  classical
  let A := maximumHidden M key hkey active mask
  have hsingle : accepted A.core r (observed A r w) w π = {g} := by
    apply firstRule_single_qualifier key hkey (threshold M active mask)
    intro e
    rw [threshold_congr_samples M active mask r
      (fun f => key (observed A r w f)) (fun f => key (w f))]
    · exact ha e
    · intro f hf
      simp [observed, A, maximumHidden, hf]
  change (∑ e ∈ accepted A.core r (observed A r w) w π \ mask r, w e) = w g
  rw [hsingle]
  have hd : ({g} : Finset (Fin n)) \ mask r = {g} := by
    apply Finset.sdiff_eq_self_of_disjoint
    simpa only [Finset.disjoint_singleton_left] using hg
  rw [hd, Finset.sum_singleton]

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in
lemma exists_top [LinearOrder K] (a : Fin n → K) (V : Finset (Fin n)) (hV : V.Nonempty) :
    ∃ g ∈ V, ∀ f ∈ V, f ≠ g → higher (g, a g) (f, a f) := by
  classical
  induction V using Finset.induction_on with
  | empty => simp at hV
  | @insert e V he ih =>
    by_cases hn : V.Nonempty
    · obtain ⟨g, hg, htop⟩ := ih hn
      have heg : e ≠ g := fun heq => he (heq ▸ hg)
      by_cases heg' : higher (e, a e) (g, a g)
      · refine ⟨e, Finset.mem_insert_self _ _, ?_⟩
        intro f hf hfe
        have hfV : f ∈ V := (Finset.mem_insert.mp hf).resolve_left hfe
        by_cases hfg : f = g
        · simpa [hfg] using heg'
        · exact higher_trans heg' (htop f hfV hfg)
      · refine ⟨g, Finset.mem_insert_of_mem hg, ?_⟩
        intro f hf hfg
        rcases Finset.mem_insert.mp hf with hfe | hfV
        · subst f
          exact (higher_total (show (e, a e) ≠ (g, a g) from
            fun h => heg (congrArg Prod.fst h))).resolve_left heg'
        · exact htop f hfV hfg
    · have hv : V = ∅ := Finset.not_nonempty_iff_eq_empty.mp hn
      subst V
      exact ⟨e, by simp, by simp⟩

omit [Countable K] [MeasurableSpace K] [MeasurableSingletonClass K] in
lemma threshold_only_positive [LinearOrder K] (M : Matroid (Fin n))
    (active : K → Prop) (mask : Seed bits → Finset (Fin n))
    (r : Seed bits) (a : Fin n → K) (g : Fin n)
    (hg : M.Indep ({g} : Set (Fin n))) (hag : active (a g))
    (honly : ∀ f, M.Indep ({f} : Set (Fin n)) → active (a f) → f = g)
    (hgm : g ∉ mask r) :
    ∀ e, threshold M active mask r a (e, a e) ↔ e = g := by
  intro e
  constructor
  · intro he
    exact honly e he.2.1 he.2.2.1
  · intro heq
    subst e
    refine ⟨hgm, hg, hag, ?_⟩
    intro f hfm hf haf
    exact False.elim (hgm (honly f hf haf ▸ hfm))

end Maximum
end MatroidProphet

end OAI