import OAI.Computability.StarHeight.Height

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uS

namespace EpisodeAlgebra

open scoped Computability

variable {Alphabet : Type u} {S : Type uS}

def PrefixCode (E : Language Alphabet) : Prop :=
  [] ∉ E ∧ ∀ e ∈ E, ∀ f ∈ E, e <+: f → e = f

def AllIn (D : Language Alphabet) (es : List (List Alphabet)) : Prop :=
  ∀ e ∈ es, e ∈ D

def updateWord (G : List Alphabet → S → S) (x : S) (es : List (List Alphabet)) : S :=
  es.foldl (fun z e => G e z) x

def graph (D : Language Alphabet) (G : List Alphabet → S → S) (x y : S) : Language Alphabet :=
  {w | ∃ es, AllIn D es ∧ es.flatten = w ∧ updateWord G x es = y}

lemma AllIn.mono {D E : Language Alphabet} {es : List (List Alphabet)}
    (h : AllIn D es) (hDE : D ≤ E) : AllIn E es := fun e he => hDE (h e he)

lemma AllIn.append {D : Language Alphabet} {es fs : List (List Alphabet)}
    (he : AllIn D es) (hf : AllIn D fs) : AllIn D (es ++ fs) := by
  intro e hm
  rcases List.mem_append.mp hm with hm | hm
  · exact he e hm
  · exact hf e hm

lemma AllIn.of_append_right {D : Language Alphabet} {es fs : List (List Alphabet)}
    (h : AllIn D (es ++ fs)) : AllIn D fs := fun e he => h e (List.mem_append_right _ he)

@[simp] lemma updateWord_nil (G : List Alphabet → S → S) (x : S) :
    updateWord G x [] = x := rfl

@[simp] lemma updateWord_cons (G : List Alphabet → S → S) (x : S)
    (e : List Alphabet) (es : List (List Alphabet)) :
    updateWord G x (e :: es) = updateWord G (G e x) es := rfl

lemma updateWord_append (G : List Alphabet → S → S) (x : S)
    (es fs : List (List Alphabet)) :
    updateWord G x (es ++ fs) = updateWord G (updateWord G x es) fs :=
  List.foldl_append

lemma graph_nil (D : Language Alphabet) (G : List Alphabet → S → S) (x : S) :
    [] ∈ graph D G x x := ⟨[], by simp [AllIn], rfl, rfl⟩

lemma graph_singleton {D : Language Alphabet} (G : List Alphabet → S → S)
    (x : S) {e : List Alphabet} (he : e ∈ D) : e ∈ graph D G x (G e x) :=
  ⟨[e], by simpa [AllIn], by simp, rfl⟩

lemma graph_mono {D E : Language Alphabet} (hDE : D ≤ E)
    (G : List Alphabet → S → S) (x y : S) : graph D G x y ≤ graph E G x y := by
  rintro w ⟨es, he, hw, hx⟩
  exact ⟨es, he.mono hDE, hw, hx⟩

lemma graph_concat {D : Language Alphabet} {G : List Alphabet → S → S}
    {x y z : S} {u v : List Alphabet} (hu : u ∈ graph D G x y)
    (hv : v ∈ graph D G y z) : u ++ v ∈ graph D G x z := by
  obtain ⟨es, he, rfl, hx⟩ := hu
  obtain ⟨fs, hf, rfl, hy⟩ := hv
  exact ⟨es ++ fs, he.append hf, List.flatten_append,
    by rw [updateWord_append, hx, hy]⟩

lemma flatten_prefix {E : Language Alphabet} (hE : PrefixCode E)
    {es fs : List (List Alphabet)} (he : AllIn E es) (hf : AllIn E fs)
    (hp : es.flatten <+: fs.flatten) : es <+: fs := by
  induction es generalizing fs with
  | nil => exact List.nil_prefix
  | cons e es ih =>
      have heE : e ∈ E := he e (by simp)
      cases fs with
      | nil =>
          obtain ⟨r, hr⟩ := hp
          have he0 : e = [] := by
            have hh : e ++ (es.flatten ++ r) = [] := by simpa [List.append_assoc] using hr
            exact (List.append_eq_nil_iff.mp hh).1
          exact False.elim (hE.1 (he0 ▸ heE))
      | cons f fs =>
          have hfE : f ∈ E := hf f (by simp)
          have hePre : e <+: (f :: fs).flatten :=
            (List.prefix_append e es.flatten).trans hp
          have hfPre : f <+: (f :: fs).flatten := List.prefix_append _ _
          have hef : e = f := by
            rcases List.prefix_or_prefix_of_prefix hePre hfPre with h | h
            · exact hE.2 e heE f hfE h
            · exact (hE.2 f hfE e heE h).symm
          subst f
          obtain ⟨r, hr⟩ := hp
          have htail : es.flatten ++ r = fs.flatten := by
            apply List.append_cancel_left (as := e)
            simpa only [List.flatten_cons, List.append_assoc] using hr
          have hrec := ih (fun a ha => he a (by simp [ha]))
            (fun a ha => hf a (by simp [ha])) ⟨r, htail⟩
          obtain ⟨gs, hgs⟩ := hrec
          exact ⟨gs, by simp [hgs]⟩

lemma consume_graph_prefix {E D D' : Language Alphabet} (hE : PrefixCode E)
    (hDE : D ≤ E) (hD'D : D' ≤ D) {G : List Alphabet → S → S}
    {x z : S} {u v : List Alphabet} {es : List (List Alphabet)}
    (hu : u ∈ graph D' G x z) (hes : AllIn D es) (hword : u ++ v = es.flatten) :
    ∃ fs, AllIn D fs ∧ fs.flatten = v ∧ updateWord G x es = updateWord G z fs := by
  obtain ⟨pre, hp, hu, hx⟩ := hu
  have hpre := flatten_prefix hE (hp.mono (hD'D.trans hDE)) (hes.mono hDE)
    (show pre.flatten <+: es.flatten from ⟨v, by rw [hu, hword]⟩)
  obtain ⟨fs, rfl⟩ := hpre
  refine ⟨fs, hes.of_append_right, ?_, ?_⟩
  · apply List.append_cancel_left (as := u)
    simpa only [List.flatten_append, hu] using hword.symm
  · rw [updateWord_append, hx]

lemma flatten_injective {E : Language Alphabet} (hE : PrefixCode E)
    {es fs : List (List Alphabet)} (he : AllIn E es) (hf : AllIn E fs)
    (h : es.flatten = fs.flatten) : es = fs := by
  have hp := flatten_prefix hE he hf (h ▸ List.prefix_rfl)
  have hq := flatten_prefix hE hf he (h.symm ▸ List.prefix_rfl)
  exact hp.sublist.antisymm hq.sublist

lemma graph_iff_update {E D : Language Alphabet} (hE : PrefixCode E) (hDE : D ≤ E)
    (G : List Alphabet → S → S) (x y : S) {es : List (List Alphabet)}
    (he : AllIn D es) : es.flatten ∈ graph D G x y ↔ updateWord G x es = y := by
  constructor
  · rintro ⟨fs, hf, hw, hx⟩
    have hfs := flatten_injective hE (hf.mono hDE) (he.mono hDE) hw
    simpa only [hfs] using hx
  · exact fun hx => ⟨es, he, rfl, hx⟩

def SplitSound (D : Language Alphabet) (G : List Alphabet → S → S)
    (P Q : S → Language Alphabet) : Prop :=
  ∀ (x y : S) (es : List (List Alphabet)) (u v : List Alphabet),
    AllIn D es → u ∈ P x → v ∈ Q y → u ++ v <+: es.flatten →
      ∃ e fs, es = e :: fs ∧ u ++ v = e ∧ G e x = y

def SplitAvailable (D D' : Language Alphabet) (G : List Alphabet → S → S)
    (P Q : S → Language Alphabet) : Prop :=
  ∀ e ∈ D, e ∉ D' → ∀ x, e ∈ P x * Q (G e x)

lemma consume_pair_prefix {D : Language Alphabet} {G : List Alphabet → S → S}
    {P Q : S → Language Alphabet} (hs : SplitSound D G P Q)
    {x y : S} {u v r : List Alphabet} {es : List (List Alphabet)}
    (he : AllIn D es) (hu : u ∈ P x) (hv : v ∈ Q y)
    (hw : (u ++ v) ++ r = es.flatten) :
    ∃ fs, AllIn D fs ∧ fs.flatten = r ∧ updateWord G x es = updateWord G y fs := by
  obtain ⟨e, fs, rfl, huv, hxy⟩ := hs x y es u v he hu hv ⟨r, hw⟩
  refine ⟨fs, fun a ha => he a (by simp [ha]), ?_, ?_⟩
  · apply List.append_cancel_left (as := e)
    simpa only [List.flatten_cons, huv] using hw.symm
  · simp only [updateWord_cons, hxy]

def start (W : S → S → Language Alphabet) (P : S → Language Alphabet) (x : S) :=
  ⨆ i, W x i * P i

def middle (W : S → S → Language Alphabet) (P Q : S → Language Alphabet) :=
  ⨆ j, ⨆ i, Q j * W j i * P i

def finish (W : S → S → Language Alphabet) (Q : S → Language Alphabet) (y : S) :=
  ⨆ l, Q l * W l y

def body (W : S → S → Language Alphabet) (P Q : S → Language Alphabet) (x y : S) :=
  W x y + start W P x * (middle W P Q)∗ * finish W Q y

lemma mem_start_iff {W : S → S → Language Alphabet} {P : S → Language Alphabet}
    {x : S} {w : List Alphabet} : w ∈ start W P x ↔
    ∃ i u v, u ∈ W x i ∧ v ∈ P i ∧ u ++ v = w := by
  simp only [start, Language.mem_iSup, Language.mem_mul]
  aesop

lemma mem_middle_iff {W : S → S → Language Alphabet} {P Q : S → Language Alphabet}
    {w : List Alphabet} : w ∈ middle W P Q ↔
    ∃ j i u v p, u ∈ Q j ∧ v ∈ W j i ∧ p ∈ P i ∧ (u ++ v) ++ p = w := by
  simp only [middle, Language.mem_iSup, Language.mem_mul]
  constructor
  · rintro ⟨j, i, a, ⟨u, hu, v, hv, rfl⟩, p, hp, rfl⟩
    exact ⟨j, i, u, v, p, hu, hv, hp, rfl⟩
  · rintro ⟨j, i, u, v, p, hu, hv, hp, rfl⟩
    exact ⟨j, i, u ++ v, ⟨u, hu, v, hv, rfl⟩, p, hp, rfl⟩

lemma mem_finish_iff {W : S → S → Language Alphabet} {Q : S → Language Alphabet}
    {y : S} {w : List Alphabet} : w ∈ finish W Q y ↔
    ∃ j u v, u ∈ Q j ∧ v ∈ W j y ∧ u ++ v = w := by
  simp only [finish, Language.mem_iSup, Language.mem_mul]
  aesop

lemma mem_body_iff {W : S → S → Language Alphabet} {P Q : S → Language Alphabet}
    {x y : S} {w : List Alphabet} : w ∈ body W P Q x y ↔
    w ∈ W x y ∨ ∃ a ms b, a ∈ start W P x ∧ AllIn (middle W P Q) ms ∧
      b ∈ finish W Q y ∧ (a ++ ms.flatten) ++ b = w := by
  simp only [body, Language.mem_add, Language.mem_mul, Language.mem_kstar]
  constructor
  · rintro (h | ⟨c, ⟨a, ha, m, ⟨ms, rfl, hm⟩, rfl⟩, b, hb, rfl⟩)
    · exact Or.inl h
    · exact Or.inr ⟨a, ms, b, ha, hm, hb, rfl⟩
  · rintro (h | ⟨a, ms, b, ha, hm, hb, rfl⟩)
    · exact Or.inl h
    · exact Or.inr ⟨a ++ ms.flatten, ⟨a, ha, ms.flatten, ⟨ms, rfl, hm⟩, rfl⟩,
        b, hb, rfl⟩

lemma suffix_sound {E D D' : Language Alphabet} (hE : PrefixCode E)
    (hDE : D ≤ E) (hD'D : D' ≤ D) {G : List Alphabet → S → S}
    {P Q : S → Language Alphabet} (hs : SplitSound D G P Q)
    (ms : List (List Alphabet)) (hm : AllIn (middle (graph D' G) P Q) ms)
    {x y : S} {p b : List Alphabet} {es : List (List Alphabet)}
    (hp : p ∈ P x) (hb : b ∈ finish (graph D' G) Q y) (he : AllIn D es)
    (hw : (p ++ ms.flatten) ++ b = es.flatten) : updateWord G x es = y := by
  induction ms generalizing x p es with
  | nil =>
      obtain ⟨j, q, w, hq, hwg, rfl⟩ := mem_finish_iff.mp hb
      have hw' : (p ++ q) ++ w = es.flatten := by simpa [List.append_assoc] using hw
      obtain ⟨fs, hf, hfw, hxy⟩ := consume_pair_prefix hs he hp hq hw'
      rw [hxy]
      apply (graph_iff_update hE hDE G j y hf).mp
      rw [hfw]
      exact graph_mono hD'D G j y hwg
  | cons m ms ih =>
      obtain ⟨j, i, q, w, p', hq, hwg, hp', rfl⟩ :=
        mem_middle_iff.mp (hm m (by simp))
      have hw' : (p ++ q) ++ (w ++ ((p' ++ ms.flatten) ++ b)) = es.flatten := by
        simpa only [List.flatten_cons, List.append_assoc] using hw
      obtain ⟨fs, hf, hfw, hxy⟩ := consume_pair_prefix hs he hp hq hw'
      obtain ⟨gs, hg, hgw, hj⟩ := consume_graph_prefix hE hDE hD'D hwg hf hfw.symm
      rw [hxy, hj]
      exact ih (fun a ha => hm a (by simp [ha])) hp' hg hgw.symm

lemma body_sound {E D D' : Language Alphabet} (hE : PrefixCode E)
    (hDE : D ≤ E) (hD'D : D' ≤ D) {G : List Alphabet → S → S}
    {P Q : S → Language Alphabet} (hs : SplitSound D G P Q)
    {x y : S} {es : List (List Alphabet)} (he : AllIn D es)
    (hb : es.flatten ∈ body (graph D' G) P Q x y) : updateWord G x es = y := by
  rcases mem_body_iff.mp hb with hw | ⟨a, ms, b, ha, hm, hb, hword⟩
  · exact (graph_iff_update hE hDE G x y he).mp (graph_mono hD'D G x y hw)
  · obtain ⟨i, w, p, hw, hp, rfl⟩ := mem_start_iff.mp ha
    have hword' : w ++ ((p ++ ms.flatten) ++ b) = es.flatten := by
      simpa only [List.append_assoc] using hword
    obtain ⟨fs, hf, hfw, hxy⟩ := consume_graph_prefix hE hDE hD'D hw he hword'
    rw [hxy]
    exact suffix_sound hE hDE hD'D hs ms hm hp hb hf hfw.symm

lemma body_prepend_skip {D' : Language Alphabet} {G : List Alphabet → S → S}
    {P Q : S → Language Alphabet} {x z y : S} {u v : List Alphabet}
    (hu : u ∈ graph D' G x z) (hv : v ∈ body (graph D' G) P Q z y) :
    u ++ v ∈ body (graph D' G) P Q x y := by
  apply mem_body_iff.mpr
  rcases mem_body_iff.mp hv with hv | ⟨a, ms, b, ha, hm, hb, rfl⟩
  · exact Or.inl (graph_concat hu hv)
  · obtain ⟨i, w, p, hw, hp, rfl⟩ := mem_start_iff.mp ha
    apply Or.inr
    refine ⟨(u ++ w) ++ p, ms, b, ?_, hm, hb, ?_⟩
    · exact mem_start_iff.mpr ⟨i, u ++ w, p, graph_concat hu hw, hp, rfl⟩
    · simp only [List.append_assoc]

lemma body_prepend_pair {D' : Language Alphabet} {G : List Alphabet → S → S}
    {P Q : S → Language Alphabet} {x z y : S} {p q v : List Alphabet}
    (hp : p ∈ P x) (hq : q ∈ Q z) (hv : v ∈ body (graph D' G) P Q z y) :
    (p ++ q) ++ v ∈ body (graph D' G) P Q x y := by
  have hstart : p ∈ start (graph D' G) P x :=
    mem_start_iff.mpr ⟨x, [], p, graph_nil D' G x, hp, by simp⟩
  apply mem_body_iff.mpr
  rcases mem_body_iff.mp hv with hv | ⟨a, ms, b, ha, hm, hb, rfl⟩
  · refine Or.inr ⟨p, [], q ++ v, hstart, by simp [AllIn], ?_, ?_⟩
    · exact mem_finish_iff.mpr ⟨z, q, v, hq, hv, rfl⟩
    · simp [List.append_assoc]
  · obtain ⟨i, w, r, hw, hr, rfl⟩ := mem_start_iff.mp ha
    have hmid : (q ++ w) ++ r ∈ middle (graph D' G) P Q :=
      mem_middle_iff.mpr ⟨z, i, q, w, r, hq, hw, hr, rfl⟩
    refine Or.inr ⟨p, ((q ++ w) ++ r) :: ms, b, hstart, ?_, hb, ?_⟩
    · intro a ha
      rcases List.mem_cons.mp ha with rfl | ha
      · exact hmid
      · exact hm a ha
    · simp only [List.flatten_cons, List.append_assoc]

lemma body_available {D D' : Language Alphabet} {G : List Alphabet → S → S}
    {P Q : S → Language Alphabet} (ha : SplitAvailable D D' G P Q)
    (es : List (List Alphabet)) (he : AllIn D es) (x : S) :
    es.flatten ∈ body (graph D' G) P Q x (updateWord G x es) := by
  classical
  induction es generalizing x with
  | nil => exact mem_body_iff.mpr (Or.inl (graph_nil D' G x))
  | cons e es ih =>
      have heD := he e (by simp)
      have hes : AllIn D es := fun a ha => he a (by simp [ha])
      have hind := ih hes (G e x)
      by_cases he' : e ∈ D'
      · exact body_prepend_skip (graph_singleton G x he') hind
      · obtain ⟨p, hp, q, hq, heq⟩ := Language.mem_mul.mp (ha e heD he' x)
        simpa only [heq, List.flatten_cons, updateWord_cons] using body_prepend_pair hp hq hind

theorem split_identity {E D D' : Language Alphabet} (hE : PrefixCode E)
    (hDE : D ≤ E) (hD'D : D' ≤ D) (G : List Alphabet → S → S)
    (P Q : S → Language Alphabet) (hs : SplitSound D G P Q)
    (ha : SplitAvailable D D' G P Q) (x y : S) :
    graph D G x y = D∗ ⊓ body (graph D' G) P Q x y := by
  ext w
  constructor
  · rintro ⟨es, he, rfl, rfl⟩
    exact ⟨Language.join_mem_kstar he, body_available ha es he x⟩
  · rintro ⟨⟨es, rfl, he⟩, hb⟩
    exact ⟨es, he, rfl, body_sound hE hDE hD'D hs he hb⟩

theorem split_height [Finite S] {E D D' : Language Alphabet} (hE : PrefixCode E)
    (hDE : D ≤ E) (hD'D : D' ≤ D) (G : List Alphabet → S → S)
    (P Q : S → Language Alphabet) (hs : SplitSound D G P Q)
    (ha : SplitAvailable D D' G P Q) (H : ℕ)
    (hD : HasHeightAtMost D 1) (hP : ∀ x, HasHeightAtMost (P x) 1)
    (hQ : ∀ y, HasHeightAtMost (Q y) 1)
    (hW : ∀ x y, HasHeightAtMost (graph D' G x y) H) (x y : S) :
    HasHeightAtMost (graph D G x y) (max 2 (1 + H)) := by
  rw [split_identity hE hDE hD'D G P Q hs ha]
  have hH : H ≤ max 2 (1 + H) := by omega
  have h1 : 1 ≤ max 1 H := le_max_left _ _
  have hh : H ≤ max 1 H := le_max_right _ _
  have hm : max 1 H ≤ max 2 (1 + H) := by omega
  have hstar : 1 + max 1 H ≤ max 2 (1 + H) := by omega
  apply (hD.star.mono (le_max_left _ _)).inter
  apply (hW x y |>.mono hH).union
  apply HasHeightAtMost.concat
  · apply HasHeightAtMost.concat
    · exact (HasHeightAtMost.iSup _ (fun i => (hW x i |>.mono hh).concat
        (hP i |>.mono h1))).mono hm
    · exact (HasHeightAtMost.iSup _ (fun j => HasHeightAtMost.iSup _ (fun i =>
        ((hQ j |>.mono h1).concat (hW j i |>.mono hh)).concat (hP i |>.mono h1)))).star.mono hstar
  · exact (HasHeightAtMost.iSup _ (fun l => (hQ l |>.mono h1).concat
      (hW l y |>.mono hh))).mono hm

lemma graph_empty [DecidableEq S] (G : List Alphabet → S → S) (x y : S) :
    graph (0 : Language Alphabet) G x y = if x = y then 1 else 0 := by
  classical
  ext w
  by_cases h : x = y
  · subst y
    simp only [ite_true, Language.mem_one]
    constructor
    · rintro ⟨es, he, rfl, _⟩
      have hes : es = [] := by
        cases es with
        | nil => rfl
        | cons e es => exact False.elim (he e (by simp))
      simp [hes]
    · rintro rfl
      exact graph_nil 0 G x
  · simp only [h, ite_false, Language.notMem_zero, iff_false]
    rintro ⟨es, he, _, hu⟩
    have hes : es = [] := by
      cases es with
      | nil => rfl
      | cons e es => exact False.elim (he e (by simp))
    exact h (by simpa [hes] using hu)

lemma empty_skip_height (G : List Alphabet → S → S) (x y : S) :
    HasHeightAtMost (graph (0 : Language Alphabet) G x y) 0 := by
  classical
  rw [graph_empty]
  split
  · exact HasHeightAtMost.one 0
  · exact HasHeightAtMost.zero 0

end EpisodeAlgebra

end GeneralizedStarHeight

end OAI