tix/ui/

triage.rs

//! The triage inbox and its decision modal (WP06, T029–T032).
//!
//! One view over the queue the WP02 service answers, plus the modal that
//! decides an item of it. The view is a **modal over the board**, exactly like
//! settings, planning and the batch modal, so nothing about the board, the
//! tabs or the card cursor changes to make room for it: the inbox renders on
//! top and `esc` drops it, leaving the cursor where it was (T029).
//!
//! ## What this module computes, and what it does not
//!
//! Nothing here decides anything. Age, membership, counts and the histogram
//! come from [`crate::triage::inbox::scope`] plus
//! [`crate::triage::inbox::collect`] — one pass over one snapshot. A
//! decision is [`crate::triage::batch::build_plan`] plus, only after a second
//! `y`, [`crate::triage::batch::apply`], which is the same #173 core
//! `tix triage batch` drives (C-005, T031). The preview and report text is the
//! CLI's own [`crate::commands::triage`] renderers, so the two surfaces cannot
//! describe the same plan differently (NFR-003).
//!
//! There is no second completion rule, no status compared against a literal,
//! and no `store.update` outside the batch engine's. The one thing that *is*
//! restated here is the shape of a refusal when there is no inbox at all —
//! `TriageState::open` needs a message, and `commands::triage::scope_of` is
//! private to that module; both are `TixError::InvalidInput` and both name
//! `[triage]` in `tix.toml`, which is the part the contract makes load-bearing.
//!
//! ## Why the decision keys are not in the key table
//!
//! `a`, `d`, `u`, `f`, `p`, `y`, `q` and every letter a reason or a duplicate
//! target might contain are deliberately **unbound** in
//! [`crate::keybindings::InputContext::Triage`], so
//! [`crate::app::App::handle_key`]'s fallback hands them to the handler
//! verbatim. Binding `q` to close the inbox — which the board does — would
//! canonicalise a `q` typed into a decline reason into an `Esc` and close the
//! modal mid-sentence; the same defect is why `LinkPrompt` and `Comment` bind
//! only `esc`. What the modal can do at any moment is named by its own
//! [`TriageModal::footer`], which is how the batch modal names its keys.

use std::fmt::Write as _;

use ratatui::Frame;
use ratatui::layout::{Constraint, Direction, Layout, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Clear, Paragraph};

use crate::bulk::{Selection, SelectionScope, SelectionSource};
use crate::commands::triage as cli_triage;
use crate::error::{Result, TixError};
use crate::model::Issue;
use crate::storage::Store;
use crate::triage::inbox::{self, AgeBucket, InboxScope, QueueMetrics};
use crate::triage::{DecisionKind, TriageDecision, TriagePlan, batch};
use crate::ui::bulk::BulkSelection;

// ---------------------------------------------------------------------------
// T029/T030 — the queue snapshot
// ---------------------------------------------------------------------------

/// One row of the inbox: the issue, how long it has waited, and the last
/// decision recorded on it.
///
/// Owned rather than borrowed because [`inbox::QueueMetrics`] borrows the
/// snapshot it was collected from, and the inbox outlives the query that
/// filled it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QueueRow {
    /// The issue as the snapshot read it.
    pub issue: Issue,
    /// Days since the entry stamp; `None` when nothing recorded one. Never
    /// `0` for "unknown" — that is [`inbox`]'s rule and it is copied, not
    /// re-derived.
    pub age_days: Option<i64>,
    /// The last triage decision, as `kind -> result — reason (actor, date)`,
    /// or `None` for an issue nobody has decided.
    pub last_decision: Option<String>,
}

/// The counts and histogram the header renders, copied out of [`QueueMetrics`]
/// so the snapshot outlives the query that produced it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TriageSummary {
    /// Inbox entries.
    pub total: usize,
    /// Entries in the entry column.
    pub awaiting: usize,
    /// Entries in the deferred column.
    pub deferred: usize,
    /// Entries already `completed` while still in an inbox column.
    pub accepted: usize,
    /// Entries already `canceled` while still in an inbox column.
    pub declined: usize,
    /// Entries that originate a `duplicates` edge.
    pub duplicated: usize,
    /// Entries with no readable entry stamp.
    pub unknown_age: usize,
    /// The age histogram, in [`inbox::AGE_BUCKETS`] order. Sums to `total`.
    pub age: Vec<AgeBucket>,
}

impl TriageSummary {
    /// Copy the metrics out of the query that borrowed them.
    #[must_use]
    pub fn of(metrics: &QueueMetrics<'_>) -> Self {
        Self {
            total: metrics.total,
            awaiting: metrics.awaiting,
            deferred: metrics.deferred,
            accepted: metrics.accepted,
            declined: metrics.declined,
            duplicated: metrics.duplicated,
            unknown_age: metrics.unknown_age,
            age: metrics.age_distribution.clone(),
        }
    }

    /// The header line, in the **CLI's** wording.
    ///
    /// `commands::triage::summary_line` prints this same string for
    /// `tix triage list --count`, and
    /// `triage_tui_the_inbox_counts_are_the_clis_counts_for_the_same_snapshot`
    /// pins the two together: a header the two surfaces could spell differently
    /// is a header a reader would trust differently.
    #[must_use]
    pub fn header(&self) -> String {
        format!(
            "inbox: {} entr{} ({} awaiting, {} deferred)",
            self.total,
            if self.total == 1 { "y" } else { "ies" },
            self.awaiting,
            self.deferred
        )
    }

    /// The age histogram, every bucket named including the zeros.
    #[must_use]
    pub fn age_line(&self) -> String {
        let cells: Vec<String> = self
            .age
            .iter()
            .map(|bucket| format!("{} {}", bucket.label, bucket.count))
            .collect();
        format!("age: {}", cells.join(" · "))
    }

    /// The decision counts. `accepted`/`declined` are the WP02 *staleness*
    /// readings — they come from `is_completed` and the category resolver, not
    /// from a column name.
    #[must_use]
    pub fn decisions_line(&self) -> String {
        format!(
            "decisions: {} accepted · {} declined · {} duplicated · {} unknown age",
            self.accepted, self.declined, self.duplicated, self.unknown_age
        )
    }
}

/// The one row under the cursor, for the detail line below the list.
#[must_use]
pub fn decision_summary(row: &QueueRow) -> String {
    let mut out = format!(
        "#{number} \"{title}\" — {status}",
        number = row.issue.number,
        title = row.issue.title,
        status = row.issue.status.display(),
    );
    match &row.last_decision {
        Some(last) => {
            let _ = write!(out, " — last decision: {last}");
        }
        None => out.push_str(" — last decision: none"),
    }
    out
}

/// The last decision on `issue`, formatted for a queue row.
///
/// `triage_decided` and friends rather than the decision verb: the History
/// event's own kind is what is on disk, and a summary that renamed it would be
/// a second spelling of the same fact.
fn last_decision(issue: &Issue) -> Option<String> {
    let record = crate::triage::history::last_decision(issue)?;
    let mut out = format!("{} -> {}", record.kind.as_str(), record.result);
    if let Some(reason) = &record.reason {
        let _ = write!(out, " — {reason}");
    }
    let when = record.timestamp.get(..10).unwrap_or(&record.timestamp);
    let _ = write!(out, " ({}, {})", record.actor, when);
    Some(out)
}

/// The inbox scope, or the one refusal every triage surface shares.
///
/// The message names the *inbox* rather than `tix triage`, because this is the
/// TUI. What the contract makes load-bearing is the category and the fact that
/// both name `[triage]` in `tix.toml`, and both are the crate's existing
/// `invalid input` variant — no triage diagnostic in
/// `crate::workflow::DiagnosticKind` (whose `ALL` stays at seven).
fn scope_of(store: &Store) -> Result<InboxScope> {
    inbox::scope(&store.config)?.ok_or_else(|| {
        TixError::InvalidInput(
            "the triage inbox needs a `[triage]` section in tix.toml, and this project has none"
                .to_string(),
        )
    })
}

// ---------------------------------------------------------------------------
// T031 — the decision modal
// ---------------------------------------------------------------------------

/// What the modal is asking for.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DecisionField {
    Reason,
    Actor,
    /// The accept target (`--to`). Present for `accept` only, so `--to` on a
    /// decline cannot be typed — the same check `run_batch` makes on a flag.
    Target,
    /// The duplicate target (`--of`). Present for `duplicate` only, so `--of`
    /// on an accept cannot be typed either.
    DuplicateOf,
}

impl DecisionField {
    #[must_use]
    pub fn label(self) -> &'static str {
        match self {
            Self::Reason => "reason",
            Self::Actor => "actor",
            Self::Target => "to",
            Self::DuplicateOf => "of",
        }
    }
}

/// The issue a decision is about: one from the cursor, or everything marked.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ModalScope {
    /// One issue, by number. Resolved from the **store** at plan time, so the
    /// plan is built from the file on disk and not from a row the list drew
    /// before the file changed.
    One(u32),
    /// The marked issues, in the order they were marked.
    Many(BulkSelection),
}

/// Where the modal is in its own cycle. The #173 batch modal's shape, because
/// "I saw it" and "I approved it" are two decisions here too.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ModalState {
    /// The fields, ready to edit.
    Editing,
    /// The modal asked for something it cannot plan without.
    NeedsInput(String),
    /// A plan is on screen. **Nothing has been written.**
    Preview(Box<TriagePlan>),
    /// The plan is armed: one more `y` writes.
    Confirming(Box<TriagePlan>),
    /// The apply ran. Its per-item outcomes and counts are in the string.
    Done(String),
    /// The plan or the apply was refused. Its reasons are in the string.
    Refused(String),
}

/// The decision modal: four fields, four states, one plan.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TriageModal {
    /// Which decision.
    pub kind: DecisionKind,
    /// One issue or the marked set.
    pub scope: ModalScope,
    /// What the title says: `#12 Alpha` or `3 marked issues`.
    pub heading: String,
    /// The fields this decision has, in the order they are drawn.
    pub fields: Vec<DecisionField>,
    /// Which field the cursor is on.
    pub cursor: usize,
    /// Whether the cursor's field is being typed into.
    pub editing: bool,
    /// The text being typed. Discarded on `esc`, never committed.
    pub draft: String,
    pub reason: String,
    pub actor: String,
    pub target: String,
    pub duplicate_of: String,
    /// The decision timestamp, fixed when the modal opened so a preview and the
    /// apply it authorises stamp the same event.
    pub timestamp: String,
    pub state: ModalState,
    /// The last message, for the status bar and the body.
    pub note: Option<String>,
    /// Whether the plan no longer matches the screen.
    pub plan_stale: bool,
}

impl TriageModal {
    /// A fresh modal for `kind` over `scope`.
    ///
    /// The fields are fixed per decision rather than per keystroke, which is
    /// how `--to` on a decline and `--of` on an accept become *untypeable*
    /// instead of merely refused: the flag does not exist to type into.
    #[must_use]
    pub fn new(kind: DecisionKind, scope: ModalScope, heading: String) -> Self {
        let fields = Self::fields_for(kind);
        Self {
            kind,
            scope,
            heading,
            fields,
            cursor: 0,
            editing: false,
            draft: String::new(),
            reason: String::new(),
            actor: String::new(),
            target: String::new(),
            duplicate_of: String::new(),
            timestamp: crate::model::utc_now_rfc3339(),
            state: ModalState::Editing,
            note: None,
            plan_stale: false,
        }
    }

    #[must_use]
    pub fn field(&self, index: usize) -> DecisionField {
        self.fields
            .get(index)
            .copied()
            .unwrap_or(DecisionField::Reason)
    }

    #[must_use]
    pub fn field_value(&self, field: DecisionField) -> &str {
        match field {
            DecisionField::Reason => &self.reason,
            DecisionField::Actor => &self.actor,
            DecisionField::Target => &self.target,
            DecisionField::DuplicateOf => &self.duplicate_of,
        }
    }

    fn field_mut(&mut self, field: DecisionField) -> &mut String {
        match field {
            DecisionField::Reason => &mut self.reason,
            DecisionField::Actor => &mut self.actor,
            DecisionField::Target => &mut self.target,
            DecisionField::DuplicateOf => &mut self.duplicate_of,
        }
    }

    pub fn begin_edit(&mut self) {
        let field = self.field(self.cursor);
        self.draft = self.field_value(field).to_string();
        self.editing = true;
    }

    pub fn push_char(&mut self, c: char) {
        if self.editing {
            self.draft.push(c);
        }
    }

    pub fn pop_char(&mut self) {
        if self.editing {
            self.draft.pop();
        }
    }

    pub fn commit_edit(&mut self) {
        if !self.editing {
            return;
        }
        let field = self.field(self.cursor);
        let draft = std::mem::take(&mut self.draft);
        *self.field_mut(field) = draft;
        self.editing = false;
        // The row changed, so the plan on screen no longer describes it. The
        // state is deliberately **not** reset to `Editing`: the plan is left
        // visible and labelled stale, because a preview that silently vanished
        // the moment a field was edited leaves the user with no way to see
        // what their edit invalidated (contract §4: any change requires a new
        // preview — and `confirm` is what refuses the old one).
        self.plan_stale = true;
    }

    /// Abandon the draft. The row keeps whatever `commit_edit` last stored.
    pub fn abort_edit(&mut self) {
        self.draft.clear();
        self.editing = false;
    }

    pub fn move_cursor(&mut self, delta: isize) {
        if self.fields.is_empty() {
            return;
        }
        let len = self.fields.len() as isize;
        let next = (self.cursor as isize + delta).rem_euclid(len);
        self.cursor = next as usize;
    }

    /// What the batch modal's `a` does: pick the next decision.
    ///
    /// The typed fields survive, so a reason the user already wrote does not
    /// have to be written again because they changed their mind about which
    /// decision it belonged to. What does **not** survive is any plan built
    /// for the old verb — `state` goes back to [`ModalState::Editing`] and
    /// `plan_stale` is set, so the only way to see a plan is to preview this
    /// one (contract §4: any change requires a new preview).
    pub fn cycle_kind(&mut self) {
        self.kind = match self.kind {
            DecisionKind::Accept => DecisionKind::Decline,
            DecisionKind::Decline => DecisionKind::Duplicate,
            DecisionKind::Duplicate => DecisionKind::Defer,
            DecisionKind::Defer => DecisionKind::Accept,
        };
        self.fields = Self::fields_for(self.kind);
        if self.cursor >= self.fields.len() {
            self.cursor = self.fields.len() - 1;
        }
        self.state = ModalState::Editing;
        self.plan_stale = true;
    }

    /// The rows this decision has, in the order they are drawn.
    ///
    /// Fixed per decision rather than per keystroke: `--to` on a decline and
    /// `--of` on an accept do not exist as flags, so here they do not exist as
    /// rows either, and the check `run_batch` makes on those flags is
    /// unreachable by construction.
    fn fields_for(kind: DecisionKind) -> Vec<DecisionField> {
        let mut fields = vec![DecisionField::Reason, DecisionField::Actor];
        match kind {
            DecisionKind::Accept => fields.push(DecisionField::Target),
            DecisionKind::Duplicate => fields.push(DecisionField::DuplicateOf),
            DecisionKind::Decline | DecisionKind::Defer => {}
        }
        fields
    }

    /// The decision request these fields describe, shaped exactly like
    /// `commands::triage::run_batch`'s: a whitespace-only target is no target,
    /// and an accept that named none of its own names the configured one so the
    /// preview and the service cannot propose two destinations.
    ///
    /// A blank actor means *not specified*, so it falls back to the identity
    /// the CLI also uses when `--actor` is absent — an audit entry with no
    /// actor is worse than no entry (contract §Required reason and actor).
    #[must_use]
    pub fn request(&self, store: &Store) -> TriageDecision {
        let actor = if self.actor.trim().is_empty() {
            crate::storage::actor_identity()
        } else {
            self.actor.trim().to_string()
        };
        let mut decision = TriageDecision::new(
            self.kind,
            self.timestamp.clone(),
            actor,
            self.reason.clone(),
        );
        if self.kind == DecisionKind::Accept {
            let target = self.target.trim();
            decision.target_status = if target.is_empty() {
                None
            } else {
                Some(target.to_string())
            };
            if decision.target_status.is_none() {
                decision.target_status = store
                    .config
                    .triage
                    .as_ref()
                    .and_then(|triage| triage.accepted_status.clone());
            }
        }
        decision
    }

    /// The `--of` this modal carries, for a duplicate only.
    #[must_use]
    pub fn duplicate_target(&self) -> Option<String> {
        let raw = self.duplicate_of.trim();
        (!raw.is_empty() && self.kind == DecisionKind::Duplicate).then(|| raw.to_string())
    }

    /// One read-only plan over the modal's scope. **Writes nothing.**
    ///
    /// Both the single issue and the marked set go through
    /// [`batch::build_plan`], which is T031's "route single and batch
    /// operations through WP03/WP04": one preview engine, one refusal
    /// vocabulary, one per-item outcome shape, whatever the size of the batch.
    ///
    /// # Errors
    ///
    /// Propagates a *plan-level* failure (no `[triage]` section, an unresolvable
    /// `--of`, a `--to` on a decision that has none). A per-item refusal is not
    /// an error — it is a refused item in the plan, which is where a surface
    /// that reports every outcome has to put it.
    pub fn plan(&self, store: &Store, issues: &[(u32, Issue)]) -> Result<TriagePlan> {
        let selection = match &self.scope {
            ModalScope::One(number) => Selection::from_issues(
                [store.resolve_issue(&number.to_string())?],
                SelectionSource::Explicit,
                SelectionScope::Active,
            ),
            ModalScope::Many(marked) => marked.to_selection(issues).0,
        };
        batch::build_plan(
            store,
            selection,
            self.request(store),
            self.duplicate_target().as_deref(),
        )
    }

    /// Build the preview. A refusal the modal caused lands in `state`, not in
    /// the `Result`: an `Err` out of here would reach the event loop, and the
    /// only thing that could do with it is end the session (the rule WP04 froze
    /// for `BulkModal::preview`, and the reason `tix triage batch` prints a
    /// refusal and exits non-zero instead of erroring).
    pub fn preview(&mut self, store: &Store, issues: &[(u32, Issue)]) -> Result<()> {
        if let ModalScope::Many(marked) = &self.scope {
            if marked.is_empty() {
                self.state =
                    ModalState::NeedsInput("press `space` on a card to mark it".to_string());
                return Ok(());
            }
            // A marked number that has left the inbox between marking and
            // previewing is left out and **named**, the same way
            // `BulkModal::preview` reports a card that left the board.
            let (_selection, dropped) = marked.to_selection(issues);
            self.note = (!dropped.is_empty()).then(|| {
                format!(
                    "{} marked issue(s) left the inbox and were left out: #{}",
                    dropped.len(),
                    dropped
                        .iter()
                        .map(u32::to_string)
                        .collect::<Vec<_>>()
                        .join(", #")
                )
            });
        }
        match self.plan(store, issues) {
            Ok(plan) => {
                self.state = ModalState::Preview(Box::new(plan));
                self.plan_stale = false;
            }
            Err(e) => {
                self.state = ModalState::Refused(e.to_string());
                self.note = Some(e.to_string());
            }
        }
        Ok(())
    }

    /// `y`: from a preview, arm. From an armed preview, apply.
    ///
    /// Two presses because "I saw it" and "I approved it" are two decisions;
    /// one `y` conflates them (WP07's rule, kept rather than reinvented).
    ///
    /// The **stale** check runs before either branch: a plan built before the
    /// last field edit is a plan nobody read as it now stands, so the apply
    /// refuses rather than asking the second `y` to mean something different
    /// from what the first one did.
    ///
    /// # Errors
    ///
    /// Only an I/O failure behind the keyboard. A refusal lands in
    /// [`ModalState::Refused`], because the only thing an `Err` out of here
    /// could do is end the session.
    pub fn confirm(&mut self, store: &Store) -> Result<()> {
        if self.plan_stale
            && matches!(
                self.state,
                ModalState::Preview(_) | ModalState::Confirming(_)
            )
        {
            self.state = ModalState::Refused(
                "the fields changed since the preview — press `p` again to see what would \
                 happen now"
                    .to_string(),
            );
            return Ok(());
        }
        match &self.state {
            ModalState::Preview(plan) => {
                self.state = ModalState::Confirming(plan.clone());
                Ok(())
            }
            ModalState::Confirming(plan) => {
                let mut plan = (**plan).clone();
                plan.confirm();
                match batch::apply(store, &plan) {
                    Ok(report) => {
                        let text = cli_triage::render_report(&report, &plan);
                        self.state = ModalState::Done(text);
                        self.plan_stale = false;
                    }
                    Err(e) => {
                        self.state = ModalState::Refused(e.to_string());
                        self.note = Some(e.to_string());
                    }
                }
                Ok(())
            }
            _ => Ok(()),
        }
    }

    #[must_use]
    pub fn is_armed(&self) -> bool {
        matches!(self.state, ModalState::Confirming(_))
    }

    #[must_use]
    pub fn state_label(&self) -> &'static str {
        match &self.state {
            ModalState::Editing => "editing",
            ModalState::NeedsInput(_) => "needs input",
            ModalState::Preview(_) | ModalState::Confirming(_) if self.plan_stale => {
                "stale — preview again"
            }
            ModalState::Preview(_) => "preview — nothing written",
            ModalState::Confirming(_) => "confirming — y writes",
            ModalState::Done(_) => "done",
            ModalState::Refused(_) => "refused",
        }
    }

    /// The footer: only the keys that mean something **right now**. A footer
    /// that names `y` while `y` types a letter teaches the wrong thing.
    #[must_use]
    pub fn footer(&self) -> String {
        if self.editing {
            return "enter commit · esc revert".to_string();
        }
        if self.plan_stale
            && matches!(
                self.state,
                ModalState::Preview(_) | ModalState::Confirming(_)
            )
        {
            return "press p to re-preview · esc to cancel".to_string();
        }
        match &self.state {
            ModalState::Preview(_) => "y to confirm · p to re-preview · esc to cancel".to_string(),
            ModalState::Confirming(_) => "y APPLIES THIS WRITE · esc to cancel".to_string(),
            ModalState::Done(_) | ModalState::Refused(_) | ModalState::NeedsInput(_) => {
                "p to re-preview · esc to close".to_string()
            }
            ModalState::Editing => {
                "a decision · j/k field · enter edit · t target · p preview · esc cancel"
                    .to_string()
            }
        }
    }

    /// The rows, as the modal draws them: a cursor, a label and a value.
    #[must_use]
    pub fn rows(&self) -> Vec<(bool, &'static str, String)> {
        self.fields
            .iter()
            .enumerate()
            .map(|(index, field)| {
                let value = if self.editing && index == self.cursor {
                    format!("{}█", self.draft)
                } else {
                    let value = self.field_value(*field);
                    if value.is_empty() {
                        "—".to_string()
                    } else {
                        value.to_string()
                    }
                };
                (index == self.cursor, field.label(), value)
            })
            .collect()
    }

    /// The text a surface shows for the current state, from the **CLI's**
    /// renderers wherever the CLI has one.
    #[must_use]
    pub fn body(&self) -> String {
        match &self.state {
            ModalState::Editing => {
                let mut out = format!("decision: {}\n", self.kind);
                if self.kind.requires_reason() {
                    out.push_str("a reason is required\n");
                }
                out.push_str("fields (enter to edit):\n");
                for (on, name, value) in self.rows() {
                    let cursor = if on { ">" } else { " " };
                    out.push_str(&format!("{cursor} {name}: {value}\n"));
                }
                if let Some(note) = &self.note {
                    out.push_str(&format!("\nnote: {note}\n"));
                }
                out.push('\n');
                out.push_str(&self.footer());
                out
            }
            ModalState::NeedsInput(what) => format!("{what}\n\n{}", self.footer()),
            // The plan table, verbatim from the CLI: `render_plan` is what
            // `tix triage batch --select …` prints for this same plan.
            ModalState::Preview(plan) => {
                let mut out = cli_triage::render_plan(plan);
                if let Some(note) = &self.note {
                    out.push_str(&format!("\nnote: {note}\n"));
                }
                out.push('\n');
                out.push_str(&self.footer());
                out
            }
            ModalState::Confirming(plan) => {
                let mut out = cli_triage::render_plan(plan);
                out.push('\n');
                out.push_str(&self.footer());
                out
            }
            ModalState::Done(text) | ModalState::Refused(text) => text.clone(),
        }
    }
}

// ---------------------------------------------------------------------------
// T029 — the inbox
// ---------------------------------------------------------------------------

/// The inbox view's own state: a cursor and a selection that are **not** the
/// board's, so opening and closing the inbox leaves
/// `(active_col, selected)` exactly as it was (T029).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TriageState {
    /// The queue, in the order the store lists it (or oldest-first under `A`).
    pub rows: Vec<QueueRow>,
    /// The header's counts.
    pub summary: TriageSummary,
    /// The row under the cursor.
    pub cursor: usize,
    /// The marked issues — #173's own ordered set, reused rather than grown
    /// beside it (the "duplicate selection model" risk, mitigated).
    pub selection: BulkSelection,
    /// Oldest-first, the TUI's `--age`.
    pub by_age: bool,
    /// The decision modal, `Some` exactly while one is open.
    pub modal: Option<TriageModal>,
    /// The last message worth showing under the list.
    pub note: Option<String>,
}

impl TriageState {
    /// Query the queue and open the inbox.
    ///
    /// # Errors
    ///
    /// A project with no `[triage]` section has no inbox, and the refusal is
    /// raised **before** the mode is entered — the board does not change under
    /// a user who pressed `t` in a project that does not use triage.
    pub fn open(store: &Store) -> Result<Self> {
        let mut state = Self {
            rows: Vec::new(),
            summary: TriageSummary {
                total: 0,
                awaiting: 0,
                deferred: 0,
                accepted: 0,
                declined: 0,
                duplicated: 0,
                unknown_age: 0,
                age: Vec::new(),
            },
            cursor: 0,
            selection: BulkSelection::new(),
            by_age: false,
            modal: None,
            note: None,
        };
        state.refresh(store)?;
        Ok(state)
    }

    /// Re-query the queue. Called on open and after every apply, so the counts
    /// are never a stale snapshot of a file that has moved on.
    ///
    /// # Errors
    ///
    /// Propagates the scope refusal and any I/O failure.
    pub fn refresh(&mut self, store: &Store) -> Result<()> {
        // `scope_of` rather than `inbox::scope`, so the refusal this view shows
        // is the one refusal there is — a project with no `[triage]` section
        // has no inbox, and saying so in two different words would make the
        // TUI and the CLI disagree about the same missing config.
        let scope = scope_of(store)?;
        let corpus = crate::search::Corpus::build(store)?;
        // The same two calls `commands::triage::render_list` makes: one
        // snapshot, one scope, one `today`, one pass.
        let metrics = inbox::collect(&corpus.issues, &scope, &crate::model::today());
        self.summary = TriageSummary::of(&metrics);
        self.rows = metrics
            .entries
            .iter()
            .map(|entry| QueueRow {
                issue: (*entry.issue).clone(),
                age_days: entry.age_days,
                last_decision: last_decision(entry.issue),
            })
            .collect();
        if self.by_age {
            self.sort_by_age();
        }
        self.clamp_cursor();
        Ok(())
    }

    /// Oldest first, with an unknown age sorted **last** on both ends rather
    /// than coerced to `0` — the rule `commands::triage::render_list` gives
    /// `--age`, restated rather than re-invented.
    fn sort_by_age(&mut self) {
        self.rows.sort_by(|a, b| match (a.age_days, b.age_days) {
            (Some(x), Some(y)) => y.cmp(&x),
            (Some(_), None) => std::cmp::Ordering::Less,
            (None, Some(_)) => std::cmp::Ordering::Greater,
            (None, None) => std::cmp::Ordering::Equal,
        });
    }

    fn clamp_cursor(&mut self) {
        if self.rows.is_empty() {
            self.cursor = 0;
        } else if self.cursor >= self.rows.len() {
            self.cursor = self.rows.len() - 1;
        }
    }

    pub fn move_cursor(&mut self, delta: isize) {
        if self.rows.is_empty() {
            return;
        }
        let len = self.rows.len() as isize;
        let next = (self.cursor as isize + delta).rem_euclid(len);
        self.cursor = next as usize;
    }

    #[must_use]
    pub fn current(&self) -> Option<&QueueRow> {
        self.rows.get(self.cursor)
    }

    /// Mark or unmark the row under the cursor. A refusal (a full selection, a
    /// number already marked) is reported, not swallowed.
    pub fn toggle_current(&mut self) {
        let Some(row) = self.rows.get(self.cursor) else {
            return;
        };
        match self.selection.toggle(row.issue.number) {
            Ok(_) => {}
            Err(problem) => self.note = Some(problem.to_string()),
        }
    }

    pub fn clear_selection(&mut self) {
        self.selection.clear();
    }

    /// Open the decision modal for the row under the cursor.
    pub fn open_single(&mut self, kind: DecisionKind) -> bool {
        let Some(row) = self.rows.get(self.cursor) else {
            self.note = Some("the inbox is empty — there is nothing to decide".to_string());
            return false;
        };
        let heading = format!("#{} {}", row.issue.number, row.issue.title);
        self.modal = Some(TriageModal::new(
            kind,
            ModalScope::One(row.issue.number),
            heading,
        ));
        true
    }

    /// Open the decision modal over everything marked.
    pub fn open_batch(&mut self, kind: DecisionKind) -> bool {
        if self.selection.is_empty() {
            self.note = Some("press `space` on a card to mark it first".to_string());
            return false;
        }
        let heading = format!("{} marked issue(s)", self.selection.len());
        self.modal = Some(TriageModal::new(
            kind,
            ModalScope::Many(self.selection.clone()),
            heading,
        ));
        true
    }

    /// Drop the modal and whatever state it was in. The queue and the
    /// selection are untouched: a cancel changes nothing, which is T032's
    /// claim about cancellation in full.
    pub fn close_modal(&mut self) {
        self.modal = None;
    }

    /// The snapshot the plan is built from, as the batch modal asks for it.
    fn issues(&self) -> Vec<(u32, Issue)> {
        self.rows
            .iter()
            .map(|row| (row.issue.number, row.issue.clone()))
            .collect()
    }

    /// Preview the open decision. Writes nothing, in every branch.
    ///
    /// # Errors
    /// Propagates an I/O failure behind the keyboard; a *refusal* is reported
    /// through [`ModalState::Refused`].
    pub fn preview(&mut self, store: &Store) -> Result<()> {
        let issues = self.issues();
        if let Some(modal) = self.modal.as_mut() {
            modal.preview(store, &issues)?;
        }
        Ok(())
    }

    /// `y` on the open decision: arm, then apply.
    ///
    /// # Errors
    /// Propagates an I/O failure behind the keyboard only.
    pub fn confirm(&mut self, store: &Store) -> Result<()> {
        // No `issues` here: the plan that is applied is the one the preview
        // built and stored, re-checked by `batch::apply` for freshness — not a
        // second plan rebuilt from a snapshot that may have moved on.
        if let Some(modal) = self.modal.as_mut() {
            modal.confirm(store)?;
        }
        Ok(())
    }

    /// Whether the modal finished, so the caller can refresh the queue and
    /// report the result the way `BulkModal`'s handler does.
    #[must_use]
    pub fn modal_finished(&self) -> bool {
        matches!(
            self.modal.as_ref().map(|modal| &modal.state),
            Some(ModalState::Done(_))
        )
    }

    /// The note worth showing under the list, preferring a completed apply's
    /// report over an older message.
    #[must_use]
    pub fn display_note(&self) -> Option<String> {
        match self.modal.as_ref().map(|modal| &modal.state) {
            Some(ModalState::Done(text)) | Some(ModalState::Refused(text)) => Some(text.clone()),
            _ => self.note.clone(),
        }
    }

    /// The inbox's own footer: what the list can do right now.
    #[must_use]
    pub fn footer(&self) -> String {
        if self.selection.is_empty() {
            "j/k move · space mark · a accept · d decline · u duplicate · f defer · p batch · A age · esc back"
                .to_string()
        } else {
            format!(
                "{} marked — p batch · X clear · a accept · d decline · u duplicate · f defer · esc back",
                self.selection.len()
            )
        }
    }

    /// The text the inbox pane shows.
    #[must_use]
    pub fn body(&self) -> String {
        let mut out = String::new();
        let _ = writeln!(out, "{}", self.summary.header());
        let _ = writeln!(out, "{}", self.summary.age_line());
        let _ = writeln!(out, "{}", self.summary.decisions_line());
        out.push('\n');
        if self.rows.is_empty() {
            out.push_str("the inbox is empty\n");
        }
        for (index, row) in self.rows.iter().enumerate() {
            let cursor = if index == self.cursor { ">" } else { " " };
            let mark = if self.selection.contains(row.issue.number) {
                "*"
            } else {
                " "
            };
            let _ = writeln!(
                out,
                "{cursor}{mark}{:<4} {:<8} {}",
                row.issue.number,
                age_cell(row.age_days),
                row.issue.title
            );
        }
        if let Some(row) = self.current() {
            let _ = writeln!(out, "\n{}", decision_summary(row));
        }
        if let Some(note) = self.display_note() {
            let _ = writeln!(out, "\n{note}");
        }
        let _ = write!(out, "\n{}", self.footer());
        out
    }
}

/// The age cell: a number of days, `today` for zero, `unknown` for no stamp.
///
/// Duplicated from `commands::triage::age_cell`, which is private to that
/// module: a reader who sees `0` believes the issue arrived today, and
/// `unknown` is the whole point of the entry stamp. The two spellings are
/// pinned together by
/// `triage_tui_the_inbox_counts_are_the_clis_counts_for_the_same_snapshot`,
/// which strips the inbox row's cursor and mark and compares the rest with
/// `tix triage list`'s own row — byte for byte, age cell included.
fn age_cell(age: Option<i64>) -> String {
    match age {
        Some(0) => "today".to_string(),
        Some(days) => format!("{days}d"),
        None => "unknown".to_string(),
    }
}

// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------

/// Render the inbox (and the decision modal over it) on top of the board.
///
/// Never asserts on pixels — a test reads the buffer.
pub fn render(frame: &mut Frame, area: Rect, state: &TriageState) {
    let rect = crate::ui::modal::modal_rect(area);
    frame.render_widget(Clear, rect);
    let block = Block::default()
        .borders(Borders::ALL)
        .title(" triage inbox ")
        .border_style(Style::default().fg(Color::Cyan));
    let inner = block.inner(rect);
    frame.render_widget(block, rect);

    let body = state.body();
    frame.render_widget(Paragraph::new(body), inner);

    if let Some(modal) = state.modal.as_ref() {
        let modal_rect = crate::ui::modal::modal_rect(rect);
        frame.render_widget(Clear, modal_rect);
        let modal_block = Block::default()
            .borders(Borders::ALL)
            .title(format!(" {} — {} ", modal.kind, modal.state_label()))
            .border_style(Style::default().fg(Color::Magenta));
        let modal_inner = modal_block.inner(modal_rect);
        frame.render_widget(modal_block, modal_rect);

        let chunks = Layout::default()
            .direction(Direction::Vertical)
            .constraints([Constraint::Length(1), Constraint::Min(1)])
            .split(modal_inner);
        frame.render_widget(
            Paragraph::new(Line::from(Span::styled(
                modal.heading.clone(),
                Style::default().add_modifier(Modifier::BOLD),
            ))),
            chunks[0],
        );
        frame.render_widget(Paragraph::new(modal.body()), chunks[1]);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Every WP06 unit test is named `triage_tui_*`, matching the gate
    /// `cargo test --test tui_state` and the naming the other triage work
    /// packages use.
    #[test]
    fn triage_tui_fields_exist_only_for_the_decision_that_can_use_them() {
        let one = ModalScope::One(1);
        let accept = TriageModal::new(DecisionKind::Accept, one.clone(), "a".into());
        assert_eq!(
            accept.fields,
            vec![
                DecisionField::Reason,
                DecisionField::Actor,
                DecisionField::Target
            ]
        );
        let decline = TriageModal::new(DecisionKind::Decline, one.clone(), "d".into());
        assert_eq!(
            decline.fields,
            vec![DecisionField::Reason, DecisionField::Actor],
            "`--to` has nowhere to be typed on a decline, so it cannot be"
        );
        let duplicate = TriageModal::new(DecisionKind::Duplicate, one.clone(), "u".into());
        assert_eq!(
            duplicate.fields,
            vec![
                DecisionField::Reason,
                DecisionField::Actor,
                DecisionField::DuplicateOf
            ]
        );
        let defer = TriageModal::new(DecisionKind::Defer, one, "f".into());
        assert_eq!(
            defer.fields,
            vec![DecisionField::Reason, DecisionField::Actor]
        );
    }

    #[test]
    fn triage_tui_the_cursor_only_moves_over_the_fields_the_decision_has() {
        let mut modal = TriageModal::new(DecisionKind::Decline, ModalScope::One(1), "d".into());
        modal.move_cursor(1);
        assert_eq!(modal.field(modal.cursor), DecisionField::Actor);
        modal.move_cursor(1);
        assert_eq!(
            modal.field(modal.cursor),
            DecisionField::Reason,
            "two fields, so the third step wraps back to the first"
        );
        modal.move_cursor(-1);
        assert_eq!(modal.field(modal.cursor), DecisionField::Actor);
    }

    #[test]
    fn triage_tui_a_cancelled_draft_never_reaches_the_row_it_was_typed_into() {
        let mut modal = TriageModal::new(DecisionKind::Decline, ModalScope::One(1), "d".into());
        modal.begin_edit();
        for c in "half a reason".chars() {
            modal.push_char(c);
        }
        modal.abort_edit();
        assert!(!modal.editing);
        assert_eq!(modal.reason, "", "the row never saw the draft");
    }

    #[test]
    fn triage_tui_a_committed_draft_lands_on_the_row_under_the_cursor() {
        let mut modal = TriageModal::new(DecisionKind::Decline, ModalScope::One(1), "d".into());
        modal.begin_edit();
        for c in "no budget".chars() {
            modal.push_char(c);
        }
        modal.commit_edit();
        assert_eq!(modal.reason, "no budget");
        assert_eq!(modal.field_value(modal.field(0)), "no budget");
    }

    #[test]
    fn triage_tui_an_accept_without_a_configured_target_names_none() {
        let config = crate::config::Config::default();
        let modal = TriageModal::new(DecisionKind::Accept, ModalScope::One(1), "a".into());
        let request = modal.request(&Store::open(&config).expect("an empty store opens"));
        assert_eq!(
            request.target_status, None,
            "no `--to` and no `[triage].accepted_status` means the service \
             refuses `missing_target`, exactly as the CLI does"
        );
    }

    #[test]
    fn triage_tui_the_header_is_the_cli_headers_wording() {
        let summary = TriageSummary {
            total: 3,
            awaiting: 2,
            deferred: 1,
            accepted: 0,
            declined: 0,
            duplicated: 0,
            unknown_age: 1,
            age: Vec::new(),
        };
        assert_eq!(
            summary.header(),
            "inbox: 3 entries (2 awaiting, 1 deferred)"
        );
    }

    #[test]
    fn triage_tui_an_unknown_age_is_unknown_and_never_zero() {
        assert_eq!(age_cell(None), "unknown");
        assert_eq!(age_cell(Some(0)), "today");
        assert_eq!(age_cell(Some(7)), "7d");
    }

    #[test]
    fn triage_tui_the_footer_names_only_keys_that_mean_something_now() {
        let mut modal = TriageModal::new(DecisionKind::Decline, ModalScope::One(1), "d".into());
        assert!(modal.footer().contains("p preview"), "editing: preview");
        modal.begin_edit();
        assert!(
            modal.footer().contains("enter commit"),
            "a letter while editing must not be advertised as a command"
        );
        assert!(!modal.footer().contains("p preview"));
    }
}