import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedStoppedJoin

namespace OAI

/-! # Tail-recursive execution of the prepaid stopped join

The loop keeps the completed-step and measured-work counters in its state.
No frame containing a prior cursor survives a recursive call.
-/

namespace LowSpaceSubsetSum.BudgetedStoppedLoop

universe s t w
variable {σ₁ : Type s} {σ₂ : Type t} {τ : Type w}
local notation "State" => StreamJoin.State σ₁ σ₂ τ
local notation "Result" => StreamJoin.StoppedResult σ₁ σ₂ τ

def shift (steps : ℕ) (out : Result) : Result := ⟨out.state, out.steps + steps⟩

def loop (step : State → ℕ → Option (State × ℕ) × ℕ) :
    ℕ → State → ℕ → ℕ → ℕ → Option (Result × ℕ) × ℕ
  | fuel, st, steps, budget, work =>
    if 4 ≤ budget then
      match fuel with
      | 0 => (some (⟨st, steps⟩, budget - 4), work + 1)
      | fuel + 1 =>
        if st.done then (some (⟨st, steps⟩, budget - 4), work + 1) else
        let next := step st (budget - 4)
        match next.1 with
        | none => (none, work + next.2 + 2)
        | some (state, left) => loop step fuel state (steps + 1) left (work + next.2 + 3)
    else (none, work + 1)

theorem loop_eq (step : State → ℕ → Option (State × ℕ) × ℕ)
    (fuel : ℕ) (st : State) (steps budget work : ℕ) :
    loop step fuel st steps budget work =
      ((BudgetedStoppedJoin.execute step fuel st budget).1.map (fun (out, left) => (shift steps out, left)),
        work + (BudgetedStoppedJoin.execute step fuel st budget).2) := by
  induction fuel generalizing st steps budget work with
  | zero =>
    rw [loop, BudgetedStoppedJoin.execute]
    split <;> simp only [Option.map_some, Option.map_none, shift, Nat.zero_add]
  | succ fuel ih =>
    rw [loop, BudgetedStoppedJoin.execute]
    split
    next hb =>
      by_cases hd : st.done = true
      · simp only [hd, ↓reduceIte, Option.map_some, shift, Nat.zero_add]
      · simp only [hd, Bool.false_eq_true, ↓reduceIte]
        cases hn : (step st (budget - 4)).1 with
        | none => simp only [Option.map_none, Nat.add_assoc]
        | some p =>
          rcases p with ⟨next, remaining⟩
          dsimp only
          rw [ih]
          simp only [Option.map_map, Function.comp_def, shift, Nat.add_assoc]
          apply Prod.ext
          · apply congrArg (fun f => (BudgetedStoppedJoin.execute step fuel next remaining).1.map f)
            funext p
            rcases p with ⟨out, left⟩
            simp only
            congr 2
            omega
          · omega
    next _ => rfl

def run (step : State → ℕ → Option (State × ℕ) × ℕ)
    (fuel : ℕ) (st : State) (budget : ℕ) := loop step fuel st 0 budget 0

theorem run_eq (step : State → ℕ → Option (State × ℕ) × ℕ)
    (fuel : ℕ) (st : State) (budget : ℕ) :
    run step fuel st budget = BudgetedStoppedJoin.execute step fuel st budget := by
  rw [run, loop_eq]
  simp only [shift, Nat.add_zero, Nat.zero_add]
  change ((BudgetedStoppedJoin.execute step fuel st budget).1.map id, _) = _
  apply Prod.ext
  · exact Option.map_id'
  · rfl

end LowSpaceSubsetSum.BudgetedStoppedLoop

end OAI