/*
Minimalist terminal output. Color via owo-colors, off when piped, NO_COLOR, or --no-color.
*/

use owo_colors::OwoColorize;
use std::io::{IsTerminal, Write};
use std::path::Path;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use std::time::Duration;

static PLAIN: AtomicBool = AtomicBool::new(false);

/// Decide coloring once at startup.
pub fn init(no_color_flag: bool) {
    let off = no_color_flag || std::env::var_os("NO_COLOR").is_some() || !std::io::stdout().is_terminal();
    PLAIN.store(off, Ordering::Relaxed);
}

fn plain() -> bool {
    PLAIN.load(Ordering::Relaxed)
}

/// A `+ name   kind` line for an added package.
pub fn added(name: &str, kind: &str) {
    if plain() {
        println!("  + {name:<10} {kind}");
    } else {
        println!("  {} {name:<10} {}", "+".green(), kind.dimmed());
    }
}

/// A `- name` line for a removed package.
pub fn removed(name: &str) {
    if plain() {
        println!("  - {name}");
    } else {
        println!("  {} {name}", "-".red());
    }
}

/// A blank line then a dim trailing note.
pub fn note(msg: &str) {
    println!();
    if plain() {
        println!("  {msg}");
    } else {
        println!("  {}", msg.dimmed());
    }
}

/// The created-files tree printed by `edge init`.
pub fn scaffolded(dir: &str, items: &[&str], next: &str) {
    let label = if dir == "." { "project" } else { dir };
    println!("  created {label}/");
    for (i, item) in items.iter().enumerate() {
        let branch = if i + 1 == items.len() { "└─" } else { "├─" };
        println!("    {branch} {item}");
    }
    note(next);
}

/// The `edge serve` banner.
pub fn serve_banner(port: u16, dir: &Path) {
    let url = format!("http://localhost:{port}");
    let path = dir.display().to_string();
    if plain() {
        println!("  {url}");
        println!("  watching {path}");
    } else {
        println!("  {}", url.cyan());
        println!("  {} {}", "watching".dimmed(), path.dimmed());
    }
}

/// Print a script's traceback to stderr, verbatim from the runtime.
pub fn traceback(msg: &str) {
    eprintln!("{msg}");
}

/// Summary printed by `edge build` after vendoring runtime + packages + scripts into dist/.
pub fn build_report(dir: &std::path::Path, runtime_files: usize, packages: usize, scripts: usize, size: u64, elapsed: std::time::Duration) {
    println!();
    if plain() {
        println!("  bundled to {}/", dir.display());
    } else {
        println!("  bundled to {}/", dir.display().to_string().cyan());
    }
    println!();
    println!("  {runtime_files} runtime files + compiler.wasm");
    println!("  {packages} packages");
    println!("  {scripts} scripts");
    println!();
    println!("  {:.2} MB · {:.1}s", size as f64 / 1_000_000.0, elapsed.as_secs_f64());
}

/// Render an error to stderr. `{:#}` joins the cause chain so the root reason isn't swallowed.
pub fn error(e: &anyhow::Error) {
    if plain() {
        eprintln!("error: {e:#}");
    } else {
        eprintln!("{} {e:#}", "error:".red());
    }
}

// Braille frames used by the spinner; match the rest of the UI's unicode style.
const SPIN_FRAMES: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];

/// Animated stderr spinner for long operations. Falls back to a static line in plain/non-TTY mode.
pub struct Spinner {
    stop: Arc<AtomicBool>,
    handle: Option<thread::JoinHandle<()>>,
}

/// Start a spinner with `label`. Drop it (or call `done`) to stop.
pub fn spinner(label: &str) -> Spinner {
    let stop = Arc::new(AtomicBool::new(false));
    // No animation when colors are off or stderr is redirected; just announce the step.
    if plain() || !std::io::stderr().is_terminal() {
        eprintln!("  {label}...");
        return Spinner { stop, handle: None };
    }
    let stop_thread = stop.clone();
    let label = label.to_string();
    let handle = thread::spawn(move || {
        let mut i = 0usize;
        while !stop_thread.load(Ordering::Relaxed) {
            let frame = SPIN_FRAMES[i % SPIN_FRAMES.len()];
            eprint!("\r  {} {}", frame, label.dimmed());
            let _ = std::io::stderr().flush();
            thread::sleep(Duration::from_millis(120));
            i += 1;
        }
        // ANSI: carriage return + erase-to-end-of-line so the next print starts clean.
        eprint!("\r\x1b[2K");
        let _ = std::io::stderr().flush();
    });
    Spinner { stop, handle: Some(handle) }
}

impl Spinner {
    /// Stop the spinner and print a `(successful) {msg}` line in green.
    pub fn done(self, msg: &str) {
        // Drop stops the thread and clears the line; the result line goes right after.
        drop(self);
        if plain() {
            eprintln!("  (successful) {msg}");
        } else {
            eprintln!("  {} {msg}", "(successful)".green());
        }
    }

    /// Stop the spinner and print an `(unsuccessful) {msg}` line in red.
    pub fn fail(self, msg: &str) {
        drop(self);
        if plain() {
            eprintln!("  (unsuccessful) {msg}");
        } else {
            eprintln!("  {} {msg}", "(unsuccessful)".red());
        }
    }
}

impl Drop for Spinner {
    fn drop(&mut self) {
        self.stop.store(true, Ordering::Relaxed);
        if let Some(h) = self.handle.take() {
            let _ = h.join();
        }
    }
}