domain-check 1.1.0

//! Display logic for domain-check CLI.
//!
//! This module handles all styled terminal output: colored result lines,
//! grouped batch output (--pretty), spinner animation, progress counters,
//! headers, and summaries. Uses only the `console` crate (already a dependency).
//!
//! Default mode: colored status words, progress counter, spinner, colored summary.
//! Pretty mode: everything above plus grouped layout, column alignment, styled header.

use console::{pad_str, style, Alignment, Term};
use domain_check_lib::{DomainInfo, DomainResult, ForSaleInfo};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;

use crate::Args;

// ── Custom help ─────────────────────────────────────────────────────────────

/// Print a fully custom help screen with ASCII art, compact flags, and examples.
pub fn print_custom_help() {
    // ASCII art banner — cyan bold
    let banner = r#"     _                       _                  _               _
  __| | ___  _ __ ___   __ _(_)_ __         ___| |__   ___  ___| | __
 / _` |/ _ \| '_ ` _ \ / _` | | '_ \ _____ / __| '_ \ / _ \/ __| |/ /
| (_| | (_) | | | | | | (_| | | | | |_____| (__| | | |  __/ (__|   <
 \__,_|\___/|_| |_| |_|\__,_|_|_| |_|      \___|_| |_|\___|\___|_|\_\"#;

    println!("{}", style(banner).cyan().bold());
    println!();
    println!(
        " {} {}",
        style("domain-check").white().bold(),
        style(format!("v{}", env!("CARGO_PKG_VERSION"))).dim(),
    );
    println!(
        " {}",
        style("Check domain availability using RDAP with WHOIS fallback").dim()
    );

    // USAGE
    print_section("USAGE");
    println!(
        "   {} {} {}",
        style("domain-check").cyan().bold(),
        style("[DOMAINS]").white(),
        style("[--flags]").dim()
    );
    println!(
        "   {} {} {}",
        style("domain-check").cyan().bold(),
        style("--file <FILE>").white(),
        style("[--flags]").dim()
    );
    println!(
        "   {} {} {}",
        style("domain-check").cyan().bold(),
        style("--pattern <PATTERN>").white(),
        style("[--flags]").dim()
    );

    // DOMAIN SELECTION
    print_section("DOMAIN SELECTION");
    print_flag(
        "",
        "[DOMAINS]",
        "Domain names to check (base names or FQDNs)",
    );
    print_flag(
        "-t",
        "--tld <TLD>",
        "TLDs to check (comma-separated or multiple -t)",
    );
    print_flag("", "--all", "Check against all known TLDs");
    print_flag("", "--preset <NAME>", "Use a predefined TLD preset");
    print_flag(
        "",
        "--list-presets",
        "List all available TLD presets and exit",
    );
    print_flag(
        "-f",
        "--file <FILE>",
        "Input file with domains (one per line)",
    );

    // DOMAIN GENERATION
    print_section("DOMAIN GENERATION");
    print_flag(
        "",
        "--pattern <PATTERN>",
        "Pattern for name generation (\\w=letter, \\d=digit, ?=either)",
    );
    print_flag(
        "",
        "--prefix <PREFIX>",
        "Prefixes to prepend (comma-separated)",
    );
    print_flag(
        "",
        "--suffix <SUFFIX>",
        "Suffixes to append (comma-separated)",
    );
    print_flag(
        "",
        "--dry-run",
        "Preview generated domains without checking",
    );

    // OUTPUT FORMAT
    print_section("OUTPUT FORMAT");
    print_flag("-j", "--json", "Output results in JSON format");
    print_flag("", "--csv", "Output results in CSV format");
    print_flag("-p", "--pretty", "Grouped output with section headers");
    print_flag("-i", "--info", "Show detailed domain information");
    print_flag(
        "",
        "--only-for-sale",
        "Show only taken domains that are for sale",
    );
    print_flag("", "--batch", "Collect all results before displaying");
    print_flag("", "--streaming", "Show results as they complete");

    // PERFORMANCE
    print_section("PERFORMANCE");
    print_flag(
        "-c",
        "--concurrency <N>",
        "Max concurrent checks (default: 20, max: 100)",
    );
    print_flag("", "--force", "Override the 5000 domain limit");
    print_flag("-y", "--yes", "Skip confirmation prompts");

    // PROTOCOL
    print_section("PROTOCOL");
    print_flag(
        "",
        "--no-bootstrap",
        "Disable IANA bootstrap (hardcoded TLDs only)",
    );
    print_flag("", "--no-whois", "Disable automatic WHOIS fallback");
    print_flag(
        "",
        "--for-sale",
        "Check taken domains for RFC 10023 for-sale records",
    );

    // CONFIGURATION
    print_section("CONFIGURATION");
    print_flag("", "--config <FILE>", "Use specific config file");
    print_flag("-d", "--debug", "Show detailed debug info and errors");
    print_flag("-v", "--verbose", "Verbose logging");

    // GENERAL
    print_section("GENERAL");
    print_flag("-h", "--help", "Show this help message");
    print_flag("-V", "--version", "Show version");

    // EXAMPLES
    print_section("EXAMPLES");
    print_example("domain-check myapp", "Check myapp.com (default TLD)");
    print_example("domain-check myapp -t com,io,dev", "Check specific TLDs");
    print_example(
        "domain-check myapp --preset startup",
        "Use the startup TLD preset",
    );
    print_example(
        "domain-check --pattern \"app\\d\" --dry-run",
        "Preview pattern-generated names",
    );
    print_example(
        "domain-check example.nl --for-sale",
        "Is a taken domain for sale?",
    );

    println!();
}

/// Print a magenta bold section header.
fn print_section(name: &str) {
    println!();
    println!(" {}", style(name).magenta().bold());
}

/// Print a compact flag line with aligned columns.
fn print_flag(short: &str, long: &str, desc: &str) {
    if short.is_empty() {
        // No short flag — 6 chars of padding
        println!("       {:<24} {}", style(long).cyan(), desc);
    } else {
        println!(
            "   {}  {:<24} {}",
            style(short).cyan(),
            style(long).cyan(),
            desc,
        );
    }
}

/// Print an example line with green command and dim description.
fn print_example(cmd: &str, desc: &str) {
    println!(
        "   {} {}",
        style(format!("$ {:<44}", cmd)).green(),
        style(desc).dim(),
    );
}

// ── Spinner ──────────────────────────────────────────────────────────────────

const SPINNER_FRAMES: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];

/// An async braille-dot spinner that writes to stderr so stdout stays clean.
pub struct Spinner {
    running: Arc<AtomicBool>,
    handle: Option<tokio::task::JoinHandle<()>>,
}

impl Spinner {
    /// Start a new spinner with the given message (e.g. "Checking 8 domains...").
    ///
    /// Returns `None` if stderr is not a TTY (piped output, CI, etc.) to avoid
    /// polluting non-interactive streams with escape codes.
    /// Waits 500ms before showing to avoid a flash on fast operations.
    pub fn start(message: String) -> Option<Self> {
        let term = Term::stderr();
        if !term.is_term() {
            return None;
        }

        let running = Arc::new(AtomicBool::new(true));
        let running_clone = running.clone();

        let handle = tokio::spawn(async move {
            let term = Term::stderr();

            // Wait before showing — avoids spinner flash on fast operations
            tokio::time::sleep(Duration::from_millis(500)).await;

            let mut idx = 0usize;
            while running_clone.load(Ordering::Relaxed) {
                let frame = SPINNER_FRAMES[idx % SPINNER_FRAMES.len()];
                let _ = term.clear_line();
                let _ = term.write_str(&format!("{} {}", style(frame).cyan(), message));
                idx += 1;
                tokio::time::sleep(Duration::from_millis(80)).await;
            }
            let _ = term.clear_line();
        });

        Some(Self {
            running,
            handle: Some(handle),
        })
    }

    /// Stop the spinner and clear the line.
    pub async fn stop(self) {
        self.running.store(false, Ordering::Relaxed);
        if let Some(h) = self.handle {
            let _ = h.await;
        }
    }
}

// ── Header ───────────────────────────────────────────────────────────────────

/// Print a styled header at the start of a pretty run.
pub fn print_header(domain_count: usize, concurrency: usize, args: &Args) {
    println!(
        "{} {} {}",
        style("domain-check").bold(),
        style(format!("v{}", env!("CARGO_PKG_VERSION"))).dim(),
        style(format!(
            "— Checking {} domain{}",
            domain_count,
            if domain_count == 1 { "" } else { "s" }
        ))
        .dim(),
    );

    let mut meta_parts: Vec<String> = Vec::new();

    if let Some(preset) = &args.preset {
        meta_parts.push(format!("Preset: {}", preset));
    }
    if args.all_tlds {
        let tld_count = domain_check_lib::get_all_known_tlds().len();
        meta_parts.push(format!("All {} TLDs", tld_count));
    }
    meta_parts.push(format!("Concurrency: {}", concurrency));

    println!("{}", style(meta_parts.join(" | ")).dim());
    println!();
}

// ── Single result line ───────────────────────────────────────────────────────

/// Format and print a single domain result with colors and alignment.
///
/// If `counter` is Some((current, total)), a progress prefix like `[3/8]` is shown.
pub fn print_result(
    result: &DomainResult,
    show_info: bool,
    debug: bool,
    counter: Option<(usize, usize)>,
) {
    let domain_width = 30;
    let padded_domain = pad_str(&result.domain, domain_width, Alignment::Left, Some(".."));

    let prefix = match counter {
        Some((cur, total)) => {
            format!("{} ", style(format!("[{}/{}]", cur, total)).dim())
        }
        None => String::new(),
    };

    match result.available {
        Some(true) => {
            println!(
                "  {}{}  {}",
                prefix,
                style(&padded_domain).white(),
                style("AVAILABLE").green().bold(),
            );
        }
        Some(false) => {
            let info_str = if show_info {
                result
                    .info
                    .as_ref()
                    .map(|i| format!("  {}", style(format_domain_info(i)).dim()))
                    .unwrap_or_default()
            } else {
                String::new()
            };
            println!(
                "  {}{}  {}{}{}",
                prefix,
                style(&padded_domain).white(),
                style("TAKEN").red().bold(),
                info_str,
                for_sale_suffix(result),
            );
            print_for_sale_details(result, show_info, "    ");
        }
        None => {
            let reason = brief_error(result);
            println!(
                "  {}{}  {}  {}",
                prefix,
                style(&padded_domain).white(),
                style("UNKNOWN").yellow(),
                style(reason).dim(),
            );
        }
    }

    if debug {
        if let Some(duration) = result.check_duration {
            println!(
                "    {} Checked in {}ms via {}",
                style("└─").dim(),
                duration.as_millis(),
                result.method_used,
            );
        }
    }
}

// ── Default result line (colored, flat) ───────────────────────────────────────

/// Print a single domain result with colored status words but flat layout.
/// No padding or column alignment — just `domain STATUS` with color.
///
/// If `counter` is Some((current, total)), a progress prefix like `[3/8]` is shown.
pub fn print_result_default(
    result: &DomainResult,
    show_info: bool,
    debug: bool,
    counter: Option<(usize, usize)>,
) {
    let prefix = match counter {
        Some((cur, total)) => format!("{} ", style(format!("[{}/{}]", cur, total)).dim()),
        None => String::new(),
    };

    match result.available {
        Some(true) => {
            println!(
                "{}{} {}",
                prefix,
                result.domain,
                style("AVAILABLE").green().bold(),
            );
        }
        Some(false) => {
            let info_str = if show_info {
                result
                    .info
                    .as_ref()
                    .map(|i| format!(" ({})", style(format_domain_info(i)).dim()))
                    .unwrap_or_default()
            } else {
                String::new()
            };
            println!(
                "{}{} {}{}{}",
                prefix,
                result.domain,
                style("TAKEN").red().bold(),
                info_str,
                for_sale_suffix(result),
            );
            print_for_sale_details(result, show_info, "    ");
        }
        None => {
            let reason = brief_error(result);
            println!(
                "{}{} {} {}",
                prefix,
                result.domain,
                style("UNKNOWN").yellow(),
                style(reason).dim(),
            );
        }
    }

    if debug {
        if let Some(duration) = result.check_duration {
            println!(
                "    {} Checked in {}ms via {}",
                style("└─").dim(),
                duration.as_millis(),
                result.method_used,
            );
        }
    }
}

// ── Grouped batch output (Issue #17 core) ────────────────────────────────────

/// Print results grouped by status: Available, Taken, Unknown.
/// Empty sections are omitted entirely.
pub fn print_grouped_results(results: &[DomainResult], show_info: bool, debug: bool) {
    let mut available: Vec<&DomainResult> = Vec::new();
    let mut taken: Vec<&DomainResult> = Vec::new();
    let mut unknown: Vec<&DomainResult> = Vec::new();

    for r in results {
        match r.available {
            Some(true) => available.push(r),
            Some(false) => taken.push(r),
            None => unknown.push(r),
        }
    }

    if !available.is_empty() {
        println!(
            "  {} {}",
            style(format!("── Available ({}) ", available.len()))
                .green()
                .bold(),
            style("─".repeat(40)).green().dim(),
        );
        for r in &available {
            print_grouped_line(r, show_info, debug);
        }
        println!();
    }

    if !taken.is_empty() {
        println!(
            "  {} {}",
            style(format!("── Taken ({}) ", taken.len())).red().bold(),
            style("─".repeat(44)).red().dim(),
        );
        for r in &taken {
            print_grouped_line(r, show_info, debug);
        }
        println!();
    }

    if !unknown.is_empty() {
        println!(
            "  {} {}",
            style(format!("── Unknown ({}) ", unknown.len()))
                .yellow()
                .bold(),
            style("─".repeat(40)).yellow().dim(),
        );
        for r in &unknown {
            print_grouped_line(r, show_info, debug);
        }
        println!();
    }
}

/// Print a single line inside a grouped section.
fn print_grouped_line(result: &DomainResult, show_info: bool, debug: bool) {
    let domain_width = 30;
    let padded = pad_str(&result.domain, domain_width, Alignment::Left, Some(".."));

    match result.available {
        Some(true) => {
            println!("    {}", style(&padded).white());
        }
        Some(false) => {
            let info_str = if show_info {
                result
                    .info
                    .as_ref()
                    .map(|i| format!("  {}", style(format_domain_info(i)).dim()))
                    .unwrap_or_default()
            } else {
                String::new()
            };
            println!(
                "    {}{}{}",
                style(&padded).white(),
                info_str,
                for_sale_suffix(result)
            );
            print_for_sale_details(result, show_info, "      ");
        }
        None => {
            let reason = brief_error(result);
            println!("    {}  {}", style(&padded).white(), style(reason).dim());
        }
    }

    if debug {
        if let Some(duration) = result.check_duration {
            println!(
                "      {} Checked in {}ms via {}",
                style("└─").dim(),
                duration.as_millis(),
                result.method_used,
            );
        }
    }
}

// ── Summary ──────────────────────────────────────────────────────────────────

/// Print the final summary bar with colored counts.
pub fn print_summary(
    total: usize,
    available: usize,
    taken: usize,
    unknown: usize,
    for_sale: Option<usize>,
    duration: Duration,
) {
    println!(
        "  {}",
        style("────────────────────────────────────────────────────").dim()
    );
    let for_sale_part = for_sale
        .map(|n| {
            format!(
                "  {}  {}",
                style("|").dim(),
                style(format!("{} for sale", n)).yellow()
            )
        })
        .unwrap_or_default();
    println!(
        "  {} domain{} in {:.1}s  {}  {}  {}  {}  {}  {}{}",
        style(total).bold(),
        if total == 1 { "" } else { "s" },
        duration.as_secs_f64(),
        style("|").dim(),
        style(format!("{} available", available)).green(),
        style("|").dim(),
        style(format!("{} taken", taken)).red(),
        style("|").dim(),
        style(format!("{} unknown", unknown)).yellow(),
        for_sale_part,
    );
}

// ── Helpers ──────────────────────────────────────────────────────────────────

/// Format domain info (registrar, dates) into a concise string.
pub fn format_domain_info(info: &DomainInfo) -> String {
    let mut parts = Vec::new();
    if let Some(registrar) = &info.registrar {
        parts.push(format!("Registrar: {}", registrar));
    }
    if let Some(created) = &info.creation_date {
        parts.push(format!("Created: {}", created));
    }
    if let Some(expires) = &info.expiration_date {
        parts.push(format!("Expires: {}", expires));
    }
    if parts.is_empty() {
        "No info available".to_string()
    } else {
        parts.join(", ")
    }
}

/// One-line for-sale summary: first price and first trusted contact URI.
pub fn format_for_sale_brief(info: &ForSaleInfo) -> String {
    let mut parts = Vec::new();
    if let Some(price) = info.prices.first() {
        parts.push(price.to_string());
    }
    if let Some(uri) = info.first_trusted_uri() {
        parts.push(uri.value.clone());
    }
    if parts.is_empty() {
        "for sale".to_string()
    } else {
        format!("for sale: {}", parts.join(" · "))
    }
}

/// Every for-sale detail, one per line, for --info.
pub fn format_for_sale_details(info: &ForSaleInfo) -> Vec<String> {
    let mut lines = Vec::new();
    for price in &info.prices {
        lines.push(format!("Price: {} (indicative only)", price));
    }
    for uri in &info.uris {
        if uri.trusted {
            lines.push(format!("Contact: {}", uri.value));
        } else {
            lines.push(format!("Contact: {} [unverified scheme]", uri.value));
        }
    }
    for text in &info.texts {
        lines.push(format!("Note: {}", text));
    }
    for code in &info.codes {
        lines.push(format!("Code: {}", code));
    }
    lines
}

/// Styled " (for sale: …)" suffix for a taken result, or empty.
fn for_sale_suffix(result: &DomainResult) -> String {
    result
        .for_sale
        .as_ref()
        .map(|fs| {
            format!(
                " {}",
                style(format!("({})", format_for_sale_brief(fs))).yellow()
            )
        })
        .unwrap_or_default()
}

/// With --info, print every for-sale detail under the result line.
fn print_for_sale_details(result: &DomainResult, show_info: bool, indent: &str) {
    if !show_info {
        return;
    }
    if let Some(fs) = &result.for_sale {
        for line in format_for_sale_details(fs) {
            println!("{}{} {}", indent, style("└─").dim(), style(line).dim());
        }
    }
}

/// Extract a brief error reason from a DomainResult with unknown status.
fn brief_error(result: &DomainResult) -> &str {
    match &result.error_message {
        Some(msg) => {
            let m = msg.to_lowercase();
            if m.contains("timeout") || m.contains("timed out") {
                "(timeout)"
            } else if m.contains("network") || m.contains("dns") || m.contains("connect") {
                "(network error)"
            } else if m.contains("parse") || m.contains("json") {
                "(parsing error)"
            } else if m.contains("unknown") || m.contains("tld") || m.contains("bootstrap") {
                "(unknown TLD)"
            } else {
                "(error)"
            }
        }
        None => "(unknown status)",
    }
}

// ── Tests ────────────────────────────────────────────────────────────────────

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

    fn make_result(domain: &str, available: Option<bool>) -> DomainResult {
        DomainResult {
            domain: domain.to_string(),
            available,
            info: None,
            check_duration: None,
            method_used: CheckMethod::Rdap,
            error_message: if available.is_none() {
                Some("timeout".to_string())
            } else {
                None
            },
            for_sale: None,
        }
    }

    fn make_result_with_error(error: &str) -> DomainResult {
        DomainResult {
            domain: "test.com".to_string(),
            available: None,
            info: None,
            check_duration: None,
            method_used: CheckMethod::Unknown,
            error_message: Some(error.to_string()),
            for_sale: None,
        }
    }

    // ── brief_error ─────────────────────────────────────────────────────

    #[test]
    fn test_brief_error_timeout() {
        let r = make_result("a.com", None);
        assert_eq!(brief_error(&r), "(timeout)");
    }

    #[test]
    fn test_brief_error_timed_out() {
        let r = make_result_with_error("request timed out after 5s");
        assert_eq!(brief_error(&r), "(timeout)");
    }

    #[test]
    fn test_brief_error_network() {
        let r = make_result_with_error("dns lookup failed");
        assert_eq!(brief_error(&r), "(network error)");
    }

    #[test]
    fn test_brief_error_connect() {
        let r = make_result_with_error("failed to connect to server");
        assert_eq!(brief_error(&r), "(network error)");
    }

    #[test]
    fn test_brief_error_parsing() {
        let r = make_result_with_error("failed to parse json response");
        assert_eq!(brief_error(&r), "(parsing error)");
    }

    #[test]
    fn test_brief_error_json() {
        let r = make_result_with_error("invalid JSON in response");
        assert_eq!(brief_error(&r), "(parsing error)");
    }

    #[test]
    fn test_brief_error_unknown_tld() {
        let r = make_result_with_error("unknown TLD .xyz123");
        assert_eq!(brief_error(&r), "(unknown TLD)");
    }

    #[test]
    fn test_brief_error_bootstrap() {
        let r = make_result_with_error("bootstrap registry failed");
        assert_eq!(brief_error(&r), "(unknown TLD)");
    }

    #[test]
    fn test_brief_error_generic() {
        let r = make_result_with_error("something unexpected happened");
        assert_eq!(brief_error(&r), "(error)");
    }

    #[test]
    fn test_brief_error_no_message() {
        let r = DomainResult {
            error_message: None,
            ..make_result("a.com", None)
        };
        assert_eq!(brief_error(&r), "(unknown status)");
    }

    #[test]
    fn test_brief_error_case_insensitive() {
        let r = make_result_with_error("TIMEOUT occurred");
        assert_eq!(brief_error(&r), "(timeout)");
    }

    // ── format_domain_info ──────────────────────────────────────────────

    #[test]
    fn test_format_domain_info_all_fields() {
        let info = DomainInfo {
            registrar: Some("GoDaddy".to_string()),
            creation_date: Some("2020-01-01".to_string()),
            expiration_date: Some("2025-01-01".to_string()),
            ..Default::default()
        };
        let formatted = format_domain_info(&info);
        assert!(formatted.contains("Registrar: GoDaddy"));
        assert!(formatted.contains("Created: 2020-01-01"));
        assert!(formatted.contains("Expires: 2025-01-01"));
    }

    #[test]
    fn test_format_domain_info_empty() {
        let info = DomainInfo::default();
        assert_eq!(format_domain_info(&info), "No info available");
    }

    #[test]
    fn test_format_domain_info_registrar_only() {
        let info = DomainInfo {
            registrar: Some("Namecheap".to_string()),
            ..Default::default()
        };
        assert_eq!(format_domain_info(&info), "Registrar: Namecheap");
    }

    #[test]
    fn test_format_domain_info_dates_only() {
        let info = DomainInfo {
            creation_date: Some("2020-01-01".to_string()),
            expiration_date: Some("2025-01-01".to_string()),
            ..Default::default()
        };
        let formatted = format_domain_info(&info);
        assert!(formatted.contains("Created: 2020-01-01"));
        assert!(formatted.contains("Expires: 2025-01-01"));
        assert!(!formatted.contains("Registrar"));
    }

    #[test]
    fn test_format_domain_info_comma_separated() {
        let info = DomainInfo {
            registrar: Some("Reg".to_string()),
            creation_date: Some("2020".to_string()),
            ..Default::default()
        };
        let formatted = format_domain_info(&info);
        assert!(formatted.contains(", "));
    }

    fn fs(records: &[&str]) -> domain_check_lib::ForSaleInfo {
        let rs: Vec<Vec<Vec<u8>>> = records
            .iter()
            .map(|r| vec![r.as_bytes().to_vec()])
            .collect();
        domain_check_lib::parse_txt_records(&rs).unwrap()
    }

    #[test]
    fn brief_with_price_and_uri() {
        let info = fs(&[
            "v=FORSALE1;fval=EUR999",
            "v=FORSALE1;furi=https://x.example/buy",
        ]);
        assert_eq!(
            format_for_sale_brief(&info),
            "for sale: EUR 999 · https://x.example/buy"
        );
    }

    #[test]
    fn brief_without_content() {
        assert_eq!(format_for_sale_brief(&fs(&["v=FORSALE1;"])), "for sale");
    }

    #[test]
    fn brief_skips_untrusted_uri() {
        let info = fs(&["v=FORSALE1;furi=ftp://x.example/"]);
        assert_eq!(format_for_sale_brief(&info), "for sale");
    }

    #[test]
    fn brief_suffix_never_contains_escape() {
        let info = fs(&[
            "v=FORSALE1;ftxt=\u{1b}[2J\u{202E}evil",
            "v=FORSALE1;fval=EUR1",
        ]);
        let all = format!(
            "{}{}",
            format_for_sale_brief(&info),
            format_for_sale_details(&info).join("")
        );
        assert!(!all.contains('\u{1b}'));
        assert!(!all.contains('\u{202E}'));
    }

    #[test]
    fn details_list_everything_with_labels() {
        let info = fs(&[
            "v=FORSALE1;fval=EUR5",
            "v=FORSALE1;furi=https://a.example",
            "v=FORSALE1;furi=ftp://b.example",
            "v=FORSALE1;ftxt=hello",
            "v=FORSALE1;fcod=XX-1",
        ]);
        let d = format_for_sale_details(&info);
        assert!(d.contains(&"Price: EUR 5 (indicative only)".to_string()));
        assert!(d.contains(&"Contact: https://a.example".to_string()));
        assert!(d.contains(&"Contact: ftp://b.example [unverified scheme]".to_string()));
        assert!(d.contains(&"Note: hello".to_string()));
        assert!(d.contains(&"Code: XX-1".to_string()));
    }
}