import OAI.Algebra.FormulaHitting.Program

namespace OAI

namespace NCHitting

open BitModel

private theorem length_flatMap_uniform {α β : Type*} (xs : List α) (f : α → List β)
    (k : ℕ) (h : ∀ x ∈ xs, (f x).length = k) :
    (xs.flatMap f).length = xs.length * k := by
  induction xs with
  | nil => simp
  | cons x xs ih =>
    have hx := h x (by simp)
    have hxs : ∀ y ∈ xs, (f y).length = k := by
      intro y hy
      exact h y (by simp [hy])
    simp only [List.flatMap_cons, List.length_append, List.length_cons]
    rw [hx, ih hxs, Nat.add_mul]
    omega

private theorem getElem?_flatMap_uniform {α β : Type*} (xs : List α) (f : α → List β)
    (k : ℕ) (h : ∀ x ∈ xs, (f x).length = k) (i j : ℕ) (hj : j < k) :
    (xs.flatMap f)[i * k + j]? = xs[i]?.bind (fun x => (f x)[j]?) := by
  induction xs generalizing i with
  | nil => simp
  | cons x xs ih =>
    have hx := h x (by simp)
    have hxs : ∀ y ∈ xs, (f y).length = k := by
      intro y hy
      exact h y (by simp [hy])
    cases i with
    | zero =>
      simp only [Nat.zero_mul, Nat.zero_add, List.flatMap_cons,
        List.getElem?_cons_zero, Option.bind_some]
      exact List.getElem?_append_left (by omega)
    | succ i =>
      have hlarge : (f x).length ≤ (i + 1) * k + j := by
        rw [hx, Nat.add_mul]
        omega
      have hindex : (i + 1) * k + j - (f x).length = i * k + j := by
        rw [hx, Nat.add_mul]
        omega
      simp only [List.flatMap_cons, List.getElem?_cons_succ]
      rw [List.getElem?_append_right hlarge, hindex]
      exact ih hxs i

private theorem rows_length (d i : ℕ) :
    ((List.range d).flatMap fun r => (List.range d).map fun q => encodedEntry i r q).length = d * d := by
  apply (length_flatMap_uniform (List.range d) _ d ?_).trans
  · simp
  · intro r hr
    simp

theorem generate_output_length (n s : ℕ) :
    (generate n s).output.length = n * dimension n s * dimension n s := by
  rw [generate_output]
  by_cases h : n = 1 ∧ s = 1
  · rcases h with ⟨rfl, rfl⟩
    simp [encodedOutput, dimension]
  · simp only [encodedOutput, ite_eq_right h, dimension]
    have hl := length_flatMap_uniform (List.range n)
      (fun i => (List.range (2 * n * s ^ 2)).flatMap fun r =>
        (List.range (2 * n * s ^ 2)).map fun q => encodedEntry i r q)
      ((2 * n * s ^ 2) * (2 * n * s ^ 2)) (fun i _ => rows_length _ i)
    simp [Nat.mul_assoc] at hl ⊢

theorem encodedEntry_numerator_le (i r q : ℕ) : (encodedEntry i r q).numerator ≤ 1 := by
  unfold encodedEntry
  split_ifs <;> simp

theorem encodedEntry_denominator_size_le {n d i r q : ℕ} (hi : i < n) (hr : r < d) :
    (encodedEntry i r q).denominator.size ≤ entryBitBound n d := by
  unfold encodedEntry
  split_ifs with h
  · exact denominator_size_le (q := q) (Nat.succ_le_of_lt hi) hr
  · simp only [Nat.size_one]
    unfold entryBitBound
    omega

theorem generate_entry_bounds {n s : ℕ} (entry : RationalCode)
    (hentry : entry ∈ (generate n s).output) :
    0 < entry.denominator ∧ entry.numerator ≤ 1 ∧
      entry.denominator.size ≤ entryBitBound n (dimension n s) ∧
      entry.bits ≤ 4 + entryBitBound n (dimension n s) := by
  rw [generate_output] at hentry
  by_cases h : n = 1 ∧ s = 1
  · rcases h with ⟨rfl, rfl⟩
    simp only [encodedOutput, and_self, ite_true, List.mem_singleton] at hentry
    subst entry
    norm_num [dimension, entryBitBound, RationalCode.bits, width]
  · simp only [encodedOutput, ite_eq_right h, List.mem_flatMap, List.mem_map, List.mem_range] at hentry
    obtain ⟨i, hi, r, hr, q, hq, rfl⟩ := hentry
    have hd : dimension n s = 2 * n * s ^ 2 := by simp [dimension, h]
    rw [hd]
    exact ⟨encodedEntry_denominator_pos i r q, encodedEntry_numerator_le i r q,
      encodedEntry_denominator_size_le hi hr, encodedEntry_bits_le hi hr⟩

private theorem flattened_entry {n d i r q : ℕ} (hi : i < n) (hr : r < d) (hq : q < d) :
    ((List.range n).flatMap fun i => (List.range d).flatMap fun r =>
      (List.range d).map fun q => encodedEntry i r q)[i * d * d + r * d + q]? =
        some (encodedEntry i r q) := by
  have hj : r * d + q < d * d := by
    calc
      r * d + q < r * d + d := Nat.add_lt_add_left hq _
      _ = (r + 1) * d := by rw [Nat.add_mul]; omega
      _ ≤ d * d := Nat.mul_le_mul_right d (by omega)
  have hout := getElem?_flatMap_uniform (List.range n)
    (fun i => (List.range d).flatMap fun r => (List.range d).map fun q => encodedEntry i r q)
    (d * d) (fun i _ => rows_length d i) i (r * d + q) hj
  rw [List.getElem?_range hi] at hout
  simp only [Option.bind_some] at hout
  have hin := getElem?_flatMap_uniform (List.range d)
    (fun r => (List.range d).map fun q => encodedEntry i r q)
    d (by intro r _; simp) r q hq
  rw [List.getElem?_range hr] at hin
  simp only [Option.bind_some] at hin
  rw [List.getElem?_map, List.getElem?_range hq] at hin
  simp only [Option.map_some] at hin
  simpa only [Nat.mul_assoc, Nat.add_assoc] using hout.trans hin

theorem generate_entry_code {n s i r q : ℕ} (hi : i < n)
    (hr : r < dimension n s) (hq : q < dimension n s) :
    (generate n s).output[i * dimension n s * dimension n s + r * dimension n s + q]? =
      some (if n = 1 ∧ s = 1 then ⟨false, 1, 1⟩ else encodedEntry i r q) := by
  rw [generate_output]
  by_cases h : n = 1 ∧ s = 1
  · rcases h with ⟨rfl, rfl⟩
    have hi0 : i = 0 := by omega
    have hr0 : r = 0 := by simpa [dimension] using hr
    have hq0 : q = 0 := by simpa [dimension] using hq
    subst i
    subst r
    subst q
    simp [encodedOutput, dimension]
  · have hd : dimension n s = 2 * n * s ^ 2 := by simp [dimension, h]
    rw [hd] at hr hq ⊢
    simp only [encodedOutput, ite_eq_right h]
    exact flattened_entry hi hr hq

theorem generate_entry_decode (n s : ℕ) (i : Fin n) (r q : Fin (dimension n s)) :
    decode (((generate n s).output[i.val * dimension n s * dimension n s +
      r.val * dimension n s + q.val]?).getD ⟨false, 0, 1⟩) = generator n s i r q := by
  rw [generate_entry_code i.isLt r.isLt q.isLt]
  simp only [Option.getD_some]
  by_cases h : n = 1 ∧ s = 1
  · simp [h, generator, decode]
  · simp only [generator, ite_eq_right h]
    exact decode_encodedEntry i.val r.val q.val

end NCHitting

end OAI