import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Specht.ZeroColumns
import OAI.RepresentationTheory.UniversalSquare.Balance.BalancePacking

namespace OAI

/-! Word Contents. -/

section

noncomputable section
namespace Saxl
open scoped BigOperators

def wordContent {n d : ℕ} (w : Fin n → Fin d) (j : Fin d) : ℕ :=
  (Finset.univ.filter (fun i => w i = j)).card

lemma wordContent_position_join {n a b d e E : ℕ}
    (p : Fin n ≃ Fin a ⊕ Fin b) (q : Fin E ≃ Fin d ⊕ Fin e)
    (w : Fin a → Fin d) (z : Fin b → Fin e) (j : Fin E) :
    wordContent
      ((positionWordsEquiv p).symm ((fun i => q.symm (Sum.inl (w i))),
        (fun i => q.symm (Sum.inr (z i))))) j =
      Sum.elim (wordContent w) (wordContent z) (q j) := by
  classical
  rw [wordContent, Finset.card_filter]
  rw [← Equiv.sum_comp p.symm]
  rw [Fintype.sum_sum_type]
  rcases hj : q j with k | k
  · have hqq : j = q.symm (Sum.inl k) := (q.eq_symm_apply).mpr hj
    subst j
    simp only [positionWordsEquiv, Equiv.coe_fn_symm_mk, joinPositions, Equiv.apply_symm_apply, Sum.elim_inl,
      Sum.elim_inr, q.symm.injective.eq_iff,
      Sum.inl.injEq, Sum.inr_ne_inl, ite_false, Finset.sum_const_zero, add_zero]
    rw [wordContent,Finset.card_filter]
  · have hqq : j = q.symm (Sum.inr k) := (q.eq_symm_apply).mpr hj
    subst j
    simp only [positionWordsEquiv, Equiv.coe_fn_symm_mk, joinPositions, Equiv.apply_symm_apply, Sum.elim_inl,
      Sum.elim_inr, q.symm.injective.eq_iff,
      Sum.inr.injEq, Sum.inl_ne_inr, ite_false, Finset.sum_const_zero, zero_add]
    rw [wordContent,Finset.card_filter]

lemma wordContent_lift_equiv {n d e : ℕ} (q : Fin d ≃ Fin e)
    (w : Fin n → Fin d) (j : Fin e) :
    wordContent (q ∘ w) j = wordContent w (q.symm j) := by
  classical
  unfold wordContent
  congr 1
  apply Finset.filter_congr
  intro i _
  change q (w i) = j ↔ w i = q.symm j
  exact q.eq_symm_apply.symm

def appendLetters (ps qs : List ℕ) : Fin (ps ++ qs).length ≃ Fin ps.length ⊕ Fin qs.length :=
  (finCongr (List.length_append (as := ps) (bs := qs))).trans finSumFinEquiv.symm

lemma get_appendLetters (ps qs : List ℕ) (j : Fin (ps ++ qs).length) :
    (ps ++ qs).get j = Sum.elim ps.get qs.get (appendLetters ps qs j) := by
  obtain ⟨j,rfl⟩ := (appendLetters ps qs).symm.surjective j
  rcases j with j | j
  · simp only [Equiv.apply_symm_apply, Sum.elim_inl]
    change (ps ++ qs)[j.val] = ps[j.val]
    exact List.getElem_append_left j.isLt
  · simp only [Equiv.apply_symm_apply, Sum.elim_inr]
    change (ps ++ qs)[ps.length+j.val] = qs[j.val]
    rw [List.getElem_append_right (by omega)]
    simp

lemma list_get_fiber_card (ps : List ℕ) (k : ℕ) :
    Fintype.card {i : Fin ps.length // ps.get i = k} = ps.count k := by
  classical
  rw [Fintype.card_subtype, Finset.card_filter]
  induction ps with
  | nil => simp
  | cons p ps ih =>
    change (∑ i : Fin (ps.length+1), if (p::ps).get i = k then (1:ℕ) else 0) = _
    rw [Fin.sum_univ_succ]
    change (if p = k then 1 else 0) + (∑ i : Fin ps.length, if ps.get i = k then 1 else 0) = _
    rw [ih]
    simp [List.count_cons, Nat.add_comm]

theorem list_get_equiv {ps qs : List ℕ} (h : ps.Perm qs) :
    ∃ q : Fin ps.length ≃ Fin qs.length, ∀ i, qs.get (q i) = ps.get i := by
  classical
  let f (k : ℕ) : {i : Fin ps.length // ps.get i = k} ≃
      {i : Fin qs.length // qs.get i = k} :=
    Fintype.equivOfCardEq (by rw [list_get_fiber_card,list_get_fiber_card,h.count_eq])
  let q := (Equiv.sigmaFiberEquiv ps.get).symm.trans
    ((Equiv.sigmaCongrRight f).trans (Equiv.sigmaFiberEquiv qs.get))
  exact ⟨q,fun i => (f (ps.get i) ⟨i,rfl⟩).property⟩

lemma columnShape_rows_permutation (ps : List ℕ) (hp : ∀ p ∈ ps, 0 < p) :
    ps.Perm (Columns.columnShape ps).transpose.rowLens := by
  rw [Columns.columnShape_cols]
  have he : ps.filter (fun p => 0 < p) = ps := by
    apply List.filter_eq_self.mpr
    intro p h
    simpa using hp p h
  simpa only [he] using Columns.positiveSorted_perm ps

end Saxl
end
end

end OAI