import OAI.Combinatorics.EditDistance.RowSeparation

namespace OAI

/-!
# Padded windows and insertion-deletion matching inequalities
-/

namespace EditWindow
open EditDistortion

variable {A : Type*}

def window (x : List A) (start len : ℕ) : List (Option A) :=
  List.ofFn (fun i : Fin len => x[start+i.val]?)

@[simp] lemma window_length (x : List A) (start len : ℕ) : (window x start len).length = len :=
  List.length_ofFn

lemma lookup_insert_before (p q : List A) (a : A) {r : ℕ} (hr : r < p.length) :
    (p ++ a::q)[r]? = (p ++ q)[r]? := by
  rw [List.getElem?_append_left hr,List.getElem?_append_left hr]

lemma lookup_insert_after (p q : List A) (a : A) {r : ℕ} (hr : p.length ≤ r) :
    (p ++ a::q)[r+1]? = (p ++ q)[r]? := by
  rw [List.getElem?_append_right (by omega),List.getElem?_append_right hr]
  have he : r+1-p.length = (r-p.length)+1 := by omega
  simp only [he,List.getElem?_cons_succ]

lemma window_before (p q : List A) (a : A) {start len : ℕ} (h : start+len ≤ p.length) :
    window (p ++ a::q) start len = window (p ++ q) start len := by
  unfold window
  congr 1
  funext i
  exact lookup_insert_before p q a (by omega)

lemma window_after (p q : List A) (a : A) {start len : ℕ} (h : p.length ≤ start) :
    window (p ++ a::q) (start+1) len = window (p ++ q) start len := by
  unfold window
  congr 1
  funext i
  simpa only [Nat.add_assoc,Nat.add_left_comm,Nat.add_comm] using
    lookup_insert_after p q a (r := start+i.val) (by omega)

theorem window_insert_cost (p q : List A) (a : A) (start len : ℕ) :
    indel (window (p ++ q) start len) (window (p ++ a::q) start len) ≤ 2 := by
  by_cases hl : len = 0
  · subst len
    have hh : indel ([] : List (Option A)) [] = 0 := (cost_eq_zero_iff (s := false)).mpr rfl
    simpa only [window,List.ofFn_zero,hh] using (by norm_num : (0 : ℕ) ≤ 2)
  have hlp : 0 < len := Nat.pos_of_ne_zero hl
  let f : Fin (len-1) ↪o Fin len :=
    (Fin.castLEOrderEmb (by omega : len-1 ≤ len))
  let g₀ (i : Fin (len-1)) : Fin len :=
    ⟨if start+i.val < p.length then i.val else i.val+1,by split <;> omega⟩
  have hg : StrictMono g₀ := by
    intro i j hij
    have hij' : i.val < j.val := hij
    change (if start+i.val < p.length then i.val else i.val+1) <
      (if start+j.val < p.length then j.val else j.val+1)
    split <;> split <;> omega
  let g : Fin (len-1) ↪o Fin len := OrderEmbedding.ofStrictMono g₀ hg
  have he (i : Fin (len-1)) :
      (p ++ q)[start+(f i).val]? = (p ++ a::q)[start+(g i).val]? := by
    change (p ++ q)[start+i.val]? =
      (p ++ a::q)[start+(if start+i.val < p.length then i.val else i.val+1)]?
    split
    · rename_i hi
      exact (lookup_insert_before p q a hi).symm
    · rename_i hi
      simpa only [Nat.add_assoc] using
        (lookup_insert_after p q a (r := start+i.val) (by omega)).symm
  have hh := indel_le_of_matching (fun i : Fin len => (p ++ q)[start+i.val]?)
    (fun i : Fin len => (p ++ a::q)[start+i.val]?) f g he
  exact hh.trans (by omega)

end EditWindow

namespace EditDistortion
variable {A B : Type*}

lemma indel_cost (x y : List A) : indel x y = cost false x y := rfl

lemma step_indel_filterMap (f : A → Option B) {x y : List A} (h : Step false x y) :
    indel (x.filterMap f) (y.filterMap f) ≤ 1 := by
  cases h with
  | insert p q a =>
    cases ha : f a with
    | none => simp only [List.filterMap_append,List.filterMap_cons,ha,indel_cost,cost_refl]; omega
    | some b =>
      simpa only [List.filterMap_append,List.filterMap_cons,ha,indel_cost] using
        cost_le (Script.single (Step.insert (substitutions := false) (p.filterMap f) (q.filterMap f) b))
  | delete p q a =>
    cases ha : f a with
    | none => simp only [List.filterMap_append,List.filterMap_cons,ha,indel_cost,cost_refl]; omega
    | some b =>
      simpa only [List.filterMap_append,List.filterMap_cons,ha,indel_cost] using
        cost_le (Script.single (Step.delete (substitutions := false) (p.filterMap f) (q.filterMap f) b))
  | substitute hf => contradiction

lemma indel_filterMap_le (f : A → Option B) (x y : List A) :
    indel (x.filterMap f) (y.filterMap f) ≤ indel x y := by
  have hh {n : ℕ} {x y : List A} (h : Script false n x y) :
      indel (x.filterMap f) (y.filterMap f) ≤ n := by
    induction h with
    | nil x => exact cost_le (.nil _)
    | @cons n x y z e h ih =>
      have ht := cost_triangle (s := false) (x.filterMap f) (y.filterMap f) (z.filterMap f)
      have he := step_indel_filterMap f e
      rw [indel_cost] at he ih ⊢
      omega
  exact hh (cost_spec x y)
end EditDistortion

namespace EditWindow
open EditDistortion
variable {A : Type*}

def segment (x : ℕ → A) (start len : ℕ) : List A :=
  List.ofFn (fun i : Fin len => x (start+i.val))

@[simp] lemma segment_length (x : ℕ → A) (start len : ℕ) :
    (segment x start len).length = len := List.length_ofFn

lemma segment_sublist (x : ℕ → A) (start l k L : ℕ) (hk : k+L ≤ l) :
    (segment x (start+k) L).Sublist (segment x start l) := by
  let f : Fin L ↪o Fin l := OrderEmbedding.ofStrictMono
    (fun i => (⟨k+i.val,by omega⟩ : Fin l)) (by intro i j hij; change k+i.val < k+j.val; omega)
  have hh := sublist_ofFn_comp (fun i : Fin l => x (start+i.val)) f
  dsimp [f,OrderEmbedding.ofStrictMono] at hh
  simpa only [segment,Nat.add_assoc] using hh

lemma segment_loss (x : ℕ → A) (start l k L : ℕ) (hk : k+L ≤ l) :
    indel (segment x start l) (segment x (start+k) L) ≤ l-L := by
  simpa only [segment_length,indel_cost] using cost_le (Script.of_sublist (segment_sublist x start l k L hk))

lemma segment_cross (x y : ℕ → A) (start l s : ℕ) (hs : 1 ≤ s) (hsl : s ≤ l)
    (i j : Fin s) :
    indel (segment x start l) (segment y start l) ≤
      2*(s-1)+indel (segment x (start+i.val) (l-s+1)) (segment y (start+j.val) (l-s+1)) := by
  have hx := segment_loss x start l i.val (l-s+1) (by omega)
  have hy := segment_loss y start l j.val (l-s+1) (by omega)
  rw [indel_cost,cost_symm] at hy
  have h1 := cost_triangle (s := false) (segment x start l)
    (segment x (start+i.val) (l-s+1)) (segment y (start+j.val) (l-s+1))
  have h2 := cost_triangle (s := false) (segment x start l)
    (segment y (start+j.val) (l-s+1)) (segment y start l)
  simp only [indel_cost] at hx hy ⊢
  omega

lemma segment_append (x : ℕ → A) (start l m : ℕ) :
    segment x start (l+m) = segment x start l ++ segment x (start+l) m := by
  unfold segment
  rw [List.ofFn_add]
  congr 1
  congr 1
  funext i
  simp only [Fin.val_natAdd,Nat.add_assoc]

lemma indel_segment_blocks (x y : ℕ → A) (l b : ℕ) :
    indel (segment x 0 (b*l)) (segment y 0 (b*l)) ≤
      ∑ j ∈ Finset.range b, indel (segment x (j*l) l) (segment y (j*l) l) := by
  induction b with
  | zero => simp only [Nat.zero_mul,segment,List.ofFn_zero,Finset.sum_range_zero]; exact cost_le (.nil _)
  | succ b ih =>
    rw [Nat.succ_mul,segment_append,segment_append,Finset.sum_range_succ]
    simp only [Nat.zero_add]
    exact (cost_append_le (s := false) _ _ _ _).trans (Nat.add_le_add_right ih _)

lemma window_eq_segment (x : List A) (start len : ℕ) :
    window x start len = segment (fun k => x[k]?) start len := rfl

lemma window_padding (x : List A) (n : ℕ) (hx : x.length ≤ n) :
    window x 0 n = (x.map some) ++ List.replicate (n-x.length) none := by
  apply List.ext_getElem?
  intro i
  simp only [window,List.getElem?_ofFn,Nat.zero_add,List.getElem?_append,List.length_map,
    List.getElem?_map,List.getElem?_replicate]
  by_cases hix : i < x.length
  · have hin : i < n := lt_of_lt_of_le hix hx
    simp [hix,hin]
  · have hxn : x[i]? = none := List.getElem?_eq_none (by omega)
    have hi : i-x.length < n-x.length ↔ i < n := by omega
    simp only [ite_eq_right hix,hxn,hi]
    split <;> rfl

lemma filterMap_window (x : List A) (n : ℕ) (hx : x.length ≤ n) :
    (window x 0 n).filterMap id = x := by
  rw [window_padding x n hx]
  simp

lemma indel_le_window (x y : List A) (n : ℕ) (hx : x.length ≤ n) (hy : y.length ≤ n) :
    indel x y ≤ indel (window x 0 n) (window y 0 n) := by
  have hh := indel_filterMap_le id (window x 0 n) (window y 0 n)
  simpa only [filterMap_window x n hx,filterMap_window y n hy] using hh

end EditWindow

end OAI