import OAI.Combinatorics.LowSpaceSubsetSum.Streams.DictionaryStream
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.StreamJoinCorrectness

namespace OAI

/-!
# A bounded dictionary callback for the actual stream join

The callback freezes after the first capacity violation. It always lets the
join continue, so the established complete-join theorem applies on every
outcome. The overflowing residue is discarded afterwards. Completing the
scan uses only the bounded Cartesian potential and no extra keys.
-/

namespace LowSpaceSubsetSum.BinaryTrie

def feed (C : ℕ) (key : List Bool) (r : BuildResult) : BuildResult :=
  if r.overflow then r
  else if contains r.tree key then tick r
  else
    let next := insert r.tree key
    ⟨next, decide (C < entries next), r.processed + 1⟩

def callback {α β : Type*} (C : ℕ) (encode : α → β → List Bool)
    (x : α) (y : β) (r : BuildResult) : BuildResult × Bool :=
  (feed C (encode x y) r, false)

theorem feed_frozen (C : ℕ) (key : List Bool) (r : BuildResult)
    (h : r.overflow = true) : feed C key r = r := by simp [feed, h]

structure Safe (C width : ℕ) (r : BuildResult) : Prop where
  hasWidth : HasWidth r.tree width
  compact : Compact r.tree
  bound : entries r.tree ≤ C + 1
  complete_bound : r.overflow = false → entries r.tree ≤ C

theorem empty_safe (C width : ℕ) : Safe C width ⟨.empty, false, 0⟩ := by
  constructor <;> simp [HasWidth, Compact, entries]

theorem feed_safe {C width : ℕ} {r : BuildResult} (hr : Safe C width r)
    (key : List Bool) (hk : key.length = width) : Safe C width (feed C key r) := by
  by_cases hover : r.overflow = true
  · simpa only [feed_frozen C key r hover] using hr
  have hclear : r.overflow = false := Bool.eq_false_iff.mpr hover
  by_cases hdup : contains r.tree key = true
  · simp only [feed, hclear, Bool.false_eq_true, ↓reduceIte, hdup, tick]
    exact ⟨hr.hasWidth, hr.compact, hr.bound, fun _ => hr.complete_bound hclear⟩
  have hnew : contains r.tree key = false := Bool.eq_false_iff.mpr hdup
  have he := entries_insert hr.hasWidth hk
  rw [hnew] at he
  simp only [Bool.false_eq_true, ↓reduceIte] at he
  have hcap := hr.complete_bound hclear
  simp only [feed, hclear, hnew, Bool.false_eq_true, ↓reduceIte]
  refine ⟨insert_hasWidth hr.hasWidth hk, insert_compact hr.compact key, ?_, ?_⟩
  · dsimp
    omega
  · intro h
    have hh : ¬ C < entries (insert r.tree key) := of_decide_eq_false h
    change entries (insert r.tree key) ≤ C
    omega

theorem feed_nodes {C width : ℕ} {r : BuildResult} (hr : Safe C width r)
    (key : List Bool) (hk : key.length = width) :
    nodes (feed C key r).tree ≤ (width + 1) * (C + 1) := by
  have h := feed_safe hr key hk
  exact (nodes_le_width_mul_entries h.hasWidth h.compact).trans
    (Nat.mul_le_mul_left _ h.bound)

/-- The cardinality hypothesis is on the actual possible key set, not the
number of callbacks. Duplicate occurrences never consume extra capacity. -/
theorem feed_fits {C width : ℕ} {r : BuildResult} {U : Finset (List Bool)}
    (hclear : r.overflow = false) (ht : HasWidth r.tree width)
    (hwidth : ∀ key ∈ U, key.length = width) (htU : keySet r.tree ⊆ U)
    (hcap : U.card ≤ C) {key : List Bool} (hkey : key ∈ U) :
    (feed C key r).overflow = false ∧
      keySet (feed C key r).tree = Insert.insert key (keySet r.tree) ∧
      (feed C key r).processed = r.processed + 1 ∧
      HasWidth (feed C key r).tree width := by
  have hk := hwidth key hkey
  by_cases hdup : contains r.tree key = true
  · have hm : key ∈ keySet r.tree := (mem_keySet _ _).mpr hdup
    simp only [feed, hclear, Bool.false_eq_true, ↓reduceIte, hdup, tick]
    exact ⟨trivial, (Finset.insert_eq_of_mem hm).symm, trivial, ht⟩
  · have hnew : contains r.tree key = false := Bool.eq_false_iff.mpr hdup
    have hnextU : keySet (insert r.tree key) ⊆ U := by
      rw [keySet_insert ht hk]
      exact Finset.insert_subset hkey htU
    have hnext : entries (insert r.tree key) ≤ C := by
      rw [← card_keySet]
      exact (Finset.card_le_card hnextU).trans hcap
    simp only [feed, hclear, hnew, Bool.false_eq_true, ↓reduceIte]
    exact ⟨by simp [show ¬ C < entries (insert r.tree key) by omega],
      keySet_insert ht hk, trivial, insert_hasWidth ht hk⟩

theorem fold_fits {C width : ℕ} {r : BuildResult} {U : Finset (List Bool)}
    (hclear : r.overflow = false) (ht : HasWidth r.tree width)
    (hwidth : ∀ key ∈ U, key.length = width) (htU : keySet r.tree ⊆ U)
    (hcap : U.card ≤ C) (keys : List (List Bool)) (hkeys : ∀ key ∈ keys, key ∈ U) :
    let out := keys.foldl (fun r key => feed C key r) r
    out.overflow = false ∧ keySet out.tree = keySet r.tree ∪ keys.toFinset ∧
      out.processed = r.processed + keys.length ∧ HasWidth out.tree width := by
  induction keys generalizing r with
  | nil => simp [ht, hclear]
  | cons key rest ih =>
    obtain ⟨hc, hs, hp, hw⟩ := feed_fits hclear ht hwidth htU hcap (hkeys key (by simp))
    have hnU : keySet (feed C key r).tree ⊆ U := by
      rw [hs]
      exact Finset.insert_subset (hkeys key (by simp)) htU
    obtain ⟨hfin, hset, hnum, hwidthFin⟩ := ih hc hw hnU
      (fun q hq => hkeys q (by simp [hq]))
    refine ⟨hfin, ?_, ?_, hwidthFin⟩
    · change keySet (rest.foldl (fun r key => feed C key r) (feed C key r)).tree = _
      rw [hset, hs, List.toFinset_cons]
      ext q
      simp only [Finset.mem_union, Finset.mem_insert]
      tauto
    · change (rest.foldl (fun r key => feed C key r) (feed C key r)).processed = _
      rw [hnum, hp, List.length_cons]
      omega

theorem fold_safe {C width : ℕ} {r : BuildResult} (hr : Safe C width r)
    (keys : List (List Bool)) (hk : ∀ key ∈ keys, key.length = width) :
    Safe C width (keys.foldl (fun r key => feed C key r) r) := by
  induction keys generalizing r with
  | nil => exact hr
  | cons key rest ih =>
    exact ih (feed_safe hr key (hk key (by simp))) (fun q hq => hk q (by simp [hq]))

/-- Proof-only list of keys reported by a complete Cartesian-match join. -/
def matchingKeys {α β : Type*} (key₁ : α → ℤ) (key₂ : β → ℤ)
    (encode : α → β → List Bool) (xs : List α) (ys : List β) : List (List Bool) :=
  xs.flatMap (fun x => (ys.filter (fun y => decide (key₁ x = key₂ y))).map (encode x))

theorem mem_matchingKeys {α β : Type*} (key₁ : α → ℤ) (key₂ : β → ℤ)
    (encode : α → β → List Bool) (xs : List α) (ys : List β) (key : List Bool) :
    key ∈ matchingKeys key₁ key₂ encode xs ys ↔
      ∃ x ∈ xs, ∃ y ∈ ys, key₁ x = key₂ y ∧ encode x y = key := by
  simp [matchingKeys, and_assoc]

theorem matchFold_eq_keys {α β : Type*} (C : ℕ) (key₁ : α → ℤ) (key₂ : β → ℤ)
    (encode : α → β → List Bool) (xs : List α) (ys : List β) (r : BuildResult) :
    MatchFold.run key₁ key₂ (callback C encode) xs ys r =
      (matchingKeys key₁ key₂ encode xs ys).foldl (fun r key => feed C key r) r := by
  induction xs generalizing r with
  | nil => rfl
  | cons x xs ih =>
    simp only [MatchFold.run, matchingKeys, List.flatMap_cons, List.foldl_append,
      List.foldl_map, callback, ih]

theorem matchFold_fits {α β : Type*} {C width : ℕ} (key₁ : α → ℤ) (key₂ : β → ℤ)
    (encode : α → β → List Bool) (xs : List α) (ys : List β) (U : Finset (List Bool))
    (hwidth : ∀ key ∈ U, key.length = width) (hcap : U.card ≤ C)
    (hkeys : ∀ x ∈ xs, ∀ y ∈ ys, key₁ x = key₂ y → encode x y ∈ U) :
    let out := MatchFold.run key₁ key₂ (callback C encode) xs ys ⟨.empty, false, 0⟩
    out.overflow = false ∧
      keySet out.tree = (matchingKeys key₁ key₂ encode xs ys).toFinset ∧
      out.processed = (matchingKeys key₁ key₂ encode xs ys).length := by
  rw [matchFold_eq_keys]
  have h := fold_fits (r := ⟨.empty, false, 0⟩) rfl (by trivial) hwidth
    (by simp [keySet]) hcap (matchingKeys key₁ key₂ encode xs ys) (by
      intro key hk
      obtain ⟨x, hx, y, hy, heq, rfl⟩ := (mem_matchingKeys _ _ _ _ _ _).mp hk
      exact hkeys x hx y hy heq)
  refine ⟨h.1, ?_, ?_⟩
  · simpa only [keySet, Finset.empty_union] using h.2.1
  · simpa only [Nat.zero_add] using h.2.2.1

theorem matchFold_safe {α β : Type*} {C width : ℕ} (key₁ : α → ℤ) (key₂ : β → ℤ)
    (encode : α → β → List Bool) (xs : List α) (ys : List β)
    (hwidth : ∀ x ∈ xs, ∀ y ∈ ys, key₁ x = key₂ y → (encode x y).length = width) :
    Safe C width (MatchFold.run key₁ key₂ (callback C encode) xs ys ⟨.empty, false, 0⟩) := by
  rw [matchFold_eq_keys]
  apply fold_safe (empty_safe C width)
  intro key hk
  obtain ⟨x, hx, y, hy, heq, rfl⟩ := (mem_matchingKeys _ _ _ _ _ _).mp hk
  exact hwidth x hx y hy heq

/-- Exact membership after the actual finite-state stream join. The only
capacity assumption is the cardinality of a universe containing its keys. -/
theorem join_fits {α β σ₁ σ₂ : Type*} {C width : ℕ}
    (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ)
    (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) (encode : α → β → List Bool)
    (view₁ : σ₁ → List α) (hread₁ : RowMerge.IsReader read₁ view₁)
    (view₂ : σ₂ → List β) (hread₂ : RowMerge.IsReader read₂ view₂)
    (B fuel₁ fuel₂ controlFuel : ℕ) (s₁ : σ₁) (s₂ : σ₂)
    (hsort₁ : (view₁ s₁).Pairwise (fun x y => key₁ x ≤ key₁ y))
    (hsort₂ : (view₂ s₂).Pairwise (fun x y => key₂ x ≤ key₂ y))
    (hcap₁ : (view₁ s₁).length ≤ fuel₁) (hcap₂ : (view₂ s₂).length ≤ fuel₂)
    (hfuel : (view₁ s₁).length + (view₂ s₂).length < controlFuel)
    (U : Finset (List Bool)) (hwidth : ∀ key ∈ U, key.length = width) (hcap : U.card ≤ C)
    (hkeys : ∀ x ∈ view₁ s₁, ∀ y ∈ view₂ s₂, key₁ x = key₂ y → encode x y ∈ U) :
    let out := (StreamJoin.run read₁ key₁ read₂ key₂ (callback C encode)
      B fuel₁ fuel₂ controlFuel s₁ s₂ ⟨.empty, false, 0⟩).user
    out.overflow = false ∧ ∀ query,
      contains out.tree query = true ↔
        ∃ x ∈ view₁ s₁, ∃ y ∈ view₂ s₂, key₁ x = key₂ y ∧ encode x y = query := by
  have he := StreamJoin.run_complete read₁ key₁ read₂ key₂ (callback C encode)
    (fun _ _ _ => rfl) view₁ hread₁ view₂ hread₂ B fuel₁ fuel₂ controlFuel
    s₁ s₂ ⟨.empty, false, 0⟩ hsort₁ hsort₂ hcap₁ hcap₂ hfuel
  dsimp only
  rw [he]
  obtain ⟨hc, hs, _⟩ := matchFold_fits key₁ key₂ encode (view₁ s₁) (view₂ s₂)
    U hwidth hcap hkeys
  refine ⟨hc, ?_⟩
  intro query
  rw [← mem_keySet, hs, List.mem_toFinset, mem_matchingKeys]

/-- Every complete join, including an overflowing residue, retains at most
one rejected key beyond capacity. This gives the concrete trie node bound. -/
theorem join_nodes {α β σ₁ σ₂ : Type*} {C width : ℕ}
    (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ)
    (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) (encode : α → β → List Bool)
    (view₁ : σ₁ → List α) (hread₁ : RowMerge.IsReader read₁ view₁)
    (view₂ : σ₂ → List β) (hread₂ : RowMerge.IsReader read₂ view₂)
    (B fuel₁ fuel₂ controlFuel : ℕ) (s₁ : σ₁) (s₂ : σ₂)
    (hsort₁ : (view₁ s₁).Pairwise (fun x y => key₁ x ≤ key₁ y))
    (hsort₂ : (view₂ s₂).Pairwise (fun x y => key₂ x ≤ key₂ y))
    (hcap₁ : (view₁ s₁).length ≤ fuel₁) (hcap₂ : (view₂ s₂).length ≤ fuel₂)
    (hfuel : (view₁ s₁).length + (view₂ s₂).length < controlFuel)
    (hwidth : ∀ x ∈ view₁ s₁, ∀ y ∈ view₂ s₂,
      key₁ x = key₂ y → (encode x y).length = width) :
    nodes (StreamJoin.run read₁ key₁ read₂ key₂ (callback C encode)
      B fuel₁ fuel₂ controlFuel s₁ s₂ ⟨.empty, false, 0⟩).user.tree ≤
      (width + 1) * (C + 1) := by
  rw [StreamJoin.run_complete read₁ key₁ read₂ key₂ (callback C encode)
    (fun _ _ _ => rfl) view₁ hread₁ view₂ hread₂ B fuel₁ fuel₂ controlFuel
    s₁ s₂ ⟨.empty, false, 0⟩ hsort₁ hsort₂ hcap₁ hcap₂ hfuel]
  have h := matchFold_safe (C := C) key₁ key₂ encode (view₁ s₁) (view₂ s₂) hwidth
  exact (nodes_le_width_mul_entries h.hasWidth h.compact).trans
    (Nat.mul_le_mul_left _ h.bound)

end LowSpaceSubsetSum.BinaryTrie

end OAI