import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorTraversalCost
import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorStoredMasks
import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorTerminal

namespace OAI

/-! # Composition of the separator's four interval traversals -/

namespace LowSpaceSubsetSum.SeparatorBlocks

open SeparatorTraversal SeparatorIncidenceTable

variable {α β : Type*}

structure Block (α β : Type*) where
  size : ℕ
  left : α → Array ℕ
  right : β → Array ℕ
  left_sorted : ∀ x, Monotone (fun i : Fin (left x).size => (left x)[i.val])
  right_sorted : ∀ y, Monotone (fun i : Fin (right y).size => (right y)[i.val])

def depth (b : Block α β) : ℕ := Nat.clog 2 b.size

theorem transport_sorted (a b : Array ℕ) (he : a = b)
    (hs : Monotone (fun i : Fin a.size => a[i.val])) :
    Monotone (fun i : Fin b.size => b[i.val]) := by
  subst b
  exact hs

/-- Family tables are computed once, then captured by the lookup functions.
The runtime interval loop only indexes these stored arrays. -/
def ofFamily {g : ℕ} (family : Array (Finset (Fin g)))
    (mask₁ : α → Finset (Fin g)) (mask₂ : β → Finset (Fin g)) : Block α β :=
  let leftStore := SeparatorStoredMasks.containsStore family
  let rightStore := SeparatorStoredMasks.avoidsStore family
  { size := family.size
    left := fun x => SeparatorStoredMasks.containsList leftStore
      (SeparatorStoredMasks.containsStore_size family) (mask₁ x)
    right := fun y => SeparatorStoredMasks.avoidsList rightStore
      (SeparatorStoredMasks.avoidsStore_size family) (mask₂ y)
    left_sorted := fun x => by
      exact transport_sorted _ _ (SeparatorStoredMasks.containsList_eq family (mask₁ x)).symm
        (table_monotone _ _ _)
    right_sorted := fun y => by
      exact transport_sorted _ _ (SeparatorStoredMasks.avoidsList_eq family (mask₂ y)).symm
        (table_monotone _ _ _) }

def PairGood (blocks : List (Block α β)) (x : α) (y : β) : Prop :=
  ∀ b ∈ blocks, ∃ j < b.size, j ∈ (b.left x).toList ∧ j ∈ (b.right y).toList

def check (n : ℕ) (wx : α → ℤ) (wy : β → ℤ) (target : ℤ) :
    List (Block α β) → List α → List β → Result
  | [], xs, ys => SeparatorTerminal.bounded n wx wy target xs ys
  | b :: rest, xs, ys =>
    if xs.length + ys.length ≤ 2 ^ n then
      SeparatorTraversal.run b.left b.right (fun _ => check n wx wy target rest)
        (depth b) 0 b.size xs ys
    else ⟨false, 0, 0⟩

theorem correct (n : ℕ) (wx : α → ℤ) (wy : β → ℤ) (target : ℤ)
    (blocks : List (Block α β)) (xs : List α) (ys : List β)
    (hsize : xs.length + ys.length ≤ 2 ^ n) :
    (check n wx wy target blocks xs ys).accepted = true ↔
      ∃ x ∈ xs, ∃ y ∈ ys, PairGood blocks x y ∧ wx x + wy y = target := by
  induction blocks generalizing xs ys with
  | nil =>
    simpa only [check, PairGood, List.not_mem_nil, IsEmpty.forall_iff, implies_true,
      true_and] using SeparatorTerminal.bounded_correct n wx wy target xs ys hsize
  | cons b rest ih =>
    simp only [check, hsize, ↓reduceIte]
    rw [SeparatorTraversal.correct b.left b.right (fun _ => check n wx wy target rest)
      (fun x y => PairGood rest x y ∧ wx x + wy y = target)
      b.left_sorted b.right_sorted (2 ^ n) (fun _ xs ys hs => ih xs ys hs)
      (depth b) 0 b.size xs ys
      (by simpa only [Nat.sub_zero, depth] using Nat.le_pow_clog (by decide : 1 < 2) b.size)
      hsize]
    constructor
    · rintro ⟨j, _, hj, x, hx, y, hy, hxl, hyl, hr, hw⟩
      refine ⟨x, hx, y, hy, ?_, hw⟩
      intro b' hb'
      rcases List.mem_cons.mp hb' with rfl | hb'
      · exact ⟨j, hj, hxl, hyl⟩
      · exact hr b' hb'
    · rintro ⟨x, hx, y, hy, hp, hw⟩
      obtain ⟨j, hj, hxl, hyl⟩ := hp b (by simp)
      exact ⟨j, Nat.zero_le _, hj, x, hx, y, hy, hxl, hyl,
        (fun b' hb' => hp b' (by simp [hb'])), hw⟩

def chargeLeft (n : ℕ) : List (Block α β) → α → ℕ
  | [], _ => 6 * n + 7
  | b :: rest, x => 1 + (2 * depth b + chargeLeft n rest x) * count (b.left x) 0 b.size

def chargeRight (n : ℕ) : List (Block α β) → β → ℕ
  | [], _ => 6 * n + 7
  | b :: rest, y => 1 + (2 * depth b + chargeRight n rest y) * count (b.right y) 0 b.size

theorem sum_charge {γ : Type*} (inc : γ → Array ℕ) (charge : γ → ℕ) (zs : List γ)
    (d size : ℕ) :
    (zs.map (fun z => 1 + (2 * d + charge z) * count (inc z) 0 size)).sum =
      zs.length + 2 * d * mass inc 0 size zs (fun _ => 1) + mass inc 0 size zs charge := by
  induction zs with
  | nil => simp [mass]
  | cons z zs ih =>
    simp only [List.map_cons, List.sum_cons, List.length_cons, mass] at *
    nlinarith

theorem scans_le (n : ℕ) (wx : α → ℤ) (wy : β → ℤ) (target : ℤ)
    (blocks : List (Block α β)) (xs : List α) (ys : List β) :
    (check n wx wy target blocks xs ys).scans ≤
      (xs.map (chargeLeft n blocks)).sum + (ys.map (chargeRight n blocks)).sum := by
  induction blocks generalizing xs ys with
  | nil =>
    simpa [check, chargeLeft, chargeRight, List.map_const', List.sum_replicate, nsmul_eq_mul,
      Nat.mul_add, Nat.add_mul, Nat.mul_comm, Nat.mul_left_comm, Nat.mul_assoc, Nat.add_assoc, Nat.add_comm,
      Nat.add_left_comm] using
      SeparatorTerminal.bounded_scans n wx wy target xs ys
  | cons b rest ih =>
    simp only [check]
    split_ifs
    · have h := SeparatorTraversal.scans_le b.left b.right
        (fun _ => check n wx wy target rest) b.left_sorted b.right_sorted
        (chargeLeft n rest) (chargeRight n rest) (fun _ => ih)
        (depth b) 0 b.size xs ys
      change _ ≤ (xs.map (fun x => 1 + (2 * depth b + chargeLeft n rest x) *
        count (b.left x) 0 b.size)).sum + (ys.map (fun y => 1 +
        (2 * depth b + chargeRight n rest y) * count (b.right y) 0 b.size)).sum
      rw [sum_charge b.left (chargeLeft n rest) xs (depth b) b.size,
        sum_charge b.right (chargeRight n rest) ys (depth b) b.size]
      nlinarith
    · dsimp
      omega

def peakBound (n : ℕ) (blocks : List (Block α β)) : ℕ :=
  2 * 2 ^ n * ((blocks.map (fun b => depth b + 1)).sum) + 8 * (n + 1) * (2 ^ n + 1)

theorem peak_le (n : ℕ) (wx : α → ℤ) (wy : β → ℤ) (target : ℤ)
    (blocks : List (Block α β)) (xs : List α) (ys : List β) :
    (check n wx wy target blocks xs ys).peak ≤ peakBound n blocks := by
  induction blocks generalizing xs ys with
  | nil => simpa [check, peakBound] using SeparatorTerminal.bounded_peak n wx wy target xs ys
  | cons b rest ih =>
    simp only [check]
    split_ifs with hsize
    · have h := SeparatorTraversal.peak_le b.left b.right (fun _ => check n wx wy target rest)
        (peakBound n rest) (fun _ => ih) (depth b) 0 b.size xs ys
      simp only [peakBound, List.map_cons, List.sum_cons] at h ⊢
      nlinarith
    · dsimp
      exact Nat.zero_le _

def capacityPeak (n C : ℕ) (blocks : List (Block α β)) : ℕ :=
  2 * C * ((blocks.map (fun b => depth b + 1)).sum) + 8 * (n + 1) * (C + 1)

theorem peak_capacity (n C : ℕ) (wx : α → ℤ) (wy : β → ℤ) (target : ℤ)
    (blocks : List (Block α β)) (xs : List α) (ys : List β)
    (hsize : xs.length + ys.length ≤ C) (hC : C ≤ 2 ^ n) :
    (check n wx wy target blocks xs ys).peak ≤ capacityPeak n C blocks := by
  induction blocks generalizing xs ys with
  | nil => simpa [check, capacityPeak] using
      SeparatorTerminal.bounded_peak_capacity n C wx wy target xs ys hsize hC
  | cons b rest ih =>
    simp only [check, hsize.trans hC, ↓reduceIte]
    have h := SeparatorTraversal.peak_le_capacity b.left b.right
      (fun _ => check n wx wy target rest) C (capacityPeak n C rest)
      (fun _ xs ys hs => ih xs ys hs) (depth b) 0 b.size xs ys hsize
    simp only [capacityPeak, List.map_cons, List.sum_cons] at h ⊢
    nlinarith

end LowSpaceSubsetSum.SeparatorBlocks

end OAI