import OAI.Probability.MatroidProphet.Pivots.Reindex
import Mathlib.Data.Prod.Lex
import Mathlib.Order.WithBot

namespace OAI

namespace MatroidProphet.Pivots

open Set Finset

variable {α A T : Type*} [Fintype α] [LinearOrder α] [Fintype A] [Fintype T] [LinearOrder T]

abbrev BlockOld (F : T → Set α) :=
  {p : T ×ₗ α // (ofLex p).2 ∈ F (ofLex p).1}

noncomputable instance (F : T → Set α) : Fintype (BlockOld F) := Fintype.ofFinite _

def blockOldStage {F : T → Set α} (o : BlockOld F) : T := (ofLex o.val).1

def blockOldLabel {F : T → Set α} (o : BlockOld F) : α := (ofLex o.val).2

def blockStage (F : T → Set α) (τ : A → T) : BlockOld F ⊕ A → T :=
  Sum.elim (blockOldStage (F := F)) τ

noncomputable def blockKey (F : T → Set α) (τ : A → T) :
    BlockOld F ⊕ A → T ×ₗ (WithTop α ×ₗ ℕ)
  | Sum.inl o => toLex (blockOldStage (F := F) o, toLex ((blockOldLabel (α := α) (F := F) o : WithTop α), 0))
  | Sum.inr a => toLex (τ a, toLex (⊤, ((Fintype.equivFin A) a).val))

lemma blockKey_injective
    {α : Type u_1} {A : Type u_2} {T : Type u_3}
    [Fintype α] [LinearOrder α] [Fintype A] [Fintype T] [LinearOrder T]
    (F : T → Set α) (τ : A → T) :
    Function.Injective (blockKey F τ) := by
  intro x y h
  cases x with
  | inl x =>
    cases y with
    | inl y =>
      have hs : blockOldStage (F := F) x = blockOldStage (F := F) y := congrArg (fun z => (ofLex z).1) h
      have hl : (blockOldLabel (α := α) (F := F) x : WithTop α) = blockOldLabel (α := α) (F := F) y :=
        congrArg (fun z => (ofLex (ofLex z).2).1) h
      have hl' : blockOldLabel (α := α) (F := F) x = blockOldLabel (α := α) (F := F) y := WithTop.coe_inj.mp hl
      have heq : x = y := Subtype.ext (congrArg toLex (Prod.ext hs hl'))
      exact congrArg Sum.inl heq
    | inr y =>
      have hh : (blockOldLabel (α := α) (F := F) x : WithTop α) = ⊤ :=
        congrArg (fun z => (ofLex (ofLex z).2).1) h
      exact (WithTop.coe_ne_top hh).elim
  | inr x =>
    cases y with
    | inl y =>
      have hh : (blockOldLabel (α := α) (F := F) y : WithTop α) = ⊤ :=
        (congrArg (fun z => (ofLex (ofLex z).2).1) h).symm
      exact (WithTop.coe_ne_top hh).elim
    | inr y =>
      have hi : ((Fintype.equivFin A) x).val = ((Fintype.equivFin A) y).val :=
        congrArg (fun z => (ofLex (ofLex z).2).2) h
      exact congrArg Sum.inr ((Fintype.equivFin A).injective (Fin.ext hi))

noncomputable def blockTime (F : T → Set α) (τ : A → T) : BlockOld F ⊕ A → ℕ := by
  letI := LinearOrder.lift' (blockKey F τ) (blockKey_injective F τ)
  exact fun o => ((Fintype.orderIsoFinOfCardEq (BlockOld F ⊕ A) rfl).symm o).val

lemma blockTime_lt_iff (F : T → Set α) (τ : A → T) (x y : BlockOld F ⊕ A) :
    blockTime F τ x < blockTime F τ y ↔ blockKey F τ x < blockKey F τ y := by
  let := LinearOrder.lift' (blockKey F τ) (blockKey_injective F τ)
  change (Fintype.orderIsoFinOfCardEq (BlockOld F ⊕ A) rfl).symm x <
    (Fintype.orderIsoFinOfCardEq (BlockOld F ⊕ A) rfl).symm y ↔ _
  exact OrderIso.lt_iff_lt _

lemma blockTime_injective (F : T → Set α) (τ : A → T) :
    Function.Injective (blockTime F τ) := by
  intro x y h
  apply blockKey_injective F τ
  apply le_antisymm <;> apply le_of_not_gt <;> intro hh
  · exact (lt_irrefl _ (h ▸ (blockTime_lt_iff F τ y x).2 hh))
  · exact (lt_irrefl _ (h ▸ (blockTime_lt_iff F τ x y).2 hh))

lemma blockTime_old_strictMono (F : T → Set α) (τ : A → T) :
    StrictMono (fun o : BlockOld F => blockTime F τ (Sum.inl o)) := by
  intro x y hxy
  apply (blockTime_lt_iff F τ _ _).2
  change toLex (blockOldStage (F := F) x, toLex ((blockOldLabel (α := α) (F := F) x : WithTop α), 0)) <
    toLex (blockOldStage (F := F) y, toLex ((blockOldLabel (α := α) (F := F) y : WithTop α), 0))
  have hh : x.val < y.val := hxy
  rcases Prod.Lex.toLex_lt_toLex.mp hh with hs | ⟨hs, hl⟩
  · exact Prod.Lex.toLex_lt_toLex.mpr (Or.inl hs)
  · exact Prod.Lex.toLex_lt_toLex.mpr (Or.inr ⟨hs,
      Prod.Lex.toLex_lt_toLex.mpr (Or.inl (WithTop.coe_lt_coe.mpr hl))⟩)

lemma stage_lt_implies_blockTime_lt (F : T → Set α) (τ : A → T)
    {x y : BlockOld F ⊕ A} (h : blockStage F τ x < blockStage F τ y) :
    blockTime F τ x < blockTime F τ y := by
  apply (blockTime_lt_iff F τ _ _).2
  apply Prod.Lex.toLex_lt_toLex.mpr
  left
  cases x <;> cases y <;> exact h

lemma blockTime_le_implies_stage_le (F : T → Set α) (τ : A → T)
    {x y : BlockOld F ⊕ A} (h : blockTime F τ x ≤ blockTime F τ y) :
    blockStage F τ x ≤ blockStage F τ y := by
  by_contra hh
  exact (not_lt_of_ge h) (stage_lt_implies_blockTime_lt F τ (lt_of_not_ge hh))

end MatroidProphet.Pivots

end OAI