import OAI.GameTheory.SnakyTwentyOne.Model

namespace OAI

namespace SnakyPrototype
variable {α : Type*} [DecidableEq α]
inductive WinsIn (win : Finset α → Prop) : ℕ → Finset α → Finset α → Prop
  | done {n M B} : win M → WinsIn win n M B
  | move {n M B} (x : α) (hxM : x ∉ M) (hxB : x ∉ B)
      (next : ∀ b, b ∉ insert x M → b ∉ B →
        WinsIn win n (insert x M) (insert b B)) :
      WinsIn win (n + 1) M B
theorem WinsIn.weaken {win : Finset α → Prop} {n : ℕ} {M B : Finset α}
    (h : WinsIn win n M B) : ∀ k, WinsIn win (n + k) M B := by
  induction h with
  | done hw =>
      intro k
      exact WinsIn.done hw
  | @move n M B x hxM hxB next ih =>
      intro k
      simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using
        (WinsIn.move x hxM hxB (fun b hbM hbB => ih b hbM hbB k))
theorem WinsIn.mono {win : Finset α → Prop} {n m : ℕ} {M B : Finset α}
    (h : WinsIn win n M B) (hnm : n ≤ m) : WinsIn win m M B := by
  obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hnm
  exact h.weaken k
def Template (win : Finset α → Prop) (n : ℕ) (A H : Finset α) : Prop :=
  ∀ M B, Disjoint M B → A ⊆ M → Disjoint B H → WinsIn win n M B
theorem WinsIn.transport {win : Finset α → Prop} {n : ℕ} {M B : Finset α}
    (h : WinsIn win n M B) (e : α ≃ α)
    (hwin : ∀ X, win X → win (X.image e)) :
    WinsIn win n (M.image e) (B.image e) := by
  induction h with
  | done hw => exact WinsIn.done (hwin _ hw)
  | @move n M B x hxM hxB next ih =>
      apply WinsIn.move (e x)
      · intro hx
        obtain ⟨y, hy, he⟩ := Finset.mem_image.mp hx
        exact hxM (e.injective he ▸ hy)
      · intro hx
        obtain ⟨y, hy, he⟩ := Finset.mem_image.mp hx
        exact hxB (e.injective he ▸ hy)
      · intro b hbM hbB
        have hbM' : e.symm b ∉ insert x M := by
          intro hb
          apply hbM
          simpa [Finset.image_insert] using Finset.mem_image_of_mem e hb
        have hbB' : e.symm b ∉ B := by
          intro hb
          apply hbB
          simpa using Finset.mem_image_of_mem e hb
        simpa [Finset.image_insert] using ih (e.symm b) hbM' hbB'
theorem Template.mono {win : Finset α → Prop} {n m : ℕ} {A H : Finset α}
    (h : Template win n A H) (hnm : n ≤ m) : Template win m A H := by
  intro M B hMB hAM hBH
  exact (h M B hMB hAM hBH).mono hnm
theorem Template.transport {win : Finset α → Prop} {n : ℕ} {A H : Finset α}
    (h : Template win n A H) (e : α ≃ α)
    (hwin : ∀ X, win X → win (X.image e)) :
    Template win n (A.image e) (H.image e) := by
  intro M B hMB hAM hBH
  have hMB' : Disjoint (M.image e.symm) (B.image e.symm) := by
    refine Finset.disjoint_left.mpr ?_
    intro z hzM hzB
    obtain ⟨x, hx, hxe⟩ := Finset.mem_image.mp hzM
    obtain ⟨y, hy, hye⟩ := Finset.mem_image.mp hzB
    have hxy : x = y := e.symm.injective (hxe.trans hye.symm)
    exact Finset.disjoint_left.mp hMB hx (hxy.symm ▸ hy)
  have hAM' : A ⊆ M.image e.symm := by
    intro z hz
    exact Finset.mem_image.mpr ⟨e z, hAM (Finset.mem_image_of_mem e hz), by simp⟩
  have hBH' : Disjoint (B.image e.symm) H := by
    refine Finset.disjoint_left.mpr ?_
    intro z hzB hzH
    obtain ⟨x, hx, he⟩ := Finset.mem_image.mp hzB
    have hxH : x ∈ H.image e := by
      exact Finset.mem_image.mpr ⟨z, hzH, by rw [← he]; simp⟩
    exact Finset.disjoint_left.mp hBH hx hxH
  have h' := (h (M.image e.symm) (B.image e.symm) hMB' hAM' hBH').transport e hwin
  simpa [Finset.image_image, Function.comp_def] using h'
theorem immediate_template (win : Finset α → Prop) (H : Finset α) (pivot : α)
    (hp : pivot ∈ H) (hwin : ∀ M, H ⊆ M → win M) :
    Template win 1 (H.erase pivot) H := by
  intro M B _ hAM hBH
  have hsub : H ⊆ insert pivot M := by
    intro y hy
    by_cases hyp : y = pivot
    · simp [hyp]
    · exact Finset.mem_insert_of_mem (hAM (Finset.mem_erase.mpr ⟨hyp, hy⟩))
  by_cases hpM : pivot ∈ M
  · exact WinsIn.done (hwin M (by simpa [Finset.insert_eq_of_mem hpM] using hsub))
  · apply WinsIn.move pivot hpM
    · exact fun hpB => Finset.disjoint_left.mp hBH hpB hp
    · intro b _ _
      exact WinsIn.done (hwin (insert pivot M) hsub)
theorem surviving_child {ι : Type*} [Nonempty ι]
    (C D : ι → Finset α) (M B H : Finset α)
    (hC : ∀ j, C j ⊆ M) (hD : ∀ j, D j ⊆ H)
    (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ M)
    (hBH : Disjoint B H) (b : α) (hbM : b ∉ M) :
    ∃ j, C j ⊆ M ∧ Disjoint (insert b B) (D j) := by
  classical
  have hex : ∃ j, b ∉ D j := by
    by_contra h
    push Not at h
    exact hbM (hcommon b h)
  obtain ⟨j, hj⟩ := hex
  refine ⟨j, hC j, Finset.disjoint_left.mpr ?_⟩
  intro x hx hxd
  rcases Finset.mem_insert.mp hx with hxb | hxB
  · subst x
    exact hj hxd
  · exact Finset.disjoint_left.mp hBH hxB (hD j hxd)
theorem legal_pivot_or_replacement [Infinite α]
    (pivot : α) (M B : Finset α) (hpB : pivot ∉ B) :
    ∃ x, x ∉ M ∧ x ∉ B ∧ pivot ∈ insert x M := by
  classical
  by_cases hpM : pivot ∈ M
  · obtain ⟨x, hx⟩ := (M ∪ B).exists_notMem
    refine ⟨x, ?_, ?_, Finset.mem_insert_of_mem hpM⟩
    · exact fun hxM => hx (Finset.mem_union_left B hxM)
    · exact fun hxB => hx (Finset.mem_union_right M hxB)
  · exact ⟨pivot, hpM, hpB, Finset.mem_insert_self pivot M⟩
theorem breaker_turn {ι : Type*} [Nonempty ι]
    (win : Finset α → Prop) (n : ℕ) (C D : ι → Finset α)
    (hchild : ∀ j, Template win n (C j) (D j))
    (M B H : Finset α) (hMB : Disjoint M B)
    (hC : ∀ j, C j ⊆ M) (hD : ∀ j, D j ⊆ H)
    (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ M)
    (hBH : Disjoint B H) :
    ∀ b, b ∉ M → b ∉ B → WinsIn win n M (insert b B) := by
  intro b hbM _
  obtain ⟨j, hjC, hjD⟩ := surviving_child C D M B H hC hD hcommon hBH b hbM
  apply hchild j M (insert b B) _ hjC hjD
  refine Finset.disjoint_left.mpr ?_
  intro x hxM hxB
  rcases Finset.mem_insert.mp hxB with hxb | hxB
  · subst x
    exact hbM hxM
  · exact Finset.disjoint_left.mp hMB hxM hxB
theorem compose [Infinite α] {ι : Type*} [Nonempty ι]
    (win : Finset α → Prop) (n : ℕ) (C D : ι → Finset α)
    (hchild : ∀ j, Template win n (C j) (D j))
    (pivot : α) (A H : Finset α) (hpH : pivot ∈ H)
    (hC : ∀ j, C j ⊆ insert pivot A)
    (hD : ∀ j, D j ⊆ H)
    (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ insert pivot A) :
    Template win (n + 1) A H := by
  intro M B hMB hAM hBH
  have hpB : pivot ∉ B := fun hp => Finset.disjoint_left.mp hBH hp hpH
  obtain ⟨x, hxM, hxB, hpx⟩ := legal_pivot_or_replacement pivot M B hpB
  have howned : insert pivot A ⊆ insert x M := by
    intro y hy
    rcases Finset.mem_insert.mp hy with hyp | hyA
    · subst y
      exact hpx
    · exact Finset.mem_insert_of_mem (hAM hyA)
  have hMB' : Disjoint (insert x M) B := by
    refine Finset.disjoint_left.mpr ?_
    intro y hy hyB
    rcases Finset.mem_insert.mp hy with hyx | hyM
    · subst y
      exact hxB hyB
    · exact Finset.disjoint_left.mp hMB hyM hyB
  apply WinsIn.move x hxM hxB
  exact breaker_turn win n C D hchild (insert x M) B H hMB'
    (fun j => (hC j).trans howned) hD
    (fun b hb => howned (hcommon b hb)) hBH
theorem one_stone_after_distant_reply {ι : Type*} [Nonempty ι]
    (win : Finset α → Prop) (n : ℕ) (o : α) (N : Finset α)
    (D : ι → Finset α)
    (hchild : ∀ j, Template win n {o} (D j))
    (hcommon : ∀ q, (∀ j, q ∈ D j) → q ∈ N)
    (q : α) (hqo : q ≠ o) (hqN : q ∉ N) :
    WinsIn win n {o} {q} := by
  classical
  have hex : ∃ j, q ∉ D j := by
    by_contra h
    push Not at h
    exact hqN (hcommon q h)
  obtain ⟨j, hj⟩ := hex
  apply hchild j {o} {q}
  · simpa [Finset.disjoint_singleton_left, eq_comm] using hqo
  · exact Finset.Subset.refl _
  · exact Finset.disjoint_singleton_left.mpr hj
theorem from_first_reply (win : Finset α → Prop) (n : ℕ) (o : α)
    (h : ∀ q, q ≠ o → WinsIn win n {o} {q}) :
    WinsIn win (n + 1) ∅ ∅ := by
  apply WinsIn.move o (by simp) (by simp)
  intro q hq _
  simpa using h q (by simpa using hq)
end SnakyPrototype

end OAI