progress

type BatchPanelOptions struct {
	// MaxActiveRows caps the number of active batches rendered as full
	// detail rows. Overflow becomes a single "+N more active" line.
	// Defaults to 10 when <= 0.
	MaxActiveRows int

	// RecentTail caps the number of recently-finished rows rendered
	// below the active ones. Defaults to 10 when <= 0 — same cap as
	// MaxActiveRows so the panel feels symmetric.
	RecentTail int

	// Animation is a monotonic tick counter used to cycle the
	// indeterminate dotted bar for active batches that haven't
	// streamed any bytes yet. Pass int(elapsed / 100ms) so the
	// animation advances at a steady 10 fps.
	Animation int

	// Now overrides the wall-clock used to compute per-row elapsed
	// timers. Zero defaults to time.Now() — tests pin this so
	// snapshot output is deterministic.
	Now time.Time
}

type BatchState struct {
	// Index is the call's original 0-based index (1-based on the
	// wire as "Batch K"). Stable across the run.
	Index int
	// Label is the human-readable description: directory ("internal/ui")
	// for general batches, "category/subcategory" (with " [critical]"
	// suffix for individual calls) for AOI-driven ones.
	Label string
	// Files is the count rendered in the panel's middle column. The
	// semantic depends on Unit: "files" for deep-review batches,
	// "findings" for recheck batches. Naming is legacy — kept as
	// "Files" so existing snapshot tests don't churn.
	Files int
	// Unit is the noun shown after Files in the panel ("files",
	// "findings"). Empty defaults to "files" so deep-review wire
	// shape (kind=aoi-driven|general, no unit token) keeps working.
	Unit string
	// Kind is "aoi-driven" or "general". Drives the row's accent color.
	Kind string
	// Status is the lifecycle stage.
	Status BatchStatus
	// StartedAt is set when the batch transitions to active. Zero
	// while queued. Used to compute the elapsed timer on the row.
	StartedAt time.Time
	// EndedAt is set when the batch transitions to done/cached/failed.
	// Zero while queued or active.
	EndedAt time.Time
	// Bytes is the cumulative content-byte count received from the
	// LLM stream for this batch. Drives the per-row progress bar
	// when non-zero; the row falls back to an indeterminate spinner
	// when zero.
	Bytes int
	// Findings is the number of findings this batch produced. Set
	// from the optional `findings=N` token on terminal events
	// (done/cached). Rendered next to the elapsed time on finished
	// rows so the user can see what work each call delivered.
	Findings int
}

type BatchStatus string

type Config struct {
	Header Header
	Phases []PhaseDef

	// RunTask is the background work. emit forwards (phase, message)
	// events into the model on the Bubble Tea main thread. The
	// returned error becomes the run's error (passed to Summary).
	RunTask func(emit func(phase, message string)) error

	// ParseEvent updates counters in s for a (phase, message) pair.
	// Optional. The TUI also recognizes the special phase "warning"
	// as a banner regardless of ParseEvent.
	ParseEvent func(s *State, phase, message string)

	// Summary renders the final box after the run completes.
	// Optional. err is the RunTask return value; elapsed is wall time.
	Summary func(err error, elapsed time.Duration) string

	// OnCancel is called when the user exits the TUI (Ctrl+C / q)
	// before the background task signals done. The task's goroutine
	// is still in flight at this point; the canonical use is for the
	// caller to cancel the context it passed to RunTask so the
	// in-flight LLM call returns quickly instead of orphaning. Optional.
	OnCancel func()

	// BatchPhases lists the phase Names whose active state should
	// trigger the Batches panel. The panel renders below the phase
	// list while one of these is the active phase. Empty disables
	// the panel — modes whose pipelines don't emit per-batch
	// lifecycle events leave this nil.
	BatchPhases []string
}

type Header struct {
	Title    string // e.g. "  prr audit", "  prr review"
	Subtitle string // e.g. repo name, PR number
	Info     string // e.g. "review: model-x  aoi: model-y"
}

type PhaseDef struct {
	// Name is the event key the pipeline emits on (e.g. "phase2", "fetch").
	// Must be unique within a Config.Phases slice.
	Name string

	// Label is the human-readable label shown next to the spinner/check.
	Label string

	// ProgressFn computes the active-phase progress bar value (0..1)
	// from the current State. Called only while this phase is active.
	// Return 0 (or leave nil) to skip the progress bar for this phase.
	ProgressFn func(s *State) float64

	// Counter returns (done, total) for inline "X/Y" display next to
	// the phase label. Rendered while the phase is active *and* after
	// it completes (so users can see the final tally per phase).
	// Skipped when total <= 0. Optional.
	Counter func(s *State) (done, total int)

	// CounterUnit is the unit shown after the X/Y, e.g. "batches",
	// "findings", "files". Empty omits the unit (legacy behavior).
	// Surfacing this is what tells the user whether 0/3 means three
	// files, three batches, or three findings — the absence of a
	// unit reads as ambiguous noise.
	CounterUnit string

	// Summary returns a stable description of what this phase
	// accomplished. Rendered as the row's detail line when the phase
	// reaches `done` state, replacing the last-write-wins live detail.
	// Falls back to live detail when this returns "" or is nil.
	//
	// Use this to surface structured information that would otherwise
	// be lost as the live detail line flips between transient status
	// messages — e.g., "kept 11 · dismissed 4" for Recheck or
	// "35 done · 58 cached · 3 failed" for Deep Review.
	Summary func(s *State) string
}

type PhaseInfo struct {
	Def    PhaseDef
	Status PhaseStatus
	Detail string
}

type PhaseStatus string

type State struct {
	Counters map[string]int
	Elapsed  time.Duration

	// Batches is populated by ParseEvent for modes whose pipelines
	// emit per-batch lifecycle events (Batch K: init/active/stream/
	// done/cached/failed). The Batches panel renders these as one
	// row per active batch plus a recent-completions tail. Nil for
	// modes that don't emit those events.
	Batches map[int]*BatchState
}