import OAI.Combinatorics.EditDistance.RowAlignment

namespace OAI

/-!
# Payload restrictions and fresh-marker row separation
-/

namespace EditDistortion

lemma sublist_ofFn_comp {A : Type*} {m n : ℕ} (x : Fin n → A) (f : Fin m ↪o Fin n) :
    (List.ofFn (fun i => x (f i))).Sublist (List.ofFn x) := by
  apply List.sublist_iff_exists_fin_orderEmbedding_get_eq.mpr
  refine ⟨((Fin.castOrderIso (List.length_ofFn (f := fun i => x (f i)))).toOrderEmbedding.trans f).trans
    (Fin.castOrderIso (List.length_ofFn (f := x)).symm).toOrderEmbedding, ?_⟩
  intro i
  simp only [List.get_ofFn]
  rfl

lemma indel_le_of_matching {A : Type*} {m n k : ℕ} (x : Fin m → A) (y : Fin n → A)
    (f : Fin k ↪o Fin m) (g : Fin k ↪o Fin n) (heq : ∀ i, x (f i) = y (g i)) :
    indel (List.ofFn x) (List.ofFn y) ≤ m + n - 2 * k := by
  have hx := sublist_ofFn_comp x f
  have hy := sublist_ofFn_comp y g
  have hz : (fun i => x (f i)) = (fun i => y (g i)) := funext heq
  rw [← hz] at hy
  simpa only [List.length_ofFn] using indel_le_matching_loss hx hy

end EditDistortion

namespace EditRows

lemma payload_mod {B i x : ℕ} (hB : 0 < B) (hx : x ∈ payload B i) :
    x % (2 * B) < B := by
  have hd := payload_index hB hx
  have hx := mem_payload.mp hx
  have hm := Nat.mod_add_div x (2 * B)
  rw [hd] at hm
  omega

def rowValue {A : Type*} {L B : ℕ} (P : Fin L → Fin B → A)
    (x : Fin (2 * B * L)) : Option A :=
  if h : x.val % (2 * B) < B then
    some (P ⟨x.val / (2 * B), (Nat.div_lt_iff_lt_mul (by omega)).mpr
      (by simpa only [Nat.mul_comm] using x.isLt)⟩ ⟨x.val % (2 * B), h⟩)
  else none

def rowWord {A : Type*} {L B : ℕ} (P : Fin L → Fin B → A) : List (Option A) :=
  List.ofFn (rowValue P)

@[simp] lemma rowWord_length {A : Type*} {L B : ℕ} (P : Fin L → Fin B → A) :
    (rowWord P).length = 2 * B * L := by simp [rowWord]

lemma rowValue_ne_none {A : Type*} {L B : ℕ} (P : Fin L → Fin B → A)
    (x : Fin (2 * B * L)) : rowValue P x ≠ none ↔ x.val % (2 * B) < B := by
  unfold rowValue
  split_ifs <;> simp_all

def payloadOffset {B i x : ℕ} (h : x ∈ payload B i) : Fin B :=
  ⟨x - 2 * B * i, by have h := mem_payload.mp h; omega⟩

lemma rowValue_payload {A : Type*} {L B : ℕ} (hB : 0 < B) (P : Fin L → Fin B → A)
    (i : Fin L) (x : Fin (2 * B * L)) (hx : x.val ∈ payload B i) :
    rowValue P x = some (P i (payloadOffset hx)) := by
  have hd := payload_index hB hx
  have hm := payload_mod hB hx
  rw [rowValue, dite_eq_left hm]
  congr 2
  · exact Fin.ext hd
  · apply Fin.ext
    change x.val % (2 * B) = x.val - 2 * B * i.val
    have hh := Nat.mod_add_div x.val (2 * B)
    rw [hd] at hh
    omega

end EditRows

namespace EditRows

lemma local_matching_bound {A : Type*} {k L B : ℕ} {t : ℝ}
    (P Q : Fin L → Fin B → A) (hB : 0 < B)
    (f g : Fin k → Fin (2 * B * L))
    (hf : StrictMono (fun a => (f a).val)) (hg : StrictMono (fun a => (g a).val))
    (heq : ∀ a, rowValue P (f a) = rowValue Q (g a))
    (ht : t ≤ B)
    (hsep : ∀ i j : Fin L, 2 * t ≤
      (EditDistortion.indel (List.ofFn (P i)) (List.ofFn (Q j)) : ℝ))
    (i : Fin L) (j : ℕ) :
    t + (((rowMatches (fun a => (f a).val) B i).filter
      (fun a => (g a).val ∈ payload B j)).card : ℝ) ≤ B := by
  classical
  let K := (rowMatches (fun a => (f a).val) B i).filter
    (fun a => (g a).val ∈ payload B j)
  change t + (K.card : ℝ) ≤ B
  by_cases hj : j < L
  · let e : Fin K.card ↪o Fin k := K.orderEmbOfFin rfl
    have hp : ∀ r : Fin K.card,
        (f (e r)).val ∈ payload B i ∧ (g (e r)).val ∈ payload B j := by
      intro r
      have h := K.orderEmbOfFin_mem rfl r
      exact ⟨(Finset.mem_filter.mp (Finset.mem_filter.mp h).1).2,
        (Finset.mem_filter.mp h).2⟩
    let ff : Fin K.card → Fin B := fun r => payloadOffset (hp r).1
    let gg : Fin K.card → Fin B := fun r => payloadOffset (hp r).2
    have hff : StrictMono ff := by
      intro r s hrs
      have h := hf (e.strictMono hrs)
      change (f (e r)).val < (f (e s)).val at h
      have hr := mem_payload.mp (hp r).1
      have hs := mem_payload.mp (hp s).1
      change (f (e r)).val - 2 * B * i.val < (f (e s)).val - 2 * B * i.val
      omega
    have hgg : StrictMono gg := by
      intro r s hrs
      have h := hg (e.strictMono hrs)
      change (g (e r)).val < (g (e s)).val at h
      have hr := mem_payload.mp (hp r).2
      have hs := mem_payload.mp (hp s).2
      change (g (e r)).val - 2 * B * j < (g (e s)).val - 2 * B * j
      omega
    have he : ∀ r, P i (ff r) = Q ⟨j, hj⟩ (gg r) := by
      intro r
      have h := heq (e r)
      rw [rowValue_payload hB P i (f (e r)) (hp r).1,
        rowValue_payload hB Q ⟨j, hj⟩ (g (e r)) (hp r).2] at h
      exact Option.some.inj h
    have hcost := EditDistortion.indel_le_of_matching (P i) (Q ⟨j, hj⟩)
      (OrderEmbedding.ofStrictMono ff hff) (OrderEmbedding.ofStrictMono gg hgg) he
    have hk : K.card ≤ B := by
      simpa only [Fintype.card_fin] using Fintype.card_le_of_injective ff hff.injective
    have hcost' : (EditDistortion.indel (List.ofFn (P i)) (List.ofFn (Q ⟨j, hj⟩)) : ℝ) ≤
        ((B + B - 2 * K.card : ℕ) : ℝ) := by exact_mod_cast hcost
    rw [Nat.cast_sub (by omega), Nat.cast_add, Nat.cast_mul] at hcost'
    norm_num at hcost'
    have hsep' := hsep i ⟨j, hj⟩
    linarith
  · have hnil : K = ∅ := by
      apply Finset.eq_empty_iff_forall_notMem.mpr
      intro a ha
      have h := mem_payload.mp (Finset.mem_filter.mp ha).2
      have hg' := (g a).isLt
      have hh : 2 * B * L ≤ 2 * B * j := Nat.mul_le_mul_left _ (by omega)
      omega
    simpa only [hnil, Finset.card_empty, Nat.cast_zero, add_zero] using ht

theorem indel_row_separation {A : Type*} {L B : ℕ} {t : ℝ}
    (P Q : Fin L → Fin B → A) (hB : 0 < B) (ht : t ≤ B)
    (hsep : ∀ i j : Fin L, 2 * t ≤
      (EditDistortion.indel (List.ofFn (P i)) (List.ofFn (Q j)) : ℝ)) :
    (L : ℝ) * t ≤ (EditDistortion.indel (rowWord P) (rowWord Q) : ℝ) := by
  classical
  obtain ⟨z, hx, hy, hcost⟩ := EditDistortion.indel_matching (rowWord P) (rowWord Q)
  obtain ⟨f₀, hf₀⟩ := List.sublist_iff_exists_fin_orderEmbedding_get_eq.mp hx
  obtain ⟨g₀, hg₀⟩ := List.sublist_iff_exists_fin_orderEmbedding_get_eq.mp hy
  let f : Fin z.length ↪o Fin (2 * B * L) :=
    f₀.trans (Fin.castOrderIso (rowWord_length P)).toOrderEmbedding
  let g : Fin z.length ↪o Fin (2 * B * L) :=
    g₀.trans (Fin.castOrderIso (rowWord_length Q)).toOrderEmbedding
  have hf : StrictMono (fun a => (f a).val) := fun _ _ h => f.strictMono h
  have hg : StrictMono (fun a => (g a).val) := fun _ _ h => g.strictMono h
  have heq : ∀ a, rowValue P (f a) = rowValue Q (g a) := by
    intro a
    have h := (hf₀ a).symm.trans (hg₀ a)
    simpa only [rowWord, List.get_ofFn] using! h
  have hclean : ∀ a : Fin z.length, ∀ i : ℕ,
      (f a).val ∈ payload B i → (g a).val % (2 * B) < B := by
    intro a i ha
    apply (rowValue_ne_none Q (g a)).mp
    rw [← heq a]
    exact (rowValue_ne_none P (f a)).mpr (payload_mod hB ha)
  have hbound := matching_loss_real hf hg hB (fun a => (f a).isLt)
    (fun a => (g a).isLt) hclean ht (local_matching_bound P Q hB f g hf hg heq ht hsep)
  have hk : z.length ≤ 2 * B * L := by simpa only [rowWord_length] using hx.length_le
  have he : 2 * (2 * B * L - z.length) =
      (rowWord P).length + (rowWord Q).length - 2 * z.length := by
    rw [rowWord_length, rowWord_length]
    omega
  rw [hcost, ← he, Nat.cast_mul, Nat.cast_ofNat]
  exact hbound

end EditRows

end OAI