use colored::Colorize;
use std::sync::atomic::{AtomicBool, Ordering};

/// Output format: human-readable (default) vs. JSON for scripting.
/// Set once at program start by main.rs based on the top-level --json flag.
static JSON_MODE: AtomicBool = AtomicBool::new(false);

/// Switch all subsequent renderers into JSON mode. Idempotent.
pub fn set_json_mode(enabled: bool) {
    JSON_MODE.store(enabled, Ordering::Relaxed);
}

/// Whether the CLI was invoked with --json. List/view subcommands check
/// this and emit raw JSON instead of a table.
pub fn is_json() -> bool {
    JSON_MODE.load(Ordering::Relaxed)
}

/// Pretty-print a serde_json::Value to stdout. Used by list/view
/// subcommands when `--json` is in effect.
pub fn print_json(value: &serde_json::Value) {
    match serde_json::to_string_pretty(value) {
        Ok(s) => println!("{s}"),
        // to_string_pretty only fails on non-string map keys; serde_json::Value
        // can't construct those, so this is unreachable in practice.
        Err(_) => println!("{value}"),
    }
}

/// Print a key-value detail line.
pub fn detail(key: &str, value: &str) {
    println!("{:>14}  {}", key.bold(), value);
}

/// Print a section header.
pub fn header(text: &str) {
    println!("\n{}", text.bold().underline());
}

/// Print a success message.
pub fn success(msg: &str) {
    println!("{} {msg}", "✓".green().bold());
}

/// Print a warning message.
pub fn warn(msg: &str) {
    eprintln!("{} {msg}", "!".yellow().bold());
}

/// Print an error message.
pub fn error(msg: &str) {
    eprintln!("  {} {}", "✗".red().bold(), msg.red());
}

/// Print an info message.
pub fn info(msg: &str) {
    println!("{} {msg}", "·".blue());
}

/// Format a timestamp string for display (truncate to date if full ISO).
pub fn format_time(ts: &str) -> String {
    if ts.len() > 19 {
        ts[..19].replace('T', " ")
    } else {
        ts.to_string()
    }
}

/// Colorize a status string.
pub fn colorize_status(status: &str) -> String {
    match status.to_lowercase().as_str() {
        "open" | "running" | "active" | "online" => status.green().to_string(),
        "closed" | "failed" | "error" | "offline" => status.red().to_string(),
        "merged" | "passed" | "success" => status.magenta().to_string(),
        "pending" | "queued" | "waiting" => status.yellow().to_string(),
        "draft" => status.dimmed().to_string(),
        _ => status.to_string(),
    }
}

/// Print items in a simple table format.
pub fn print_table(headers: &[&str], rows: &[Vec<String>]) {
    if rows.is_empty() {
        println!("  (none)");
        return;
    }

    // Calculate column widths
    let mut widths: Vec<usize> = headers.iter().map(|h| h.len()).collect();
    for row in rows {
        for (i, cell) in row.iter().enumerate() {
            if i < widths.len() {
                widths[i] = widths[i].max(cell.len());
            }
        }
    }

    // Print header
    let header_line: Vec<String> = headers
        .iter()
        .enumerate()
        .map(|(i, h)| format!("{:<width$}", h, width = widths[i]))
        .collect();
    println!("  {}", header_line.join("  ").bold());

    // Print rows
    for row in rows {
        let line: Vec<String> = row
            .iter()
            .enumerate()
            .map(|(i, cell)| {
                let w = widths.get(i).copied().unwrap_or(cell.len());
                format!("{:<width$}", cell, width = w)
            })
            .collect();
        println!("  {}", line.join("  "));
    }
}

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

    /// Note: JSON_MODE is process-global, so these tests run serially via
    /// `set_json_mode(false)` cleanup in each test. They share the same
    /// process under `cargo test`, so explicit reset prevents flakes.
    #[test]
    fn json_mode_off_by_default() {
        // Reset first in case another test left it on.
        set_json_mode(false);
        assert!(!is_json());
    }

    #[test]
    fn set_json_mode_round_trip() {
        set_json_mode(true);
        assert!(is_json());
        set_json_mode(false);
        assert!(!is_json());
    }

    #[test]
    fn print_json_pretty_prints() {
        // We can't easily capture stdout from a library test without
        // restructuring print_json to take a Writer. Instead, smoke-test
        // that it doesn't panic on common shapes — the actual output
        // format is verified end-to-end via the CLI smoke tests.
        let v = serde_json::json!({"foo": "bar", "n": 42, "arr": [1, 2, 3]});
        print_json(&v);
        let v_array = serde_json::json!([1, 2, 3]);
        print_json(&v_array);
        let v_null = serde_json::Value::Null;
        print_json(&v_null);
    }
}