import OAI.Combinatorics.EditDistance.Metric

namespace OAI

/-!
# Increasing matchings through binary delimiter blocks
-/

namespace EditCode
open scoped BigOperators
attribute [local instance] Classical.propDecidable

section Matching
variable {k w n U V : ℕ} {f g : Fin k → ℕ}

def BlockSpan (f g : Fin k → ℕ) (w i : ℕ) : Prop :=
  ∃ t : ℕ, ∀ r : ℕ, r < w → ∃ a : Fin k, f a = w * i + r ∧ g a = t + r

def Missing (f : Fin k → ℕ) (w i : ℕ) : Prop :=
  ∃ r : ℕ, r < w ∧ ∀ a : Fin k, f a ≠ w * i + r

def Gap (f g : Fin k → ℕ) (w i : ℕ) : Prop :=
  ∃ (r : ℕ) (a b : Fin k), r + 1 < w ∧ f a = w * i + r ∧
    f b = w * i + (r+1) ∧ g a + 1 < g b

lemma span_of_no_defect (hf : StrictMono f) (hg : StrictMono g) (hw : 0 < w) (i : ℕ)
    (hm : ¬ Missing f w i) (hgap : ¬ Gap f g w i) : BlockSpan f g w i := by
  have hfull : ∀ r : ℕ, r < w → ∃ a : Fin k, f a = w * i + r := by
    intro r hr
    by_contra h
    exact hm ⟨r,hr,by simpa only [not_exists] using h⟩
  obtain ⟨a₀, ha₀⟩ := hfull 0 hw
  refine ⟨g a₀, ?_⟩
  intro r hr
  induction r with
  | zero => exact ⟨a₀,ha₀,by omega⟩
  | succ r ih =>
      obtain ⟨a, ha, hga⟩ := ih (by omega)
      obtain ⟨b, hb⟩ := hfull (r+1) hr
      have hab : a < b := hf.lt_iff_lt.mp (by omega)
      have hgab := hg hab
      have hn : ¬g a + 1 < g b := fun h => hgap ⟨r,a,b,hr,ha,hb,h⟩
      exact ⟨b,hb,by omega⟩

lemma defect_of_not_span (hf : StrictMono f) (hg : StrictMono g) (hw : 0 < w) (i : ℕ)
    (h : ¬BlockSpan f g w i) : Missing f w i ∨ Gap f g w i := by
  by_contra h'
  push Not at h'
  exact h (span_of_no_defect hf hg hw i h'.1 h'.2)

def Charge (f g : Fin k → ℕ) (w i : ℕ) : ℕ ⊕ ℕ → Prop
  | Sum.inl x => w * i ≤ x ∧ x < w * i + w ∧ ∀ a : Fin k, f a ≠ x
  | Sum.inr x => (∀ a : Fin k, g a ≠ x) ∧ ∃ a b : Fin k,
      w * i ≤ f a ∧ f a < w * i + w ∧ w * i ≤ f b ∧ f b < w * i + w ∧
        g a < x ∧ x < g b

lemma exists_charge (hf : StrictMono f) (hg : StrictMono g) (hw : 0 < w) (i : ℕ)
    (h : ¬BlockSpan f g w i) : ∃ x, Charge f g w i x := by
  rcases defect_of_not_span hf hg hw i h with hm | hgap
  · obtain ⟨r,hr,hm⟩ := hm
    exact ⟨Sum.inl (w*i+r), by exact ⟨by omega,by omega,hm⟩⟩
  · obtain ⟨r,a,b,hr,ha,hb,hgap⟩ := hgap
    refine ⟨Sum.inr (g a+1), ?_⟩
    constructor
    · intro c hc
      have hac : a < c := hg.lt_iff_lt.mp (by omega)
      have hcb : c < b := hg.lt_iff_lt.mp (by omega)
      have hfa := hf hac
      have hfb := hf hcb
      omega
    · exact ⟨a,b,by omega,by omega,by omega,by omega,by omega,hgap⟩

lemma charge_distinct (hf : StrictMono f) (hg : StrictMono g)
    {i j : ℕ} (hij : i ≠ j) {x : ℕ ⊕ ℕ}
    (hi : Charge f g w i x) (hj : Charge f g w j x) : False := by
  wlog h : i < j generalizing i j
  · exact this hij.symm hj hi (lt_of_le_of_ne (Nat.le_of_not_gt h) hij.symm)
  have hwi : w * i + w ≤ w * j := by
    have := Nat.mul_le_mul_left w h
    nlinarith
  cases x with
  | inl x => dsimp [Charge] at hi hj; omega
  | inr x =>
      obtain ⟨_,a,b,ha₁,ha₂,hb₁,hb₂,hax,hxb⟩ := hi
      obtain ⟨_,c,d,hc₁,hc₂,hd₁,hd₂,hcx,hxd⟩ := hj
      have hbc : b < c := hf.lt_iff_lt.mp (by omega)
      have := hg hbc
      omega

lemma missing_card {N : ℕ} (hf : Function.Injective f) (hN : ∀ a, f a < N) :
    (Finset.range N \ Finset.univ.image f).card = N - k := by
  have hs : Finset.univ.image f ⊆ Finset.range N := by
    intro x hx
    obtain ⟨a,_,rfl⟩ := Finset.mem_image.mp hx
    exact Finset.mem_range.mpr (hN a)
  rw [Finset.card_sdiff_of_subset hs, Finset.card_range,
    Finset.card_image_of_injective _ hf, Finset.card_univ, Fintype.card_fin]

theorem bad_blocks_le_loss
    (hf : StrictMono f) (hg : StrictMono g) (hw : 0 < w)
    (hU : ∀ a, f a < U) (hV : ∀ a, g a < V) (hn : w * n ≤ U) :
    (Finset.univ.filter (fun i : Fin n => ¬BlockSpan f g w i.val)).card ≤ (U-k) + (V-k) := by
  classical
  let B := {i : Fin n // ¬BlockSpan f g w i.val}
  let X := Finset.range U \ Finset.univ.image f
  let Y := Finset.range V \ Finset.univ.image g
  have hx (i : B) : ∃ x, Charge f g w i.val.val x := exists_charge hf hg hw i.val i.property
  let c (i : B) : ℕ ⊕ ℕ := (hx i).choose
  have hc (i : B) : Charge f g w i.val.val (c i) := (hx i).choose_spec
  have hcX (i : B) (x : ℕ) (he : c i = Sum.inl x) : x ∈ X := by
    have h := hc i
    rw [he] at h
    rcases h with ⟨h₁,h₂,h₃⟩
    have hwi : w * (i.val.val+1) ≤ w * n := Nat.mul_le_mul_left _ i.val.isLt
    simp only [X, Finset.mem_sdiff, Finset.mem_range, Finset.mem_image, Finset.mem_univ,
      true_and, not_exists]
    exact ⟨by nlinarith,fun a => (h₃ a)⟩
  have hcY (i : B) (x : ℕ) (he : c i = Sum.inr x) : x ∈ Y := by
    have h := hc i
    rw [he] at h
    obtain ⟨hx,a,b,_,_,_,_,_,hxb⟩ := h
    simp only [Y, Finset.mem_sdiff, Finset.mem_range, Finset.mem_image, Finset.mem_univ,
      true_and, not_exists]
    exact ⟨lt_trans hxb (hV b),hx⟩
  let c' (i : B) : X ⊕ Y := match he : c i with
    | Sum.inl x => Sum.inl ⟨x,hcX i x he⟩
    | Sum.inr x => Sum.inr ⟨x,hcY i x he⟩
  have hval (i : B) : Sum.map Subtype.val Subtype.val (c' i) = c i := by
    dsimp [c']
    split <;> rename_i x he <;> exact he.symm
  have hinj : Function.Injective c' := by
    intro i j he
    have he' : c i = c j := by rw [←hval i,←hval j,he]
    by_contra hij
    have hvalne : i.val.val ≠ j.val.val := by
      intro h
      apply hij
      exact Subtype.ext (Fin.ext h)
    exact charge_distinct hf hg hvalne (hc i) (by rw [he']; exact hc j)
  have hcard := Fintype.card_le_of_injective c' hinj
  simpa only [B, Fintype.card_subtype, Fintype.card_sum, Fintype.card_coe, X, Y,
    missing_card hf.injective hU, missing_card hg.injective hV] using hcard

end Matching
end EditCode

end OAI