import OAI.Combinatorics.FiniteCircle.Lower

namespace OAI

namespace FiniteCircle

open scoped BigOperators List
open scoped ComplexConjugate
open RCLike Module
open Classical

theorem segment_segment {α : Type*} (x : List α) (start size r len : ℕ)
    (h : r + len ≤ size) : segment (segment x start size) r len = segment x (start + r) len := by
  unfold segment
  rw [List.drop_take, List.take_take, List.drop_drop, Nat.min_eq_left (by omega)]

theorem segment_append_left {α : Type*} (u v : List α) {start size : ℕ}
    (h : start + size ≤ u.length) : segment (u ++ v) start size = segment u start size := by
  unfold segment
  rw [List.drop_append_of_le_length (by omega), List.take_append_of_le_length (by simp; omega)]

theorem segment_append_right {α : Type*} (u v : List α) {start size : ℕ}
    (h : u.length ≤ start) : segment (u ++ v) start size = segment v (start - u.length) size := by
  unfold segment
  rw [List.drop_append, List.drop_eq_nil_of_le h, List.nil_append]

theorem slide_segment_before {α : Type*} (u v t : List α) (a b : α) {start size : ℕ}
    (h : start + size ≤ u.length) :
    segment (u ++ a :: (v ++ t)) start size = segment (u ++ v ++ b :: t) start size := by
  rw [segment_append_left _ _ h, List.append_assoc, segment_append_left _ _ h]

theorem slide_segment_after {α : Type*} (u v t : List α) (a b : α) {start size : ℕ}
    (h : u.length + v.length + 1 ≤ start) :
    segment (u ++ a :: (v ++ t)) start size = segment (u ++ v ++ b :: t) start size := by
  have h₁ : (u ++ a :: v).length ≤ start := by simp; omega
  have h₂ : (u ++ v ++ [b]).length ≤ start := by simp; omega
  rw [show u ++ a :: (v ++ t) = (u ++ a :: v) ++ t by simp,
    show u ++ v ++ b :: t = (u ++ v ++ [b]) ++ t by simp,
    segment_append_right _ _ h₁, segment_append_right _ _ h₂]
  congr 2
  simp

theorem slide_segment_shift {α : Type*} (u v t : List α) (a b : α) {start size : ℕ}
    (h₁ : u.length + 1 ≤ start) (h₂ : start + size ≤ u.length + v.length + 1) :
    segment (u ++ a :: (v ++ t)) start size =
      segment (u ++ v ++ b :: t) (start - 1) size := by
  rw [show u ++ a :: (v ++ t) = (u ++ [a]) ++ (v ++ t) by simp,
    segment_append_right (u ++ [a]) _ (by simp; omega),
    show u ++ v ++ b :: t = u ++ (v ++ b :: t) by simp,
    segment_append_right u _ (by omega),
    segment_append_left v t (by simp; omega),
    segment_append_left v (b :: t) (by omega)]
  congr 1
  simp only [List.length_append, List.length_singleton]
  omega

def windows {α : Type*} (x : List α) (start m s : ℕ) : List (List α) :=
  List.ofFn (fun r : Fin s => segment x (start + r) (m - s + 1))

@[simp] theorem length_windows {α : Type*} (x : List α) (start m s : ℕ) :
    (windows x start m s).length = s := List.length_ofFn

theorem windows_before {α : Type*} (u v t : List α) (a b : α)
    {start m s : ℕ} (_hs : 1 ≤ s) (hsm : s ≤ m) (hbef : start + m ≤ u.length) :
    windows (u ++ a :: (v ++ t)) start m s = windows (u ++ v ++ b :: t) start m s := by
  unfold windows
  congr 1
  funext r
  exact slide_segment_before _ _ _ _ _ (by have := r.isLt; omega)

theorem windows_after {α : Type*} (u v t : List α) (a b : α)
    {start m s : ℕ} (haft : u.length + v.length + 1 ≤ start) :
    windows (u ++ a :: (v ++ t)) start m s = windows (u ++ v ++ b :: t) start m s := by
  unfold windows
  congr 1
  funext r
  exact slide_segment_after _ _ _ _ _ (by omega)

theorem windows_shift {α : Type*} (u v t : List α) (a b : α)
    {start m s : ℕ} (hs : 1 ≤ s) (hsm : s ≤ m)
    (h₁ : u.length + 1 ≤ start) (h₂ : start + m ≤ u.length + v.length) :
    ∃ zs : List (List α), zs.length = s - 1 ∧
      zs <+ windows (u ++ a :: (v ++ t)) start m s ∧
      zs <+ windows (u ++ v ++ b :: t) start m s := by
  obtain ⟨r, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : s ≠ 0)
  let zs := List.ofFn (fun i : Fin r => segment (u ++ a :: (v ++ t)) (start + i.val + 1) (m - (r+1) + 1))
  refine ⟨zs, by simp [zs], ?_, ?_⟩
  · unfold windows
    rw [List.ofFn_succ]
    have he : zs = List.ofFn (fun i : Fin r => segment (u ++ a :: (v ++ t))
        (start + (i.succ : Fin (r+1))) (m - (r+1) + 1)) := by simp [zs, Nat.add_assoc]
    rw [he]
    exact List.Sublist.cons _ (List.Sublist.refl _)
  · unfold windows
    rw [List.ofFn_succ']
    have he : zs = List.ofFn (fun i : Fin r => segment (u ++ v ++ b :: t)
        (start + (i.castSucc : Fin (r+1))) (m - (r+1) + 1)) := by
      unfold zs
      congr 1
      funext i
      have hh := slide_segment_shift u v t a b (start := start + i.val + 1)
        (size := m - (r+1) + 1) (by omega) (by have := i.isLt; omega)
      simpa using hh
    rw [he]
    rw [List.concat_eq_append]
    exact List.sublist_append_left _ _

theorem block_location (p q m j : ℕ) (hm : 0 < m) (_hpq : p ≤ q)
    (hp : j ≠ p / m) (hq : j ≠ q / m) :
    (j * m + m ≤ p) ∨ (p + 1 ≤ j * m ∧ j * m + m ≤ q) ∨ (q + 1 ≤ j * m) := by
  by_cases hjp : j < p / m
  · left
    have h := (Nat.le_div_iff_mul_le hm).mp (by omega : j+1 ≤ p/m)
    nlinarith
  · have hstart : p + 1 ≤ j*m := by
      have h := (Nat.div_lt_iff_lt_mul hm).mp (by omega : p/m < j)
      omega
    by_cases hjq : j < q / m
    · right; left
      refine ⟨hstart, ?_⟩
      have h := (Nat.le_div_iff_mul_le hm).mp (by omega : j+1 ≤ q/m)
      nlinarith
    · right; right
      have h := (Nat.div_lt_iff_lt_mul hm).mp (by omega : q/m < j)
      omega

theorem windows_nonexceptional {α : Type*} (u v t : List α) (a b : α)
    {m s j : ℕ} (hs : 1 ≤ s) (hsm : s ≤ m)
    (hp : j ≠ u.length / m) (hq : j ≠ (u.length + v.length) / m) :
    ∃ zs : List (List α), s - 1 ≤ zs.length ∧
      zs <+ windows (u ++ a :: (v ++ t)) (j*m) m s ∧
      zs <+ windows (u ++ v ++ b :: t) (j*m) m s := by
  rcases block_location u.length (u.length+v.length) m j (by omega) (by omega) hp hq with h | h | h
  · have he := windows_before u v t a b hs hsm h
    exact ⟨_, by simp, .refl _, he ▸ List.Sublist.refl _⟩
  · obtain ⟨zs, hz, hx, hy⟩ := windows_shift u v t a b hs hsm h.1 h.2
    exact ⟨zs, hz.ge, hx, hy⟩
  · have he := windows_after u v t a b (m := m) (s := s) h
    exact ⟨_, by simp, .refl _, he ▸ List.Sublist.refl _⟩

theorem lcs_append_ge {α : Type*} (x y u v : List α) :
    lcs x y + lcs u v ≤ lcs (x ++ u) (y ++ v) := by
  obtain ⟨z, hzx, hzy, hz⟩ := lcs_exists x y
  obtain ⟨t, htu, htv, ht⟩ := lcs_exists u v
  simpa [List.length_append, hz, ht] using le_lcs (hzx.append htu) (hzy.append htv)

theorem deficit_append_le {α : Type*} (x y u v : List α) :
    deficit (x ++ u) (y ++ v) ≤ deficit x y + deficit u v := by
  have h := lcs_append_ge x y u v
  have hx := lcs_le_length_left x y
  have hu := lcs_le_length_left u v
  simp only [deficit, List.length_append]
  omega

theorem deficit_le_sum_blocks {α : Type*} {x y : List α} {b m : ℕ}
    (hx : x.length = b*m) (hy : y.length = b*m) :
    deficit x y ≤ ∑ j : Fin b, deficit (segment x (j*m) m) (segment y (j*m) m) := by
  induction b generalizing x y with
  | zero =>
    have hx0 : x = [] := List.length_eq_zero_iff.mp (by simpa using hx)
    have hy0 : y = [] := List.length_eq_zero_iff.mp (by simpa using hy)
    simp [hx0, hy0, deficit]
  | succ b ih =>
    have hxt : (x.drop m).length = b*m := by simp only [List.length_drop]; rw [hx, Nat.succ_mul]; omega
    have hyt : (y.drop m).length = b*m := by simp only [List.length_drop]; rw [hy, Nat.succ_mul]; omega
    have hd := deficit_append_le (x.take m) (y.take m) (x.drop m) (y.drop m)
    simp only [List.take_append_drop] at hd
    refine hd.trans ?_
    rw [Fin.sum_univ_succ]
    simp only [Fin.val_zero, Nat.zero_mul, segment, List.drop_zero]
    apply Nat.add_le_add_left
    convert ih hxt hyt using 1
    apply Finset.sum_congr rfl
    intro j _
    simp [segment, List.drop_drop, Fin.val_succ, Nat.add_mul, Nat.add_comm]

open scoped BigOperators List

open scoped BigOperators

end FiniteCircle

end OAI