import Mathlib
import OAI.Computability.FiniteCompiler.Quotients
import OAI.GroupTheory.SimpleOvergroups.ContextualTables

namespace OAI


namespace SimpleFInftyOvergroups.ContextualEncoding
open FiniteAlgebraicEnvelopes.Bootstrap Relation

namespace DelimiterCode
variable {A B S : Type*}

def alphabet (C : DelimiterCode A S) : Set S :=
  {s | s = C.start ∨ s = C.stop ∨ ∃ a, s ∈ C.body a}

theorem mem_alphabet_of_mem_encode (C : DelimiterCode A S) {s : S} {w : List A}
    (hs : s ∈ C.encode w) : s ∈ C.alphabet := by
  obtain ⟨a, _, ha⟩ := List.mem_flatMap.mp hs
  simp only [block, List.mem_cons, List.mem_append, List.not_mem_nil, or_false] at ha
  rcases ha with h | h | h
  · exact Or.inl h
  · exact Or.inr (Or.inr ⟨a, h⟩)
  · exact Or.inr (Or.inl h)

theorem avoids_of_not_mem_alphabet (C : DelimiterCode A S) {s : S}
    (hs : s ∉ C.alphabet) (w : List A) : s ∉ C.encode w :=
  fun h => hs (C.mem_alphabet_of_mem_encode h)

theorem disjoint_infix (C : DelimiterCode A S) (D : DelimiterCode B S)
    (hd : Disjoint C.alphabet D.alphabet) {u : List A} {v : List B}
    (hv : v ≠ []) (he : D.encode v <:+: C.encode u) : False := by
  have hn : D.encode v ≠ [] := fun h => hv ((D.encode_eq_nil _).mp h)
  obtain ⟨s, hs⟩ := List.exists_mem_of_ne_nil _ hn
  exact (Set.disjoint_left.mp hd) (C.mem_alphabet_of_mem_encode (he.subset hs))
    (D.mem_alphabet_of_mem_encode hs)

theorem disjoint_overlap (C : DelimiterCode A S) (D : DelimiterCode B S)
    (hd : Disjoint C.alphabet D.alphabet) {u : List A} {v : List B} {p m q : List S}
    (hm : m ≠ []) (he : C.encode u = p++m) (hf : D.encode v = m++q) : False := by
  obtain ⟨s, hs⟩ := List.exists_mem_of_ne_nil _ hm
  exact (Set.disjoint_left.mp hd)
    (C.mem_alphabet_of_mem_encode (by rw [he]; exact List.mem_append_right _ hs))
    (D.mem_alphabet_of_mem_encode (by rw [hf]; exact List.mem_append_left _ hs))
end DelimiterCode

namespace Families
variable {I S : Type*} {A Q : I → Type*} [Fintype I] [Fintype S]
variable {r : S → S → Prop} [Std.Trichotomous r]
variable (C : ∀ i, DelimiterCode (A i) S) (E : ∀ i, FiniteSearch (C i))
  (wf : WellFounded r) (q : ∀ i, List (A i) → Option (Q i)) (z : S)

noncomputable def table (n : ℕ) : List (List S × List S) :=
  Base.absorption z ++ (Static.letters I).flatMap (fun i => CodeTable.table (C i) (E i) wf (q i) z n)

omit [Std.Trichotomous r] in
theorem mem_table [Std.Trichotomous r] {n : ℕ} {p : List S × List S} : p ∈ table C E wf q z n ↔
    p ∈ Base.absorption z ∨ ∃ i, p ∈ CodeTable.table (C i) (E i) wf (q i) z n := by
  classical
  simp [table, Static.letters]

theorem absorbs (n : ℕ) : Absorbs (table C E wf q z n) z := by
  classical
  intro a
  constructor <;> apply (mem_table C E wf q z).mpr <;> apply Or.inl <;>
    apply (Base.mem_absorption z).mpr
  · exact ⟨a, Or.inl rfl, rfl⟩
  · exact ⟨a, Or.inr rfl, rfl⟩

theorem preserves_zero (hz : ∀ i, z ∉ (C i).alphabet) (n : ℕ) :
    ∀ p ∈ table C E wf q z n, z ∈ p.1 → z ∈ p.2 := by
  classical
  intro ⟨u,v⟩ hp hu
  rcases (mem_table C E wf q z).mp hp with hp | ⟨i,hp⟩
  · obtain ⟨a,_,rfl⟩ := (Base.mem_absorption z).mp hp
    simp
  · obtain ⟨w,_,_,_,rfl,_⟩ := (CodeTable.mem_table (C i) (E i) wf (q i) z).mp hp
    exact ((hz i) ((C i).mem_alphabet_of_mem_encode hu)).elim

theorem critical (hz : ∀ i, z ∉ (C i).alphabet)
    (hd : ∀ i j, i ≠ j → Disjoint (C i).alphabet (C j).alphabet) {n : ℕ}
    (hzero : ∀ i, q i [] ≠ none)
    (hc : ∀ i, CodeTable.Contextual (C i) (q i) n)
    (hi : ∀ i, CodeTable.ZeroIdeal (C i) (q i) n) : Critical (table C E wf q z n) n := by
  classical
  let rs := table C E wf q z n
  have hza : Absorbs rs z := absorbs C E wf q z n
  have hp := preserves_zero C E wf q z hz n
  have ht (i) : ∀ p ∈ CodeTable.table (C i) (E i) wf (q i) z n, p ∈ rs :=
    fun _ h => (mem_table C E wf q z).mpr (.inr ⟨i,h⟩)
  have hzeroPeak {w u v : List S} (hw : z ∈ w) (hu : Step rs w u) (hv : Step rs w v) :
      Join (Steps rs) u v :=
    ⟨[z], absorbs_mem hza (step_preserves_letter hp hw hu),
      absorbs_mem hza (step_preserves_letter hp hw hv)⟩
  have hnabs {u v : List S} (h : z ∉ u) : (u,v) ∉ Base.absorption z := by
    intro hh
    obtain ⟨a,ha,_⟩ := (Base.mem_absorption z).mp hh
    rcases ha with rfl | rfl <;> simp at h
  constructor
  · intro u u' v v' hu hv x y he hlen
    by_cases huz : z ∈ u
    · apply hzeroPeak huz
      · simpa using Step.apply hu [] []
      · simpa only [he] using Step.apply hv x y
    have hvz : z ∉ v := fun hh => huz (by simp [he,hh])
    have hut := (mem_table C E wf q z).mp hu
    have hvt := (mem_table C E wf q z).mp hv
    simp only [hnabs huz, hnabs hvz, false_or] at hut hvt
    obtain ⟨i,hui⟩ := hut
    obtain ⟨j,hvj⟩ := hvt
    by_cases hij : i = j
    · subst j
      exact CodeTable.critical_containment (C i) (E i) wf (q i) z
        (hzero i) hza (ht i) (hc i) (hi i) hui hvj he hlen
    · obtain ⟨a,_,_,_,rfl,_⟩ := (CodeTable.mem_table (C i) (E i) wf (q i) z).mp hui
      obtain ⟨b,_,hb,_,rfl,_⟩ := (CodeTable.mem_table (C j) (E j) wf (q j) z).mp hvj
      exact ((C i).disjoint_infix (C j) (hd i j hij) hb ⟨x,y,he.symm⟩).elim
  · intro u u' v v' hu hv p m t hm he hh hlen
    by_cases hwz : z ∈ p++m++t
    · apply hzeroPeak hwz
      · simpa only [he, List.nil_append, List.append_assoc] using Step.apply hu [] t
      · simpa only [hh, List.append_nil, List.append_assoc] using Step.apply hv p []
    have huz : z ∉ u := fun h => hwz (by simp [←he,h])
    have hvz : z ∉ v := fun h => hwz (by simpa only [List.append_assoc,←hh,List.mem_append] using Or.inr h)
    have hut := (mem_table C E wf q z).mp hu
    have hvt := (mem_table C E wf q z).mp hv
    simp only [hnabs huz, hnabs hvz, false_or] at hut hvt
    obtain ⟨i,hui⟩ := hut
    obtain ⟨j,hvj⟩ := hvt
    by_cases hij : i = j
    · subst j
      exact CodeTable.critical_overlap (C i) (E i) wf (q i) z
        (hzero i) hza (ht i) (hc i) (hi i) hui hvj hm he hh hlen
    · obtain ⟨a,_,_,_,rfl,_⟩ := (CodeTable.mem_table (C i) (E i) wf (q i) z).mp hui
      obtain ⟨b,_,_,_,rfl,_⟩ := (CodeTable.mem_table (C j) (E j) wf (q j) z).mp hvj
      exact ((C i).disjoint_overlap (C j) (hd i j hij) hm he hh).elim

theorem decreasing (n : ℕ) : ∀ p ∈ table C E wf q z n, List.Shortlex r p.2 p.1 := by
  classical
  intro ⟨u,v⟩ hp
  rcases (mem_table C E wf q z).mp hp with hp | ⟨i,hp⟩
  · obtain ⟨a,ha,rfl⟩ := (Base.mem_absorption z).mp hp
    rcases ha with rfl | rfl <;> exact List.Shortlex.of_length_lt (by simp)
  · exact CodeTable.decreasing (C i) (E i) wf (q i) z n (u,v) hp

theorem stable {k n : ℕ} (hkn : k ≤ n) :
    Selectors.BoundedEq (table C E wf q z k) (table C E wf q z n) k := by
  intro p hp
  simp only [mem_table]
  exact or_congr Iff.rfl (exists_congr (fun i => CodeTable.stable (C i) (E i) wf (q i) z hkn p hp))

theorem good_at (hz : ∀ i, z ∉ (C i).alphabet)
    (hd : ∀ i j, i ≠ j → Disjoint (C i).alphabet (C j).alphabet) {n : ℕ}
    (hzero : ∀ i, q i [] ≠ none)
    (hc : ∀ i, CodeTable.Contextual (C i) (q i) n)
    (hi : ∀ i, CodeTable.ZeroIdeal (C i) (q i) n) :
    GoodTable (r := r) (fun n => Part.some (table C E wf q z n)) n :=
  ⟨_, Part.mem_some_iff.mpr rfl, decreasing C E wf q z n,
    critical C E wf q z hz hd hzero hc hi⟩
end Families
end SimpleFInftyOvergroups.ContextualEncoding

end OAI