seer-cli 0.56.0

//! Overview lens — merged registration summary from the smart lookup.
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use seer_core::output::sanitize_line;

use seer_core::output::{availability_label, Emphasis};
use seer_core::LookupResult;

use crate::tui::action::LensData;
use crate::tui::theme::Theme;
use crate::tui::widgets::or_dash;
use crate::tui::widgets::page::{Block, Page};

pub fn page(theme: &Theme, data: &LensData) -> Option<Page> {
    let LensData::Overview(result) = data else {
        return None;
    };

    // Mirror the core human formatter: `Available` is a fallback variant
    // carrying a graded verdict, not proof of availability — a dns_present
    // result is a REGISTERED domain (the issue-#45 inversion bug class).
    let source = match result.as_ref() {
        LookupResult::Rdap { .. } => ("RDAP", theme.mauve),
        LookupResult::Whois { .. } => ("WHOIS", theme.peach),
        LookupResult::Available { data, .. } => {
            let (label, emphasis) = availability_label(data.verdict());
            let color = match emphasis {
                Emphasis::Good => theme.green,
                Emphasis::Neutral => theme.text,
                Emphasis::Caution => theme.yellow,
                Emphasis::Bad => theme.red,
            };
            (label, color)
        }
    };
    let headline = Line::from(vec![
        Span::styled(
            sanitize_line(&result.domain_name().unwrap_or_default()),
            Style::default().fg(theme.text).add_modifier(Modifier::BOLD),
        ),
        Span::raw("  "),
        Span::styled(
            source.0,
            Style::default().fg(source.1).add_modifier(Modifier::BOLD),
        ),
    ]);

    let (expiry, registrar) = result.expiration_info();
    // The header chip shows the verdict for Available results; the source row
    // names where that verdict came from instead of repeating it.
    let source_row = match result.as_ref() {
        LookupResult::Available { .. } => "availability check".to_string(),
        _ => source.0.to_string(),
    };
    let mut rows = vec![
        ("registrar", or_dash(registrar)),
        ("organization", or_dash(result.organization())),
        ("expires", or_dash(expiry.map(|d| d.date_naive()))),
        ("source", source_row),
    ];
    if let LookupResult::Available { data, .. } = result.as_ref() {
        rows.push(("method", data.method.clone()));
        rows.push(("confidence", data.confidence.clone()));
    }
    Some(
        Page::new("Overview", theme.blue)
            .push(Block::Lines(vec![headline]))
            .push(Block::Gap)
            .push(Block::Panel(Page::new("Registration", theme.blue).push(
                Block::Kv {
                    key_color: theme.blue,
                    rows,
                },
            ))),
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::tui::widgets::page;

    /// Draw this lens's page as the TUI does.
    fn render(f: &mut ratatui::Frame, area: ratatui::layout::Rect, theme: &Theme, data: &LensData) {
        if let Some(p) = page(theme, data) {
            page::draw(f, area, theme, p, false);
        }
    }
    use crate::tui::test_util::render_lines;
    use seer_core::AvailabilityResult;

    fn avail_data(available: bool, confidence: &str, method: &str) -> LensData {
        LensData::Overview(Box::new(LookupResult::Available {
            data: Box::new(AvailabilityResult {
                domain: "example.com".into(),
                available,
                confidence: confidence.into(),
                method: method.into(),
                details: None,
            }),
            rdap_error: "connect timeout".into(),
            whois_error: "connect timeout".into(),
            whois_data: None,
        }))
    }

    fn render_to_text(data: &LensData) -> String {
        let theme = Theme::frappe();
        render_lines(70, 14, |f| render(f, f.area(), &theme, data))
    }

    #[test]
    fn dns_present_registered_renders_registered_not_available() {
        // PR #118: both transports failed but DNS proved registration —
        // (available: false, confidence: high) must never read as AVAILABLE.
        let text = render_to_text(&avail_data(false, "high", "dns_present"));
        assert!(text.contains("REGISTERED"), "got: {text}");
        assert!(
            !text.contains("AVAILABLE"),
            "registered domain must not render as AVAILABLE: {text}",
        );
    }

    #[test]
    fn confirmed_available_verdict_renders_available() {
        let text = render_to_text(&avail_data(true, "high", "rdap_404"));
        assert!(text.contains("AVAILABLE"), "got: {text}");
        assert!(!text.contains("MAY BE"), "got: {text}");
        assert!(!text.contains("REGISTERED"), "got: {text}");
    }

    #[test]
    fn inconclusive_verdict_renders_unknown() {
        let text = render_to_text(&avail_data(false, "low", "all_methods_failed"));
        assert!(text.contains("UNKNOWN"), "got: {text}");
        assert!(!text.contains("AVAILABLE"), "got: {text}");
    }
}