import OAI.Combinatorics.Order.ChainToggle
import Mathlib.Data.Finset.Sort

namespace OAI

namespace FiniteChain

open Finset

variable {α : Type*} [DecidableEq α] [SemilatticeSup α]

/-- Every unordered finite chain has exactly one strictly increasing enumeration. -/
theorem exists_unique_strict_enumeration (s : Finset α) (hs : Ordered s) :
    ∃! l : List α, l.Pairwise (· < ·) ∧ l.toFinset = s := by
  classical
  let : LinearOrder s := {
    (inferInstance : PartialOrder s) with
    le_total := fun a b => hs a a.2 b b.2
    toDecidableLE := Classical.decRel _
    toDecidableLT := Classical.decRel _
    toDecidableEq := Classical.decEq _ }
  let l : List α := (Finset.univ.sort : List s).map Subtype.val
  have hl : l.Pairwise (· < ·) := by
    exact List.pairwise_map.mpr (Finset.sortedLT_sort (Finset.univ : Finset s)).pairwise
  have he : l.toFinset = s := by
    ext a
    simp [l]
  refine ⟨l, ⟨hl, he⟩, ?_⟩
  intro k hk
  have hn : k.Nodup := hk.1.imp (fun h => ne_of_lt h)
  have hn' : l.Nodup := hl.imp (fun h => ne_of_lt h)
  have hp : k.Perm l := (List.perm_ext_iff_of_nodup hn hn').mpr (by
    intro a
    have := congrArg (fun t : Finset α => a ∈ t) (hk.2.trans he.symm)
    simpa using this)
  exact List.Perm.eq_of_pairwise' (hk.1.imp le_of_lt) (hl.imp le_of_lt) hp

/-- Conversely, an actual strictly increasing list gives a finite chain. -/
theorem ordered_toFinset {l : List α} (hl : l.Pairwise (· < ·)) : Ordered l.toFinset := by
  induction l with
  | nil => simp [Ordered]
  | cons a l ih =>
    have ht := hl.tail
    intro x hx y hy
    simp only [List.toFinset_cons, Finset.mem_insert] at hx hy
    rcases hx with rfl | hx
    · rcases hy with rfl | hy
      · exact Or.inl le_rfl
      · exact Or.inl (le_of_lt (hl.rel_head_tail (List.mem_toFinset.mp hy)))
    · rcases hy with rfl | hy
      · exact Or.inr (le_of_lt (hl.rel_head_tail (List.mem_toFinset.mp hx)))
      · exact ih ht x hx y hy

variable [OrderBot α]

/-- Adding the initial bottom gives a strict chain whose length after bottom equals
the cardinality of the nonbottom nodes, including the empty chain. -/
theorem full_chain_enumeration (s : Finset α) (hs : Ordered s)
    (hn : ∀ x ∈ s, x ≠ ⊥) :
    ∃ l : List α, l.toFinset = s ∧ (⊥ :: l).Pairwise (· < ·) ∧ l.length = s.card := by
  obtain ⟨l, hl, _⟩ := exists_unique_strict_enumeration s hs
  refine ⟨l, hl.2, ?_, ?_⟩
  · apply List.pairwise_cons.mpr
    refine ⟨?_, hl.1⟩
    intro x hx
    exact lt_of_le_of_ne bot_le (Ne.symm (hn x (hl.2 ▸ List.mem_toFinset.mpr hx)))
  · rw [← hl.2]
    exact (List.toFinset_card_of_nodup (hl.1.imp (fun h => ne_of_lt h))).symm

variable [Fintype α]

/-- The nodes after the initial bottom in a strict chain. The empty list gives
the chain containing only bottom. -/
def StrictChain (allowed : α → Prop) :=
  {l : List α // l.Pairwise (· < ·) ∧ ∀ x ∈ l, x ≠ ⊥ ∧ allowed x}

noncomputable def strictToFinset (allowed : α → Prop) (l : StrictChain allowed) :
    {s : Finset α // s ∈ chains allowed} := by
  classical
  refine ⟨l.val.toFinset, ?_⟩
  exact mem_filter.mpr ⟨mem_powerset.mpr (subset_univ _), ordered_toFinset l.property.1,
    fun x hx => l.property.2 x (List.mem_toFinset.mp hx)⟩

noncomputable def strictChainEquiv (allowed : α → Prop) :
    StrictChain allowed ≃ {s : Finset α // s ∈ chains allowed} := by
  classical
  apply Equiv.ofBijective (strictToFinset allowed)
  constructor
  · intro a b hab
    have he : a.val.toFinset = b.val.toFinset := congrArg Subtype.val hab
    have hp : a.val.Perm b.val := (List.perm_ext_iff_of_nodup
      (a.property.1.imp (fun h => ne_of_lt h))
      (b.property.1.imp (fun h => ne_of_lt h))).mpr (by
        intro x
        have hx := congrArg (fun s : Finset α => x ∈ s) he
        simpa using hx)
    apply Subtype.ext
    exact List.Perm.eq_of_pairwise' (a.property.1.imp le_of_lt)
      (b.property.1.imp le_of_lt) hp
  · intro s
    have hs : Admissible allowed s.val := (mem_filter.mp s.property).2
    obtain ⟨l, hl, _⟩ := exists_unique_strict_enumeration s.val hs.1
    have ha : ∀ x ∈ l, x ≠ ⊥ ∧ allowed x := by
      intro x hx
      exact hs.2 x (hl.2 ▸ List.mem_toFinset.mpr hx)
    refine ⟨⟨l, hl.1, ha⟩, ?_⟩
    exact Subtype.ext hl.2

noncomputable instance strictChainFintype (allowed : α → Prop) : Fintype (StrictChain allowed) := by
  classical
  letI : DecidableEq α := Classical.decEq α
  exact Fintype.ofEquiv {s : Finset α // s ∈ chains allowed} (strictChainEquiv allowed).symm

/-- Strict enumeration preserves chain length and the signed sum over all chains. -/
theorem strict_list_weight_eq (allowed : α → Prop) :
    (∑ l : StrictChain allowed, (-1 : ℤ)^l.val.length) =
      ∑ s ∈ chains allowed, (-1 : ℤ)^s.card := by
  classical
  calc
    (∑ l : StrictChain allowed, (-1 : ℤ)^l.val.length) =
        ∑ s : {s : Finset α // s ∈ chains allowed}, (-1 : ℤ)^s.val.card := by
      apply Fintype.sum_equiv (strictChainEquiv allowed)
      intro l
      change (-1 : ℤ)^l.val.length = (-1 : ℤ)^l.val.toFinset.card
      rw [List.toFinset_card_of_nodup (l.property.1.imp (fun h => ne_of_lt h))]
    _ = ∑ s ∈ chains allowed, (-1 : ℤ)^s.card :=
      Finset.sum_coe_sort (chains allowed) (fun s : Finset α => (-1 : ℤ)^s.card)

end FiniteChain

end OAI