import OAI.Computability.StarHeight.Markers

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uAlphabet uι uι2 uι3

namespace LocalMarkers

variable {Alphabet : Type uAlphabet}

def AgreesOn (f g : ℤ → Alphabet) (l r : ℤ) : Prop :=
  ∀ x : ℤ, l ≤ x → x < r → f x = g x

def ShortContinuation (d K : ℕ) (w : ℤ → Alphabet) (z : ℤ) (v : ℤ → Alphabet) : Prop :=
  (∃ a : ℕ, 0 < a ∧ a < d ∧ Function.Periodic v (a : ℤ)) ∧
    AgreesOn w v z (z + K)

lemma short_continuation_exists {d K : ℕ} (hK : d ≤ K) (w : ℤ → Alphabet) (z : ℤ)
    (hp : ∃ a : ℕ, 0 < a ∧ a < d ∧ Period (fun i : Fin K => w (z + i.val)) a) :
    ∃ v : ℤ → Alphabet, ShortContinuation d K w z v := by
  obtain ⟨a, ha, had, hp⟩ := hp
  obtain ⟨v, hv, he⟩ := exists_continuation z ha (by omega) hp
  refine ⟨v, ⟨a, ha, had, hv⟩, ?_⟩
  intro x hx hx'
  have hn : ((x - z).toNat : ℤ) = x - z := Int.toNat_of_nonneg (by omega)
  let i : Fin K := ⟨(x - z).toNat, by omega⟩
  have hi : z + (i.val : ℤ) = x := by dsimp [i]; omega
  simpa only [hi] using (he i).symm

lemma short_continuations_equal {d K : ℕ} {w v v' : ℤ → Alphabet} {z z' : ℤ}
    (hv : ShortContinuation d K w z v) (hv' : ShortContinuation d K w z' v')
    (hover : (d : ℤ) ^ 2 ≤ (K : ℤ) - |z - z'|) : v = v' := by
  obtain ⟨⟨a, ha, had, hva⟩, he⟩ := hv
  obtain ⟨⟨b, hb, hbd, hvb⟩, he'⟩ := hv'
  have haZ : 0 < (a : ℤ) := by omega
  have hbZ : 0 < (b : ℤ) := by omega
  have hadZ : (a : ℤ) < d := by omega
  have hbdZ : (b : ℤ) < d := by omega
  have hab : (a : ℤ) * b ≤ (d : ℤ) ^ 2 := by nlinarith
  apply periodic_agree haZ hbZ hva hvb (max z z')
  intro x hx hx'
  have hz : z ≤ x := (le_max_left z z').trans hx
  have hz' : z' ≤ x := (le_max_right z z').trans hx
  have hu : x < z + K := by
    have hmax : max z z' = if z ≤ z' then z' else z := max_def _ _
    split_ifs at hmax with hzz
    · rw [abs_of_nonpos (by omega)] at hover
      omega
    · rw [abs_of_nonneg (by omega)] at hover
      omega
  have hu' : x < z' + K := by
    have hmax : max z z' = if z ≤ z' then z' else z := max_def _ _
    split_ifs at hmax with hzz
    · rw [abs_of_nonpos (by omega)] at hover
      omega
    · rw [abs_of_nonneg (by omega)] at hover
      omega
  exact (he x hz hu).symm.trans (he' x hz' hu')

lemma common_continuation {d K : ℕ} (w : ℤ → Alphabet) (S : Finset ℤ)
    (hne : S.Nonempty) (v : ℤ → ℤ → Alphabet)
    (hv : ∀ z ∈ S, ShortContinuation d K w z (v z))
    (hover : ∀ z ∈ S, ∀ z' ∈ S, (d : ℤ) ^ 2 ≤ (K : ℤ) - |z - z'|) :
    ∃ u : ℤ → Alphabet, (∃ a : ℕ, 0 < a ∧ a < d ∧ Function.Periodic u (a : ℤ)) ∧
      ∀ z ∈ S, v z = u ∧ AgreesOn w u z (z + K) := by
  obtain ⟨z, hz⟩ := hne
  refine ⟨v z, (hv z hz).1, ?_⟩
  intro z' hz'
  have he := short_continuations_equal (hv z' hz') (hv z hz) (hover z' hz' z hz)
  exact ⟨he, he ▸ (hv z' hz').2⟩

lemma periodic_run {d K : ℕ} (hd : 2 ≤ d) (hK : 3 * d ^ 2 < K)
    (w : ℤ → Alphabet) (l u : ℤ) (hlu : l ≤ u)
    (hp : ∀ x : ℤ, l ≤ x → x ≤ u →
      ∃ a : ℕ, 0 < a ∧ a < d ∧ Period (fun i : Fin K => w (x + i.val)) a) :
    ∃ v : ℤ → Alphabet, (∃ a : ℕ, 0 < a ∧ a < d ∧ Function.Periodic v (a : ℤ)) ∧
      AgreesOn w v l (u + K) := by
  classical
  have hdK : d ≤ K := by nlinarith
  have hex : ∀ x : {x : ℤ // l ≤ x ∧ x ≤ u},
      ∃ v : ℤ → Alphabet, ShortContinuation d K w x.val v := by
    intro x
    exact short_continuation_exists hdK w x.val (hp x.val x.2.1 x.2.2)
  choose v hv using hex
  let x₀ : {x : ℤ // l ≤ x ∧ x ≤ u} := ⟨l, le_refl _, hlu⟩
  have heq : ∀ (n : ℕ) (hn : l + n ≤ u),
      v ⟨l + n, by omega, hn⟩ = v x₀ := by
    intro n
    induction n with
    | zero => intro hn; congr 1; apply Subtype.ext; simp [x₀]
    | succ n ih =>
      intro hn
      have hn' : l + (n : ℤ) ≤ u := by omega
      have hover : (d : ℤ) ^ 2 ≤ (K : ℤ) - |(l + (n + 1 : ℕ)) - (l + n)| := by
        have hh : (n + 1 : ℕ) = n + 1 := rfl
        have hcast : (3 : ℤ) * (d : ℤ) ^ 2 < K := by exact_mod_cast hK
        have habs : |(l + (n + 1 : ℕ)) - (l + n)| = 1 := by
          rw [Nat.cast_add, Nat.cast_one]
          ring_nf
          norm_num
        rw [habs]
        nlinarith [sq_nonneg (d : ℤ)]
      exact (short_continuations_equal (hv ⟨l + ((n + 1 : ℕ) : ℤ), by omega, hn⟩)
        (hv ⟨l + n, by omega, hn'⟩) hover).trans (ih hn')
  refine ⟨v x₀, (hv x₀).1, ?_⟩
  intro i hi hi'
  let x : ℤ := min i u
  have hx : l ≤ x ∧ x ≤ u := ⟨le_min hi hlu, min_le_right _ _⟩
  have hn : ((x - l).toNat : ℤ) = x - l := Int.toNat_of_nonneg (by omega)
  have he : v ⟨x, hx⟩ = v x₀ := by
    have hh := heq (x - l).toNat (by omega)
    have hxval : l + (((x - l).toNat : ℕ) : ℤ) = x := by omega
    simpa only [hxval] using hh
  rw [← he]
  apply (hv ⟨x, hx⟩).2 i (min_le_left _ _)
  dsimp [x]
  rcases le_total i u with h | h
  · rw [min_eq_left h]
    have : (0 : ℤ) < K := by omega
    omega
  · rwa [min_eq_right h]

end LocalMarkers

namespace MarkerSearch

def Separated (S : Set ℤ) (d : ℤ) : Prop :=
  ∀ x ∈ S, ∀ y ∈ S, x ≠ y → d ≤ |x - y|

def FirstAfter (S : Set ℤ) (l m : ℤ) : Prop :=
  m ∈ S ∧ l ≤ m ∧ ∀ m' ∈ S, l ≤ m' → m ≤ m'

lemma firstAfter_unique {S : Set ℤ} {l m m' : ℤ}
    (h : FirstAfter S l m) (h' : FirstAfter S l m') : m = m' :=
  le_antisymm (h.2.2 m' h'.1 h'.2.1) (h'.2.2 m h.1 h.2.1)

noncomputable def search (S : Set ℤ) (l r : ℤ) : Option ℤ := by
  classical
  let F := (Finset.Icc l r).filter (· ∈ S)
  exact if h : F.Nonempty then some (F.min' h) else none

lemma search_none {S : Set ℤ} {l r : ℤ} :
    search S l r = none ↔ ∀ m ∈ S, l ≤ m → m ≤ r → False := by
  classical
  dsimp only [search]
  split_ifs with h
  · simp only [false_iff]
    obtain ⟨m, hm⟩ := h
    have hh := Finset.mem_filter.mp hm
    have hb := Finset.mem_Icc.mp hh.1
    exact fun hn => hn m hh.2 hb.1 hb.2
  · simp only [true_iff]
    intro m hm hl hr
    exact h ⟨m, Finset.mem_filter.mpr ⟨Finset.mem_Icc.mpr ⟨hl, hr⟩, hm⟩⟩

lemma search_some {S : Set ℤ} {l r m : ℤ} :
    search S l r = some m ↔ FirstAfter S l m ∧ m ≤ r := by
  classical
  let F := (Finset.Icc l r).filter (· ∈ S)
  constructor
  · dsimp only [search]
    split_ifs with h
    · intro he
      have hm : F.min' h = m := Option.some.inj he
      have hmem : m ∈ F := hm ▸ F.min'_mem h
      obtain ⟨hb, hS⟩ := Finset.mem_filter.mp hmem
      obtain ⟨hl, hr⟩ := Finset.mem_Icc.mp hb
      refine ⟨⟨hS, hl, ?_⟩, hr⟩
      intro m' hm' hl'
      by_cases hr' : m' ≤ r
      · rw [← hm]
        exact F.min'_le m' (Finset.mem_filter.mpr ⟨Finset.mem_Icc.mpr ⟨hl', hr'⟩, hm'⟩)
      · omega
    · simp
  · rintro ⟨h, hr⟩
    have hf : F.Nonempty := ⟨m, Finset.mem_filter.mpr ⟨Finset.mem_Icc.mpr ⟨h.2.1, hr⟩, h.1⟩⟩
    have hmem := F.min'_mem hf
    obtain ⟨hb, hS⟩ := Finset.mem_filter.mp hmem
    obtain ⟨hl, _⟩ := Finset.mem_Icc.mp hb
    have he : F.min' hf = m := le_antisymm
      (F.min'_le m (Finset.mem_filter.mpr ⟨Finset.mem_Icc.mpr ⟨h.2.1, hr⟩, h.1⟩))
      (h.2.2 _ hS hl)
    dsimp only [search]
    rw [dite_eq_left hf]
    exact congrArg some he

lemma search_some_or_none (S : Set ℤ) (l r : ℤ) :
    (∀ m ∈ S, l ≤ m → m ≤ r → False) ∨
      ∃ m, FirstAfter S l m ∧ m ≤ r := by
  cases h : search S l r with
  | none => exact Or.inl (search_none.mp h)
  | some m => exact Or.inr ⟨m, search_some.mp h⟩

lemma search_ext {S : Set ℤ} {l r l' r' : ℤ}
    (he : ∀ m ∈ S, (l ≤ m ∧ m ≤ r) ↔ (l' ≤ m ∧ m ≤ r')) :
    search S l r = search S l' r' := by
  classical
  have hf : (Finset.Icc l r).filter (· ∈ S) = (Finset.Icc l' r').filter (· ∈ S) := by
    ext m
    simp only [Finset.mem_filter, Finset.mem_Icc]
    constructor
    · rintro ⟨h, hS⟩
      exact ⟨(he m hS).mp h, hS⟩
    · rintro ⟨h, hS⟩
      exact ⟨(he m hS).mpr h, hS⟩
  dsimp only [search]
  simp only [hf]

lemma firstAfter_shift {S : Set ℤ} {l v m w : ℤ} (_hw : 0 ≤ w) (hv : |v| ≤ w)
    (hleft : ∀ m ∈ S, w < |m - l|) :
    FirstAfter S (l + v) m ↔ FirstAfter S l m := by
  have hv' := abs_le.mp hv
  constructor
  · intro h
    have hml := h.2.1
    have hdist := hleft m h.1
    have hl : l ≤ m := by
      by_contra hn
      rw [abs_of_neg (by omega)] at hdist
      omega
    refine ⟨h.1, hl, ?_⟩
    intro m' hm' hl'
    have hdist' := hleft m' hm'
    rw [abs_of_nonneg (by omega)] at hdist'
    exact h.2.2 m' hm' (by omega)
  · intro h
    have hml := h.2.1
    have hdist := hleft m h.1
    rw [abs_of_nonneg (by omega)] at hdist
    refine ⟨h.1, by omega, ?_⟩
    intro m' hm' hl'
    have hdist' := hleft m' hm'
    have hl'' : l ≤ m' := by
      by_contra hn
      rw [abs_of_neg (by omega)] at hdist'
      omega
    exact h.2.2 m' hm' hl''

lemma instability_charge {S : Set ℤ} {l r v w : ℤ} (hw : 0 ≤ w) (hv : |v| ≤ w)
    (hne : search S l r ≠ search S (l + v) (r + v)) :
    (∃ m ∈ S, |m - l| ≤ w) ∨
      ∃ m, FirstAfter S l m ∧ |m - r| ≤ w := by
  classical
  by_cases hn : ∃ m ∈ S, |m - l| ≤ w
  · exact Or.inl hn
  · right
    have hleft : ∀ m ∈ S, w < |m - l| := by
      intro m hm
      exact lt_of_not_ge (fun he => hn ⟨m, hm, he⟩)
    have hv' := abs_le.mp hv
    cases h₀ : search S l r with
    | none =>
      cases h₁ : search S (l + v) (r + v) with
      | none => exact False.elim (hne (h₀.trans h₁.symm))
      | some m =>
        obtain ⟨hm, hmr⟩ := search_some.mp h₁
        have hm' := (firstAfter_shift hw hv hleft).mp hm
        have hlarge : r < m := by
          by_contra he
          exact search_none.mp h₀ m hm'.1 hm'.2.1 (le_of_not_gt he)
        refine ⟨m, hm', ?_⟩
        rw [abs_of_pos (by omega)]
        omega
    | some m =>
      obtain ⟨hm, hmr⟩ := search_some.mp h₀
      cases h₁ : search S (l + v) (r + v) with
      | none =>
        have hm' := (firstAfter_shift hw hv hleft).mpr hm
        have hlarge : r + v < m := by
          by_contra he
          exact search_none.mp h₁ m hm'.1 hm'.2.1 (le_of_not_gt he)
        refine ⟨m, hm, ?_⟩
        rw [abs_of_nonpos (by omega)]
        omega
      | some m' =>
        have hm' := (firstAfter_shift hw hv hleft).mp (search_some.mp h₁).1
        have he := firstAfter_unique hm hm'
        exact False.elim (hne (h₀.trans ((congrArg some he).trans h₁.symm)))

lemma extension_charge {S : Set ℤ} {l r H : ℤ}
    (hn : search S l r = none) (he : ∃ m ∈ S, l ≤ m ∧ m ≤ r + H) :
    ∃ m, FirstAfter S l m ∧ 0 < m - r ∧ m - r ≤ H := by
  have hsome : search S l (r + H) ≠ none := by
    intro h
    obtain ⟨m, hm, hl, hr⟩ := he
    exact search_none.mp h m hm hl hr
  cases h : search S l (r + H) with
  | none => exact False.elim (hsome h)
  | some m =>
    obtain ⟨hm, hr⟩ := search_some.mp h
    have hlo : r < m := by
      by_contra he
      exact search_none.mp hn m hm.1 hm.2.1 (le_of_not_gt he)
    exact ⟨m, hm, by omega, by omega⟩

end MarkerSearch

namespace MarkerSearch

open scoped Classical

lemma close_unique {a b c w : ℤ} (ha : |a - c| ≤ w) (hb : |b - c| ≤ w)
    (hgap : 2 * w < |a - b|) : False := by
  have h := abs_sub_le a c b
  rw [abs_sub_comm c b] at h
  omega

lemma separated_interval_unique {S : Set ℤ} {d l r x y : ℤ}
    (hS : Separated S d) (hlen : r - l < d)
    (hx : x ∈ S) (hy : y ∈ S) (hxl : l ≤ x) (hxr : x ≤ r)
    (hyl : l ≤ y) (hyr : y ≤ r) : x = y := by
  by_contra hn
  have h := hS x hx y hy hn
  have hxy : |x - y| ≤ r - l := abs_le.mpr ⟨by omega, by omega⟩
  omega

lemma firstAfter_same_side {S : Set ℤ} {d l r z z' m m' : ℤ}
    (hS : Separated S d) (hlen : r - l < d)
    (hz : l ≤ z ∧ z ≤ r) (hz' : l ≤ z' ∧ z' ≤ r)
    (hm : FirstAfter S z m) (hm' : FirstAfter S z' m')
    (hside : (m ≤ r) ↔ (m' ≤ r)) : m = m' := by
  by_cases h : m ≤ r
  · exact separated_interval_unique hS hlen hm.1 hm'.1
      (hz.1.trans hm.2.1) h (hz'.1.trans hm'.2.1) (hside.mp h)
  · have h' : r < m' := lt_of_not_ge (fun hh => h (hside.mpr hh))
    exact le_antisymm (hm.2.2 m' hm'.1 (by omega))
      (hm'.2.2 m hm.1 (by omega))

lemma left_charge_card {ι : Type uι} (s : Finset ι) {S : Set ℤ}
    {d z h w : ℤ} (δ : ι → ℤ)
    (hS : Separated S d) (hsep : 2 * h + 2 * w < d)
    (hδ : ∀ i ∈ s, |δ i| ≤ h)
    (hgap : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → 2 * w < |δ i - δ j|) :
    (s.filter fun i => ∃ m ∈ S, |m - (z + δ i)| ≤ w).card ≤ 1 := by
  classical
  apply Finset.card_le_one.mpr
  intro i hi j hj
  obtain ⟨hi, m, hm, hmclose⟩ := Finset.mem_filter.mp hi
  obtain ⟨hj, m', hm', hmclose'⟩ := Finset.mem_filter.mp hj
  have hiδ := abs_le.mp (hδ i hi)
  have hjδ := abs_le.mp (hδ j hj)
  have hmδ := abs_le.mp hmclose
  have hmδ' := abs_le.mp hmclose'
  have he : m = m' := separated_interval_unique hS (by omega) hm hm'
    (show z - h - w ≤ m by omega) (show m ≤ z + h + w by omega)
    (by omega) (by omega)
  subst m'
  by_contra hij
  have ha : |δ i - (m - z)| ≤ w := by
    rw [abs_sub_comm]
    convert hmclose using 1
    congr 1
    ring
  have hb : |δ j - (m - z)| ≤ w := by
    rw [abs_sub_comm]
    convert hmclose' using 1
    congr 1
    ring
  exact close_unique ha hb (hgap i hi j hj hij)

lemma right_charge_card {ι : Type uι2} (s : Finset ι) {S : Set ℤ}
    {d z h w : ℤ} (δ H : ι → ℤ)
    (hS : Separated S d) (hsep : 2 * h < d)
    (hδ : ∀ i ∈ s, |δ i| ≤ h)
    (hgap : ∀ i ∈ s, ∀ j ∈ s, i ≠ j →
      2 * w < |(z + δ i + H i) - (z + δ j + H j)|) :
    (s.filter fun i => ∃ m, FirstAfter S (z + δ i) m ∧
      |m - (z + δ i + H i)| ≤ w).card ≤ 2 := by
  classical
  let F := s.filter fun i => ∃ m, FirstAfter S (z + δ i) m ∧
    |m - (z + δ i + H i)| ≤ w
  have hp : ∀ i : {i // i ∈ F}, ∃ m, FirstAfter S (z + δ i.val) m ∧
      |m - (z + δ i.val + H i.val)| ≤ w :=
    fun i => (Finset.mem_filter.mp i.2).2
  choose m hm using hp
  have hinj : Function.Injective (fun i => decide (m i ≤ z + h)) := by
    intro i j he
    have hi := (Finset.mem_filter.mp i.2).1
    have hj := (Finset.mem_filter.mp j.2).1
    have hiδ := abs_le.mp (hδ i.val hi)
    have hjδ := abs_le.mp (hδ j.val hj)
    have hside : (m i ≤ z + h) ↔ (m j ≤ z + h) := by simpa using he
    have hme := firstAfter_same_side hS (show z + h - (z - h) < d by omega)
      (show z - h ≤ z + δ i.val ∧ z + δ i.val ≤ z + h by omega)
      (show z - h ≤ z + δ j.val ∧ z + δ j.val ≤ z + h by omega)
      (hm i).1 (hm j).1 hside
    apply Subtype.ext
    by_contra hij
    have hc := (hm j).2
    rw [← hme] at hc
    exact close_unique (by simpa [abs_sub_comm] using (hm i).2)
      (by simpa [abs_sub_comm] using hc) (hgap i.val hi j.val hj hij)
  simpa [F] using Fintype.card_le_of_injective _ hinj

def InnerFailure (S : Set ℤ) (z H w E : ℤ) : Prop :=
  (∃ v, |v| ≤ w ∧ search S z (z + H) ≠ search S (z + v) (z + H + v)) ∨
  (search S z (z + H) = none ∧ ∃ m ∈ S, z ≤ m ∧ m ≤ z + H + E)

lemma innerFailure_charge {S : Set ℤ} {z H w E : ℤ} (hw : 0 ≤ w)
    (hf : InnerFailure S z H w E) :
    (∃ m ∈ S, |m - z| ≤ w) ∨
      ∃ m, FirstAfter S z m ∧ |m - (z + H)| ≤ max E w := by
  rcases hf with ⟨v, hv, hne⟩ | ⟨hn, he⟩
  · rcases instability_charge hw hv hne with h | ⟨m, hm, hc⟩
    · exact Or.inl h
    · exact Or.inr ⟨m, hm, hc.trans (le_max_right _ _)⟩
  · obtain ⟨m, hm, hlo, hhi⟩ := extension_charge hn he
    exact Or.inr ⟨m, hm, by rw [abs_of_pos hlo]; exact hhi.trans (le_max_left _ _)⟩

lemma innerFailure_card {ι : Type uι3} (s : Finset ι) {S : Set ℤ}
    {d z h w E : ℤ} (δ H : ι → ℤ)
    (hS : Separated S d) (hw : 0 ≤ w) (hsep : 2 * h + 2 * w < d)
    (hδ : ∀ i ∈ s, |δ i| ≤ h)
    (hgap : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → 2 * w < |δ i - δ j|)
    (hrgap : ∀ i ∈ s, ∀ j ∈ s, i ≠ j →
      2 * max E w < |(z + δ i + H i) - (z + δ j + H j)|) :
    (s.filter fun i => InnerFailure S (z + δ i) (H i) w E).card ≤ 3 := by
  classical
  let A := s.filter fun i => ∃ m ∈ S, |m - (z + δ i)| ≤ w
  let B := s.filter fun i => ∃ m, FirstAfter S (z + δ i) m ∧
    |m - (z + δ i + H i)| ≤ max E w
  have hs : (s.filter fun i => InnerFailure S (z + δ i) (H i) w E) ⊆ A ∪ B := by
    intro i hi
    obtain ⟨hi, hf⟩ := Finset.mem_filter.mp hi
    rcases innerFailure_charge hw hf with ha | hb
    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨hi, ha⟩)
    · exact Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨hi, hb⟩)
  have ha : A.card ≤ 1 := left_charge_card s δ hS hsep hδ hgap
  have hb : B.card ≤ 2 := right_charge_card s δ H hS (by omega) hδ hrgap
  exact (Finset.card_le_card hs).trans ((Finset.card_union_le A B).trans (show A.card + B.card ≤ 3 by omega))

end MarkerSearch

end GeneralizedStarHeight

end OAI