import OAI.Combinatorics.ListHadwiger.Separators

namespace OAI

namespace LinearListHadwiger

open scoped Classical

lemma exists_injective_neighborPairs {V : Type} [DecidableEq V]
    {t : ℕ} (G : SimpleGraph V) (X S : Finset V)
    (hminor : ¬HasCliqueMinor G t)
    (hSX : Disjoint S X)
    (hdeg : ∀ v ∈ S, t ≤ (X.filter (G.Adj v)).card) :
    ∃ f : V → Sym2 V, Set.InjOn f (↑S : Set V) ∧
      ∀ v ∈ S, f v ∈ neighborPairs G X v := by
  classical
  revert hSX hdeg
  induction S using Finset.induction_on with
  | empty =>
    intro _ _
    exact ⟨fun v => s(v, v), by simp [Set.InjOn], by simp⟩
  | @insert v S hv ih =>
    intro hSX hdeg
    obtain ⟨f, hfi, hfp⟩ := ih
      (hSX.mono_left (Finset.subset_insert _ _))
      (fun w hw => hdeg w (Finset.mem_insert_of_mem hw))
    by_cases hex : ∃ p ∈ neighborPairs G X v, p ∉ S.image f
    · obtain ⟨p, hp, hnp⟩ := hex
      let g : V → Sym2 V := fun w => if w = v then p else f w
      have hgv : g v = p := by simp [g]
      have hgS : ∀ w ∈ S, g w = f w := by
        intro w hw
        have hn : w ≠ v := by
          intro he
          subst w
          exact hv hw
        simp only [g, ite_eq_right hn]
      refine ⟨g, ?_, ?_⟩
      · intro a ha b hb hab
        by_cases hav : a = v
        · subst a
          by_cases hbv : b = v
          · exact hbv.symm
          · have hbS := (Finset.mem_insert.mp hb).resolve_left hbv
            rw [hgv, hgS b hbS] at hab
            exact (hnp (Finset.mem_image.mpr ⟨b, hbS, hab.symm⟩)).elim
        · have haS := (Finset.mem_insert.mp ha).resolve_left hav
          by_cases hbv : b = v
          · subst b
            rw [hgS a haS, hgv] at hab
            exact (hnp (Finset.mem_image.mpr ⟨a, haS, hab⟩)).elim
          · have hbS := (Finset.mem_insert.mp hb).resolve_left hbv
            rw [hgS a haS, hgS b hbS] at hab
            exact hfi haS hbS hab
      · intro w hw
        rcases Finset.mem_insert.mp hw with rfl | hw
        · rwa [hgv]
        · rw [hgS w hw]
          exact hfp w hw
    · exfalso
      apply hminor
      apply cliqueMinor_of_saturated_pairs G X S (X.filter (G.Adj v))
        (hSX.mono_left (Finset.subset_insert _ _)) (Finset.filter_subset _ _)
        (hdeg v (Finset.mem_insert_self _ _)) f
      · intro w hw a ha
        exact (mem_neighborPairs (hfp w hw) a ha).2
      · intro a ha b hb hab
        have hpair : s(a, b) ∈ neighborPairs G X v :=
          Finset.mem_image.mpr ⟨(a, b), Finset.mem_offDiag.mpr ⟨ha, hb, hab⟩, rfl⟩
        have himage : s(a, b) ∈ S.image f := by
          by_contra hn
          exact hex ⟨s(a, b), hpair, hn⟩
        exact Finset.mem_image.mp himage

theorem high_neighbor_count {V : Type} [Fintype V] [DecidableEq V]
    (G : SimpleGraph V) {t : ℕ} (_ht : 2 ≤ t)
    (hminor : hadwigerNumber G < t) (X : Finset V) :
    (Finset.univ.filter (fun v => v ∉ X ∧ t ≤ (X.filter (G.Adj v)).card)).card
      ≤ X.card.choose 2 := by
  classical
  let S := Finset.univ.filter (fun v => v ∉ X ∧ t ≤ (X.filter (G.Adj v)).card)
  have hSX : Disjoint S X := Finset.disjoint_left.mpr fun v hv hx =>
    (Finset.mem_filter.mp hv).2.1 hx
  have hdeg : ∀ v ∈ S, t ≤ (X.filter (G.Adj v)).card :=
    fun _ hv => (Finset.mem_filter.mp hv).2.2
  obtain ⟨f, hfi, hfp⟩ := exists_injective_neighborPairs G X S
    (fun h => (Nat.not_le_of_lt hminor) (cliqueMinor_le_hadwigerNumber h)) hSX hdeg
  have hsub : S.image f ⊆ X.offDiag.image Sym2.mk.uncurry := by
    intro p hp
    obtain ⟨v, hv, rfl⟩ := Finset.mem_image.mp hp
    obtain ⟨⟨a, b⟩, hab, heq⟩ := Finset.mem_image.mp (hfp v hv)
    obtain ⟨ha, hb, hne⟩ := Finset.mem_offDiag.mp hab
    exact Finset.mem_image.mpr ⟨(a, b), Finset.mem_offDiag.mpr
      ⟨(Finset.mem_filter.mp ha).1, (Finset.mem_filter.mp hb).1, hne⟩, heq⟩
  calc
    S.card = (S.image f).card := (Finset.card_image_of_injOn hfi).symm
    _ ≤ (X.offDiag.image Sym2.mk.uncurry).card := Finset.card_le_card hsub
    _ = X.card.choose 2 := Sym2.card_image_offDiag X

theorem choosable_add_deleted_card {V : Type} [Fintype V] [DecidableEq V]
    (G : SimpleGraph V) (Z : Finset V) {s : ℕ}
    (hR : Choosable (G.induce (↑(Finset.univ \ Z) : Set V)) s) :
    Choosable G (s + Z.card) := by
  classical
  intro Color L hL
  have hZ : Choosable (G.induce (↑Z : Set V)) Z.card := by
    have hh := choosable_card (G.induce (↑Z : Set V))
    change Choosable _ (Fintype.card ↥Z) at hh
    simpa only [Fintype.card_coe] using hh
  obtain ⟨cZ, hcZ, hpZ⟩ := hZ Color (fun v => L v.val)
    (fun v => (Nat.le_add_left _ _).trans (hL v.val))
  let used : Finset Color := Finset.univ.image cZ
  have hused : used.card ≤ Z.card := by
    calc
      used.card ≤ (Finset.univ : Finset (↑Z : Set V)).card := Finset.card_image_le
      _ = Z.card := by change Fintype.card ↥Z = Z.card; exact Fintype.card_coe Z
  let LR : (↑(Finset.univ \ Z) : Set V) → Finset Color := fun v => L v.val \ used
  have hs : ∀ v, s ≤ (LR v).card := by
    intro v
    have hh := Finset.card_le_card_sdiff_add_card (s := L v.val) (t := used)
    have hl := hL v.val
    dsimp [LR]
    omega
  obtain ⟨cR, hcR, hpR⟩ := hR Color LR hs
  let c : V → Color := fun v =>
    if hv : v ∈ Z then cZ ⟨v, hv⟩ else cR ⟨v, by simp [hv]⟩
  have hcr : ∀ v (hv : v ∉ Z), c v ∈ L v ∧ c v ∉ used := by
    intro v hv
    have hh := hcR ⟨v, by simp [hv]⟩
    simpa only [c, dite_eq_right hv, LR, Finset.mem_sdiff] using hh
  have hcz : ∀ v (hv : v ∈ Z), c v = cZ ⟨v, hv⟩ :=
    fun v hv => dite_eq_left hv
  have hzr : ∀ v (hv : v ∈ Z), c v ∈ used := by
    intro v hv
    rw [hcz v hv]
    exact Finset.mem_image.mpr ⟨⟨v, hv⟩, Finset.mem_univ _, rfl⟩
  refine ⟨c, ?_, ?_⟩
  · intro v
    by_cases hv : v ∈ Z
    · rw [hcz v hv]
      exact hcZ ⟨v, hv⟩
    · exact (hcr v hv).1
  · intro v w hadj
    by_cases hv : v ∈ Z <;> by_cases hw : w ∈ Z
    · rw [hcz v hv, hcz w hw]
      exact hpZ hadj
    · intro heq
      exact (hcr w hw).2 (heq ▸ hzr v hv)
    · intro heq
      exact (hcr v hv).2 (heq.symm ▸ hzr w hw)
    · simp only [c, dite_eq_right hv, dite_eq_right hw]
      exact hpR hadj

theorem listChromaticNumber_deleted {V : Type} [Fintype V] [DecidableEq V]
    (G : SimpleGraph V) (Z : Finset V) :
    listChromaticNumber G - Z.card ≤
      listChromaticNumber (G.induce (↑(Finset.univ \ Z) : Set V)) := by
  have hh := choosable_add_deleted_card G Z
    (choosable_listChromaticNumber (G.induce (↑(Finset.univ \ Z) : Set V)))
  have hb := (listChromaticNumber_le_iff G _).mpr hh
  omega

def DegenerateOn {V : Type} (G : SimpleGraph V) (S : Finset V) (d : ℕ) : Prop :=
  ∀ T ⊆ S, T.Nonempty → ∃ v ∈ T, (T.filter (G.Adj v)).card ≤ d

theorem degenerate_coloring_on {V Color : Type} [DecidableEq V]
    (G : SimpleGraph V) (S : Finset V) (L : V → Finset Color) (φ : V → Color)
    {d : ℕ} (hdeg : DegenerateOn G S d) (hL : ∀ v ∈ S, d + 1 ≤ (L v).card) :
    ∃ c, ValidOn G S L c := by
  classical
  induction S using Finset.strongInductionOn with
  | _ S ih =>
    obtain rfl | hS := S.eq_empty_or_nonempty
    · exact ⟨φ, by simp [ValidOn, ProperOn]⟩
    obtain ⟨v, hv, hvd⟩ := hdeg S (Finset.Subset.refl _) hS
    have herase : S.erase v ⊂ S := Finset.erase_ssubset hv
    obtain ⟨c, hc⟩ := ih (S.erase v) herase
      (fun T hT => hdeg T (hT.trans (Finset.erase_subset _ _)))
      (fun w hw => hL w (Finset.mem_of_mem_erase hw))
    let forbidden := (S.filter (G.Adj v)).image c
    have hfc : forbidden.card ≤ d := Finset.card_image_le.trans hvd
    have hpos : (L v \ forbidden).Nonempty := by
      apply Finset.card_pos.mp
      have hh := Finset.card_le_card_sdiff_add_card (s := L v) (t := forbidden)
      have hl := hL v hv
      omega
    obtain ⟨a, ha⟩ := hpos
    obtain ⟨haL, haF⟩ := Finset.mem_sdiff.mp ha
    let c' : V → Color := fun w => if w = v then a else c w
    have hcv : c' v = a := by simp [c']
    have hcw : ∀ w, w ≠ v → c' w = c w := fun w hw => ite_eq_right hw
    refine ⟨c', ?_, ?_⟩
    · intro w hw
      by_cases hwv : w = v
      · subst w
        rwa [hcv]
      · rw [hcw w hwv]
        exact hc.1 w (Finset.mem_erase.mpr ⟨hwv, hw⟩)
    · intro w hw z hz hadj
      by_cases hwv : w = v
      · subst w
        have hzv : z ≠ v := hadj.ne.symm
        rw [hcv, hcw z hzv]
        intro heq
        exact haF (Finset.mem_image.mpr
          ⟨z, Finset.mem_filter.mpr ⟨hz, hadj⟩, heq.symm⟩)
      · by_cases hzv : z = v
        · subst z
          rw [hcw w hwv, hcv]
          intro heq
          exact haF (Finset.mem_image.mpr
            ⟨w, Finset.mem_filter.mpr ⟨hw, hadj.symm⟩, heq⟩)
        · rw [hcw w hwv, hcw z hzv]
          exact hc.2 (Finset.mem_erase.mpr ⟨hwv, hw⟩)
            (Finset.mem_erase.mpr ⟨hzv, hz⟩) hadj

theorem choosable_of_degenerate {V : Type} [Fintype V] [DecidableEq V]
    (G : SimpleGraph V) {d : ℕ} (hdeg : DegenerateOn G Finset.univ d) :
    Choosable G (d + 1) := by
  classical
  intro Color L hL
  have hn : ∀ v, (L v).Nonempty := by
    intro v
    apply Finset.card_pos.mp
    have hh := hL v
    omega
  choose φ hφ using hn
  obtain ⟨c, hc⟩ := degenerate_coloring_on G Finset.univ L φ hdeg (fun v _ => hL v)
  exact ⟨c, fun v => hc.1 v (Finset.mem_univ _),
    fun _ _ h => hc.2 (Finset.mem_univ _) (Finset.mem_univ _) h⟩

theorem listChromaticNumber_le_of_degenerate {V : Type} [Fintype V] [DecidableEq V]
    (G : SimpleGraph V) {d : ℕ} (hdeg : DegenerateOn G Finset.univ d) :
    listChromaticNumber G ≤ d + 1 :=
  (listChromaticNumber_le_iff G _).mpr (choosable_of_degenerate G hdeg)

end LinearListHadwiger

end OAI