import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedTieGroupCompletion
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CountedStreamJoin

namespace OAI

/-! # One prepaid step of the stopped sorted-stream join -/

namespace LowSpaceSubsetSum.BudgetedStreamStep

universe u v s t w
variable {α : Type u} {β : Type v} {σ₁ : Type s} {σ₂ : Type t} {τ : Type w}

def advance (st : StreamJoin.State σ₁ σ₂ τ) (out : TieGroup.Result σ₁ σ₂ τ) :
    StreamJoin.State σ₁ σ₂ τ :=
  ⟨out.outer.cursor, out.outer.state.last, out.outer.state.user,
    st.queries + 2 + out.outer.queries + out.fillQueries + out.outer.state.queries,
    st.reports + out.outer.state.reports,
    st.copies + (if out.snapshot then 1 else 0) + out.outer.state.restores, out.outer.halted⟩

def execute (base front fill outer inner copy : ℕ)
    (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ)
    (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ)
    (cells : β → ℕ) (report : α → β → τ → (τ × Bool) × ℕ)
    (clone : σ₂ → σ₂ × ℕ) (B fuel₁ fuel₂ : ℕ)
    (st : StreamJoin.State σ₁ σ₂ τ) (budget : ℕ) :
    Option (StreamJoin.State σ₁ σ₂ τ × ℕ) × ℕ :=
  if base ≤ budget then
    if st.done then (some (st, budget - base), 1) else
    let x := read₁ st.left
    match x.1 with
    | none => (some ({st with queries := st.queries + 1, done := true}, budget - base), x.2 + 4)
    | some (a, left) =>
      let y := read₂ st.right
      match y.1 with
      | none => (some ({st with queries := st.queries + 2, done := true}, budget - base), x.2 + y.2 + 5)
      | some (b, right) =>
        let k₁ := key₁ a
        let k₂ := key₂ b
        if k₁.1 < k₂.1 then
          (some ({st with left := left, queries := st.queries + 2}, budget - base), x.2 + y.2 + k₁.2 + k₂.2 + 8)
        else if k₂.1 < k₁.1 then
          (some ({st with right := right, queries := st.queries + 2}, budget - base), x.2 + y.2 + k₁.2 + k₂.2 + 8)
        else
          let out := BudgetedTieGroup.execute front fill outer inner copy read₁ key₁ read₂ key₂ cells k₁.1
            report clone B fuel₁ fuel₂ st.left st.right st.user (budget - base)
          (out.1.map (fun (group, left) => (advance st group, left)),
            x.2 + y.2 + k₁.2 + k₂.2 + out.2 + 16)
  else (none, 1)

theorem execute_value (base front fill outer inner copy : ℕ)
    (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ)
    (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ)
    (cells : β → ℕ) (report : α → β → τ → (τ × Bool) × ℕ)
    (clone : σ₂ → σ₂ × ℕ) (B fuel₁ fuel₂ : ℕ)
    (st : StreamJoin.State σ₁ σ₂ τ) (budget : ℕ) (out : StreamJoin.State σ₁ σ₂ τ) (left : ℕ)
    (h : (execute base front fill outer inner copy read₁ key₁ read₂ key₂ cells report clone
      B fuel₁ fuel₂ st budget).1 = some (out, left)) :
    out = (CountedStreamJoin.step read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ st).1 ∧
      left ≤ budget := by
  rw [execute] at h
  split at h
  next hb =>
    by_cases hd : st.done = true
    · simp only [hd, ↓reduceIte] at h
      cases h
      exact ⟨by simp only [CountedStreamJoin.step, hd, ↓reduceIte], Nat.sub_le _ _⟩
    · simp only [hd, Bool.false_eq_true, ↓reduceIte] at h
      rw [CountedStreamJoin.step]
      simp only [hd, Bool.false_eq_true, ↓reduceIte]
      cases hx : (read₁ st.left).1 with
      | none =>
        simp only [hx] at h ⊢
        cases h
        exact ⟨rfl, Nat.sub_le _ _⟩
      | some p =>
        rcases p with ⟨a, a'⟩
        simp only [hx] at h ⊢
        cases hy : (read₂ st.right).1 with
        | none =>
          simp only [hy] at h ⊢
          cases h
          exact ⟨rfl, Nat.sub_le _ _⟩
        | some p =>
          rcases p with ⟨b, b'⟩
          simp only [hy] at h ⊢
          by_cases hk : (key₁ a).1 < (key₂ b).1
          · simp only [hk, ↓reduceIte] at h ⊢
            cases h
            exact ⟨rfl, Nat.sub_le _ _⟩
          · simp only [hk, ↓reduceIte] at h ⊢
            by_cases hk' : (key₂ b).1 < (key₁ a).1
            · simp only [hk', ↓reduceIte] at h ⊢
              cases h
              exact ⟨rfl, Nat.sub_le _ _⟩
            · simp only [hk', ↓reduceIte] at h ⊢
              obtain ⟨pair, hg, he⟩ := Option.map_eq_some_iff.mp h
              rcases pair with ⟨group, remaining⟩
              have hv := BudgetedTieGroup.execute_value front fill outer inner copy read₁ key₁ read₂ key₂ cells
                (key₁ a).1 report clone B fuel₁ fuel₂ st.left st.right st.user (budget - base) group remaining hg
              cases he
              exact ⟨by rw [hv.1]; rfl, hv.2.trans (Nat.sub_le _ _)⟩
  next _ => contradiction

theorem execute_work
    (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ)
    (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ)
    (cells : β → ℕ) (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ)
    (R₁ L₁ R₂ L₂ S C base front fill outer inner copy : ℕ)
    (hr₁ : ∀ s, (read₁ s).2 ≤ R₁) (hk₁ : ∀ x, (key₁ x).2 ≤ L₁)
    (hr₂ : ∀ s, (read₂ s).2 ≤ R₂) (hk₂ : ∀ y, (key₂ y).2 ≤ L₂)
    (hs : ∀ y, cells y ≤ S) (hc : ∀ x y a, (report x y a).2 ≤ C)
    (hbase : R₁ + L₁ + R₂ + L₂ + 16 ≤ base)
    (hfront : R₁ + L₁ + R₂ + L₂ + 16 ≤ front)
    (hfill : R₂ + L₂ + S + 8 ≤ fill) (houter : R₁ + L₁ + 8 ≤ outer)
    (hinner : max R₂ 4 + L₂ + C + 8 ≤ inner) (hcopy : ∀ s, (clone s).2 ≤ copy)
    (B fuel₁ fuel₂ : ℕ) (st : StreamJoin.State σ₁ σ₂ τ) (budget : ℕ) :
    (execute base front fill outer inner copy read₁ key₁ read₂ key₂ cells report clone
      B fuel₁ fuel₂ st budget).2 ≤ budget + 1 := by
  rw [execute]
  split
  next hb =>
    by_cases hd : st.done = true
    · simp only [hd, ↓reduceIte]; omega
    · simp only [hd, Bool.false_eq_true, ↓reduceIte]
      have hxw := hr₁ st.left
      cases hx : (read₁ st.left).1 with
      | none => dsimp only; omega
      | some p =>
        rcases p with ⟨x, x'⟩
        dsimp only
        have hyw := hr₂ st.right
        cases hy : (read₂ st.right).1 with
        | none => dsimp only; omega
        | some p =>
          rcases p with ⟨y, y'⟩
          have hxk := hk₁ x
          have hyk := hk₂ y
          dsimp only
          split
          · (try dsimp only); omega
          · split
            · (try dsimp only); omega
            · have hg := BudgetedTieGroup.execute_work read₁ key₁ read₂ key₂ cells (key₁ x).1 report clone
                R₁ L₁ R₂ L₂ S C front fill outer inner copy hr₁ hk₁ hr₂ hk₂ hs hc
                hfront hfill houter hinner hcopy B fuel₁ fuel₂ st.left st.right st.user (budget - base)
              try dsimp only
              omega
  next _ => (try dsimp only); omega

end LowSpaceSubsetSum.BudgetedStreamStep

end OAI