#!/bin/bash
set -euo pipefail
# Usage:
#   scripts/perf_bench_lake.sh [iterations]
#
# Environment:
#   BENCH_ARGS         Extra args for benchmark (default: --no-render)
#   PERF_RESULTS_ROOT  Results root dir (default: perf)
#   PERF_RUN_LABEL     Label for run (default: HHMMSS)
#
# Example:
#   BENCH_ARGS="--case search-bloom --lines 800 --line-len 120 --no-render" scripts/perf_bench_lake.sh 2000
ITERATIONS="10000"
BENCH_ARGS="${BENCH_ARGS:---no-render}"
PERF_CASES="${PERF_CASES:-}"
usage() {
  cat <<'USAGE'
Usage:
  scripts/perf_bench_lake.sh [iterations]
  scripts/perf_bench_lake.sh --iterations N
  scripts/perf_bench_lake.sh --case NAME [--case NAME...]
  scripts/perf_bench_lake.sh --cases "case1,case2"
Notes:
  - Cases are passed through to: bench --case <name>
  - Aliases: linear -> search-linear, bloom -> search-bloom
  - Extra bench args via BENCH_ARGS env (default: --no-render)
USAGE
}
case_list=""
iter_set="0"
while [ "$#" -gt 0 ]; do
  case "$1" in
    -n|--iterations)
      ITERATIONS="${2:-}"
      iter_set="1"
      shift 2
      ;;
    --case)
      case_list="${case_list}${2:-},"
      shift 2
      ;;
    --cases)
      PERF_CASES="${2:-}"
      shift 2
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      if [[ "$1" =~ ^[0-9]+$ ]] && [ "$iter_set" = "0" ]; then
        ITERATIONS="$1"
        iter_set="1"
        shift
      else
        echo "Error: unknown argument '$1'"
        usage
        exit 1
      fi
      ;;
  esac
done
if [ -n "$case_list" ]; then
  case_list="${case_list%,}"
  if [ -n "$PERF_CASES" ]; then
    PERF_CASES="${PERF_CASES},${case_list}"
  else
    PERF_CASES="${case_list}"
  fi
fi
RESULTS_ROOT="${PERF_RESULTS_ROOT:-perf}"
RUN_LABEL="${PERF_RUN_LABEL:-$(date +%H%M%S)}"
DATE_DIR="${RESULTS_ROOT}/$(date +%Y-%m-%d)"
REPORT_DIR="${DATE_DIR}/report"
PERF_DATA="${DATE_DIR}/perf-bench-${RUN_LABEL}.data"
PERF_REPORT="${REPORT_DIR}/perf-bench-${RUN_LABEL}.log"
FLAME_DIR="${DATE_DIR}/flamegraph"
PERF_FOLDED="${FLAME_DIR}/perf-bench-${RUN_LABEL}.folded"
FLAMEGRAPH_SVG="${FLAME_DIR}/flamegraph-bench-${RUN_LABEL}.svg"
FLAMEGRAPH_DIR="${FLAMEGRAPH_DIR:-$HOME/.local/bin/FlameGraph}"
STACKCOLLAPSE_BIN="${STACKCOLLAPSE_BIN:-${FLAMEGRAPH_DIR}/stackcollapse-perf.pl}"
FLAMEGRAPH_BIN="${FLAMEGRAPH_BIN:-${FLAMEGRAPH_DIR}/flamegraph.pl}"
echo "=== ViE perf (lake exe bench) ==="
echo "Iterations: ${ITERATIONS}"
echo "Bench args: ${BENCH_ARGS}"
if [ -n "${PERF_CASES}" ]; then
  echo "Perf cases: ${PERF_CASES}"
fi
echo "Results: ${DATE_DIR}"
# 1. Build bench
echo "Building benchmark..."
lake build bench
# 2. Check for perf
if ! command -v perf &> /dev/null; then
  echo "Error: 'perf' command not found. Please install perf."
  exit 1
fi
# 3. Prepare output directories
mkdir -p "${REPORT_DIR}" "${FLAME_DIR}"
# 4. Run perf record using lake exe bench -- <iterations> <args>
run_one () {
  local label="$1"
  shift
  local -a extra_args=("$@")
  local data="${DATE_DIR}/perf-bench-${label}.data"
  local report="${REPORT_DIR}/perf-bench-${label}.log"
  local folded="${FLAME_DIR}/perf-bench-${label}.folded"
  local svg="${FLAME_DIR}/flamegraph-bench-${label}.svg"
  echo "Running perf record (${label})..."
  perf record -g --call-graph dwarf -o "${data}" -- \
    lake exe bench -- "${ITERATIONS}" "${BENCH_ARGS_ARR[@]}" "${extra_args[@]}"
  echo "Writing report to ${report}"
  perf report -i "${data}" --stdio > "${report}"
  if { [ -x "${STACKCOLLAPSE_BIN}" ] && [ -x "${FLAMEGRAPH_BIN}" ]; } || \
     { command -v stackcollapse-perf.pl &> /dev/null && command -v flamegraph.pl &> /dev/null; }; then
    echo "Generating flamegraph (${label})..."
    if [ -x "${STACKCOLLAPSE_BIN}" ] && [ -x "${FLAMEGRAPH_BIN}" ]; then
      perf script -i "${data}" | "${STACKCOLLAPSE_BIN}" > "${folded}"
      "${FLAMEGRAPH_BIN}" "${folded}" > "${svg}"
    else
      perf script -i "${data}" | stackcollapse-perf.pl > "${folded}"
      flamegraph.pl "${folded}" > "${svg}"
    fi
  else
    echo "Flamegraph tools not found. Skipping flamegraph generation."
    echo "Expected in \$FLAMEGRAPH_DIR (default: ${FLAMEGRAPH_DIR})"
  fi
}
read -r -a BENCH_ARGS_ARR <<< "${BENCH_ARGS}"
if [ -n "${PERF_CASES}" ]; then
  IFS=',' read -r -a CASES_ARR <<< "${PERF_CASES}"
  for c in "${CASES_ARR[@]}"; do
    c_trim="$(echo "${c}" | xargs)"
    if [ -z "${c_trim}" ]; then
      continue
    fi
    case "${c_trim}" in
      linear) norm="search-linear" ;;
      bloom) norm="search-bloom" ;;
      *) norm="${c_trim}" ;;
    esac
    run_one "${RUN_LABEL}-${norm}" --case "${norm}"
  done
else
  run_one "${RUN_LABEL}"
fi
echo "Done."

#   - perf_bench_lake.sh: perf profiling via lake exe (includes lake overhead).

- `perf_bench_lake.sh`: perf record via `lake exe bench` (includes lake overhead).

## perf_bench_lake.sh
Purpose: perf capture through `lake exe bench` (measures lake overhead too).
Usage examples:

```bash
./scripts/perf_bench_lake.sh --iterations 10000 --case linear
./scripts/perf_bench_lake.sh --cases linear,bloom --iterations 20000
```
Key options match `perf_bench_bin.sh`.

import ViE.Lsp.Lean

/-- Case: Insert/backspace via keymap queue path (single-writer worker). -/
def benchInsertQueue (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let cfg := makeBenchConfig (some buildLeafBits)
  let mut s := { ViE.initialState with config := cfg.settings }
  s ← ViE.update cfg s (Key.char 'i')
  for i in [0:iterations] do
    if i % 9 == 0 then
      s ← ViE.update cfg s Key.backspace
    else
      s ← ViE.update cfg s (Key.char 'a')
  let _ ← ViE.update cfg s Key.esc

/-- Case: line lookup workload on large file (tree-based line traversal). -/
def benchLineLookupLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let lineCount := max 1 pt.lineCount
  let total := pt.length
  let mut checksum := 0
  for i in [0:iterations] do
    let row := i % lineCount
    match pt.getLineRange row with
    | some (start, len) =>
        checksum := checksum + start + len
    | none =>
        pure ()
    let off := if total == 0 then 0 else (i * 97) % total
    let (r, c) := pt.getPointFromOffset off
    checksum := checksum + r + c
  if checksum == 0 then
    IO.println "Zero checksum?"

/-- Case: compare sequential vs parallel substring extraction on large file. -/
def benchSubstringSeqLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let total := pt.length
  let readLen := min (512 * 1024) total
  let mut checksum := 0
  for i in [0:iterations] do
    let off := if total <= readLen then 0 else (i * 65537) % (total - readLen + 1)
    let s := PieceTree.getSubstring pt.tree off readLen pt
    checksum := checksum + s.length
  if checksum == 0 then
    IO.println "Zero checksum?"
/-- Case: compare sequential vs parallel substring extraction on large file. -/
def benchSubstringParLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let total := pt.length
  let readLen := min (512 * 1024) total
  let mut checksum := 0
  for i in [0:iterations] do
    let off := if total <= readLen then 0 else (i * 65537) % (total - readLen + 1)
    let s ← PieceTree.getSubstringParallelIO pt.tree off readLen pt
    checksum := checksum + s.length
  if checksum == 0 then
    IO.println "Zero checksum?"
/-- Case: syncEditorUpdate change-detection hot path. -/
def benchSyncEditorUpdate (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let cfg := makeBenchConfig (some buildLeafBits)
  let mut prev := { ViE.initialState with config := cfg.settings }
  let mut curr := prev
  for i in [0:iterations] do
    curr := curr.insertChar (if i % 2 == 0 then 'a' else 'b')
    let synced ← ViE.Lsp.Lean.syncEditorUpdate prev curr
    prev := synced
    curr := synced

    "getbytes-1mb", "getbytes-10mb" ]

    "getbytes-1mb", "getbytes-10mb",
    "insert-queue",
    "line-lookup-10mb",
    "substring-seq-10mb", "substring-par-10mb",
    "sync-update" ]

    | "insert-queue" => timeCase "insert-queue" opts.iterations (benchInsertQueue opts.iterations buildLeafBits)

    | "line-lookup-10mb" => timeCase "line-lookup-10mb" opts.iterations (benchLineLookupLarge10MB opts.iterations buildLeafBits)
    | "substring-seq-10mb" => timeCase "substring-seq-10mb" opts.iterations (benchSubstringSeqLarge10MB opts.iterations buildLeafBits)
    | "substring-par-10mb" => timeCase "substring-par-10mb" opts.iterations (benchSubstringParLarge10MB opts.iterations buildLeafBits)
    | "sync-update" => timeCase "sync-update" opts.iterations (benchSyncEditorUpdate opts.iterations buildLeafBits)