yog 0.0.1

//! The per-agent predicate: every signal, abandoned suppression, seen-gating
//! oid re-arm, the Free-vs-Unknown mail rule, and the real-`UiState` wiring.

use super::{acked, agent, nothing};
use crate::attention::*;
use crate::git_tree::{Agent, AgentState};
use crate::ui_state::{SeenKind, UiState};

#[test]
fn no_signals_is_no_attention() {
    let a = attention(&agent("a"), "ws", &nothing);
    assert!(!a.any());
    assert!(a.kinds().is_empty());
    assert_eq!(
        a,
        Attention {
            notify: false,
            stopped: false,
            budget: false,
            conflicted: false,
            mail: false,
        }
    );
}

#[test]
fn each_marked_signal_fires_when_unseen() {
    type Case = (fn(&mut Agent), AttentionKind);
    let cases: &[Case] = &[
        (|a| a.notify_oid = Some("n".into()), AttentionKind::Notify),
        (|a| a.budget_oid = Some("b".into()), AttentionKind::Budget),
        (
            |a| a.conflicted_oid = Some("c".into()),
            AttentionKind::Conflicted,
        ),
    ];
    for (mutate, kind) in cases {
        let mut ag = agent("a");
        mutate(&mut ag);
        let att = attention(&ag, "ws", &nothing);
        assert!(att.any(), "{kind:?} should fire");
        assert_eq!(att.kinds(), vec![*kind]);
        assert!(!att.mail, "a mark never implies mail");
    }
}

#[test]
fn stopped_fires_when_unabandoned_and_tip_unseen() {
    let mut ag = agent("a");
    ag.state = AgentState::Stopped;
    let att = attention(&ag, "ws", &nothing);
    assert!(att.stopped);
    assert_eq!(att.kinds(), vec![AttentionKind::Stopped]);
}

#[test]
fn abandoned_suppresses_the_stop_signal() {
    let mut ag = agent("a");
    ag.state = AgentState::Stopped;
    ag.abandoned_oid = Some("dead".into());
    let att = attention(&ag, "ws", &nothing);
    assert!(
        !att.stopped,
        "abandoned = will-not-retry suppresses stop (§6)"
    );
    assert!(!att.any());
}

#[test]
fn acked_oid_clears_but_moved_oid_re_arms() {
    let mut ag = agent("a");
    ag.notify_oid = Some("v2".into());
    // Watermark still on the old oid "v1": the current oid "v2" is unseen.
    assert!(
        attention(&ag, "ws", &acked(SeenKind::Notify, "v1")).notify,
        "a moved ref re-notifies (§4.1)"
    );
    // Watermark caught up to "v2": acknowledged, no attention.
    assert!(!attention(&ag, "ws", &acked(SeenKind::Notify, "v2")).notify);
}

#[test]
fn stopped_tip_watermark_gates_on_the_branch_tip() {
    let mut ag = agent("a");
    ag.state = AgentState::Stopped;
    // Seen the current tip oid -> stop acknowledged.
    assert!(!attention(&ag, "ws", &acked(SeenKind::Stopped, "tip-a")).stopped);
    // A stale watermark (old tip) -> re-armed.
    assert!(attention(&ag, "ws", &acked(SeenKind::Stopped, "tip-old")).stopped);
}

#[test]
fn mail_fires_only_on_pending_and_definite_free() {
    // (state, uncertain, pending, expect_mail)
    let cases = [
        (AgentState::Quiescent, false, 2, true),  // Free
        (AgentState::Stopped, false, 1, true),    // Free
        (AgentState::Quiescent, true, 2, false),  // Unknown, not Free
        (AgentState::Stopped, true, 3, false),    // Unknown, not Free
        (AgentState::Live, false, 5, false),      // Held
        (AgentState::InFlight, false, 5, false),  // Held
        (AgentState::Quiescent, false, 0, false), // Free but no mail
    ];
    for (state, uncertain, pending, expect) in cases {
        let mut ag = agent("a");
        ag.state = state;
        ag.state_uncertain = uncertain;
        ag.pending_messages = pending;
        // Abandon any stop so this isolates the mail bit.
        ag.abandoned_oid = Some("x".into());
        assert_eq!(
            attention(&ag, "ws", &nothing).mail,
            expect,
            "{state:?} uncertain={uncertain} pending={pending}"
        );
    }
}

#[test]
fn all_signals_together_list_in_badge_order() {
    let mut ag = agent("a");
    ag.notify_oid = Some("n".into());
    ag.state = AgentState::Stopped;
    ag.budget_oid = Some("b".into());
    ag.conflicted_oid = Some("c".into());
    ag.pending_messages = 1; // Stopped + Free -> mail too
    assert_eq!(
        attention(&ag, "ws", &nothing).kinds(),
        vec![
            AttentionKind::Notify,
            AttentionKind::Stopped,
            AttentionKind::Budget,
            AttentionKind::Conflicted,
            AttentionKind::Mail,
        ]
    );
}

#[test]
fn wires_through_a_real_ui_state() {
    let mut ui = UiState::open(std::path::PathBuf::from("/nonexistent/dir/ui.json"));
    ui.record_seen(SeenKind::Notify, "ws", "a", "oid1");
    let mut ag = agent("a");
    ag.notify_oid = Some("oid1".into());
    let seen = |k: SeenKind, w: &str, a: &str, o: &str| ui.is_seen(k, w, a, o);
    // Acked -> no notify.
    assert!(!attention(&ag, "ws", &seen).notify);
    // A moved ref -> re-armed.
    ag.notify_oid = Some("oid2".into());
    assert!(attention(&ag, "ws", &seen).notify);
}