print-break 0.1.0

//! # print-break
//!
//! A simple debugging macro that pretty-prints variables and pauses execution.
//! No debugger needed - just prints to stderr and waits for Enter.
//!
//! ## Features
//!
//! - Pretty-prints any `Debug` type
//! - Auto-detects and formats JSON, TOML, YAML strings
//! - Shows file:line location
//! - Pauses execution until you press Enter
//! - **Compiles to nothing in release builds**
//! - **Disable at runtime with `PRINT_BREAK=0`**
//! - **Interactive: Enter=continue, q=quit, s=skip remaining**
//!
//! ## Usage
//!
//! ```rust,no_run
//! use print_break::print_break;
//!
//! let x = 42;
//! let name = "ferris";
//! let json = r#"{"user": "alice", "id": 123}"#;
//!
//! print_break!(x, name, json);
//! ```
//!
//! ## Environment Variables
//!
//! - `PRINT_BREAK=0` - Disable all breakpoints
//! - `PRINT_BREAK=1` - Enable breakpoints (default)
//!
//! ## Interactive Controls
//!
//! When paused at a breakpoint:
//! - **Enter** - Continue to next breakpoint
//! - **q** - Quit the program immediately
//! - **s** - Skip all remaining breakpoints

use std::fmt::Debug;
use std::io::IsTerminal;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

/// Global flag to skip all remaining breakpoints
static SKIP_ALL: AtomicBool = AtomicBool::new(false);

/// Global breakpoint counter
static BREAK_COUNT: AtomicUsize = AtomicUsize::new(0);

/// Maximum lines to show before truncating
const MAX_LINES: usize = 50;

/// Check if print-break is enabled via environment variable
#[doc(hidden)]
pub fn is_enabled() -> bool {
    if SKIP_ALL.load(Ordering::Relaxed) {
        return false;
    }
    match std::env::var("PRINT_BREAK") {
        Ok(val) => !matches!(val.as_str(), "0" | "false" | "no" | "off"),
        Err(_) => true, // Enabled by default
    }
}

/// Check if we're running in a TTY (interactive terminal)
#[doc(hidden)]
pub fn is_tty() -> bool {
    std::io::stderr().is_terminal() && std::io::stdin().is_terminal()
}

/// Get and increment breakpoint counter
#[doc(hidden)]
pub fn next_break_id() -> usize {
    BREAK_COUNT.fetch_add(1, Ordering::Relaxed) + 1
}

/// Color code wrapper - returns empty string if not TTY
#[doc(hidden)]
pub fn color(code: &str) -> &str {
    if is_tty() { code } else { "" }
}

/// Reset color code - returns empty string if not TTY
#[doc(hidden)]
pub fn reset() -> &'static str {
    if is_tty() { "\x1b[0m" } else { "" }
}

/// Set the skip-all flag
#[doc(hidden)]
pub fn set_skip_all(skip: bool) {
    SKIP_ALL.store(skip, Ordering::Relaxed);
}

/// Attempts to format a value as pretty JSON/TOML/YAML if it's a config string.
/// Falls back to Debug formatting otherwise.
/// Truncates output if it exceeds MAX_LINES.
#[doc(hidden)]
pub fn format_value<T: Debug>(value: &T) -> String {
    let debug_str = format!("{:?}", value);
    let raw_output;

    // Check if it's a string
    if let Some(inner) = debug_str.strip_prefix('"').and_then(|s| s.strip_suffix('"')) {
        // Unescape the string
        let unescaped = inner
            .replace("\\\"", "\"")
            .replace("\\n", "\n")
            .replace("\\t", "\t")
            .replace("\\\\", "\\");

        let trimmed = unescaped.trim();

        // Try JSON first (most specific - must start with { or [)
        if trimmed.starts_with('{') || trimmed.starts_with('[') {
            if let Ok(json) = serde_json::from_str::<serde_json::Value>(&unescaped) {
                if let Ok(pretty) = serde_json::to_string_pretty(&json) {
                    raw_output = format!("\x1b[90m(json)\x1b[0m\n{}", pretty);
                    return truncate_output(&raw_output);
                }
            }
        }

        // Try TOML (look for key = value or [section] patterns)
        if trimmed.contains(" = ") || trimmed.contains("]\n") || trimmed.starts_with('[') {
            if let Ok(toml_val) = toml::from_str::<toml::Value>(&unescaped) {
                if let Ok(pretty) = toml::to_string_pretty(&toml_val) {
                    raw_output = format!("\x1b[90m(toml)\x1b[0m\n{}", pretty);
                    return truncate_output(&raw_output);
                }
            }
        }

        // Try YAML (look for key: value patterns, but not just any colon)
        if trimmed.contains(": ") || trimmed.contains(":\n") {
            if let Ok(yaml_val) = serde_yaml::from_str::<serde_yaml::Value>(&unescaped) {
                // Only use YAML if it parsed into something structured (not just a string)
                if yaml_val.is_mapping() || yaml_val.is_sequence() {
                    if let Ok(pretty) = serde_yaml::to_string(&yaml_val) {
                        raw_output = format!("\x1b[90m(yaml)\x1b[0m\n{}", pretty.trim());
                        return truncate_output(&raw_output);
                    }
                }
            }
        }

        // For plain text strings, show with newlines and word wrap
        raw_output = format!("\x1b[90m(string, {} chars)\x1b[0m\n{}", unescaped.len(), word_wrap(&unescaped, 80));
        return truncate_output(&raw_output);
    }

    // Fall back to pretty Debug format
    raw_output = format!("{:#?}", value);
    truncate_output(&raw_output)
}

/// Format value without truncation (for "more" output)
#[doc(hidden)]
pub fn format_value_full<T: Debug>(value: &T) -> String {
    let debug_str = format!("{:?}", value);

    // Check if it's a string
    if let Some(inner) = debug_str.strip_prefix('"').and_then(|s| s.strip_suffix('"')) {
        // Unescape the string
        let unescaped = inner
            .replace("\\\"", "\"")
            .replace("\\n", "\n")
            .replace("\\t", "\t")
            .replace("\\\\", "\\");

        let trimmed = unescaped.trim();

        // Try JSON
        if trimmed.starts_with('{') || trimmed.starts_with('[') {
            if let Ok(json) = serde_json::from_str::<serde_json::Value>(&unescaped) {
                if let Ok(pretty) = serde_json::to_string_pretty(&json) {
                    return pretty;
                }
            }
        }

        // Try TOML
        if trimmed.contains(" = ") || trimmed.contains("]\n") || trimmed.starts_with('[') {
            if let Ok(toml_val) = toml::from_str::<toml::Value>(&unescaped) {
                if let Ok(pretty) = toml::to_string_pretty(&toml_val) {
                    return pretty;
                }
            }
        }

        // Try YAML
        if trimmed.contains(": ") || trimmed.contains(":\n") {
            if let Ok(yaml_val) = serde_yaml::from_str::<serde_yaml::Value>(&unescaped) {
                if yaml_val.is_mapping() || yaml_val.is_sequence() {
                    if let Ok(pretty) = serde_yaml::to_string(&yaml_val) {
                        return pretty.trim().to_string();
                    }
                }
            }
        }

        // Plain text with word wrap
        return word_wrap(&unescaped, 100);
    }

    format!("{:#?}", value)
}

/// Word wrap text at specified width
fn word_wrap(s: &str, width: usize) -> String {
    let mut result = String::new();
    for line in s.lines() {
        if line.len() <= width {
            result.push_str(line);
            result.push('\n');
        } else {
            let mut current_line = String::new();
            for word in line.split_whitespace() {
                if current_line.is_empty() {
                    current_line = word.to_string();
                } else if current_line.len() + 1 + word.len() <= width {
                    current_line.push(' ');
                    current_line.push_str(word);
                } else {
                    result.push_str(&current_line);
                    result.push('\n');
                    current_line = word.to_string();
                }
            }
            if !current_line.is_empty() {
                result.push_str(&current_line);
                result.push('\n');
            }
        }
    }
    result.trim_end().to_string()
}

/// Truncate output if it exceeds MAX_LINES
fn truncate_output(s: &str) -> String {
    let lines: Vec<&str> = s.lines().collect();
    if lines.len() > MAX_LINES {
        let mut result: Vec<&str> = lines[..MAX_LINES].to_vec();
        result.push(&format!("\x1b[90m... ({} more lines)\x1b[0m", lines.len() - MAX_LINES));
        // Can't use format! in const context, so we do this differently
        let truncated: String = lines[..MAX_LINES].join("\n");
        format!("{}\n\x1b[90m... ({} more lines)\x1b[0m", truncated, lines.len() - MAX_LINES)
    } else {
        s.to_string()
    }
}

/// Stored full output for "show more" functionality
static LAST_FULL_OUTPUT: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);

/// Store full output for potential "show more"
#[doc(hidden)]
pub fn store_full_output(output: String) {
    if let Ok(mut guard) = LAST_FULL_OUTPUT.lock() {
        *guard = Some(output);
    }
}

/// Handle user input at breakpoint. Returns true if should continue, false if should quit.
#[doc(hidden)]
pub fn handle_input() -> bool {
    use std::io::{self, BufRead, Write};

    // If not a TTY, don't pause - just continue (for CI/piped output)
    if !is_tty() {
        eprintln!("(non-interactive mode, continuing...)");
        return true;
    }

    loop {
        eprint!("\x1b[90m[Enter=continue, m=more, s=skip all, q=quit]\x1b[0m ");
        io::stderr().flush().unwrap();

        let stdin = io::stdin();
        let mut line = String::new();
        if stdin.lock().read_line(&mut line).is_ok() {
            let input = line.trim().to_lowercase();
            match input.as_str() {
                "q" | "quit" => {
                    eprintln!("\x1b[1;31mQuitting...\x1b[0m");
                    std::process::exit(0);
                }
                "s" | "skip" => {
                    eprintln!("\x1b[1;33mSkipping remaining breakpoints...\x1b[0m");
                    set_skip_all(true);
                    break;
                }
                "m" | "more" => {
                    // Show full output
                    if let Ok(guard) = LAST_FULL_OUTPUT.lock() {
                        if let Some(ref full) = *guard {
                            eprintln!("\n\x1b[1;33m─── Full Output ───\x1b[0m");
                            for line in full.lines() {
                                eprintln!("\x1b[37m{}\x1b[0m", line);
                            }
                            eprintln!("\x1b[1;33m───────────────────\x1b[0m\n");
                        } else {
                            eprintln!("\x1b[90m(no truncated output to show)\x1b[0m");
                        }
                    }
                    continue; // Ask for input again
                }
                _ => break // Continue
            }
        } else {
            break;
        }
    }
    eprintln!();
    true
}

/// Pretty-prints variables and pauses execution until Enter is pressed.
///
/// # Features
///
/// - Compiles to nothing in release builds
/// - Can be disabled with `PRINT_BREAK=0` environment variable
/// - Interactive: Enter=continue, q=quit, s=skip all remaining
///
/// # Examples
///
/// ```rust,no_run
/// use print_break::print_break;
///
/// let user_id = 123;
/// let items = vec!["apple", "banana"];
/// let json = r#"{"status": "ok"}"#;
///
/// // Print single variable
/// print_break!(user_id);
///
/// // Print multiple variables
/// print_break!(user_id, items, json);
///
/// // Print with no variables (just pause)
/// print_break!();
/// ```
#[macro_export]
#[cfg(debug_assertions)]
macro_rules! print_break {
    () => {{
        if $crate::is_enabled() {
            use std::io::Write;

            let break_id = $crate::next_break_id();
            let location = format!("{}:{}", file!(), line!());
            let width = 50;
            let tty = $crate::is_tty();

            let (yellow, cyan, reset) = if tty {
                ("\x1b[1;33m", "\x1b[36m", "\x1b[0m")
            } else {
                ("", "", "")
            };

            eprintln!();
            eprintln!("{}┌─ BREAK #{} {}{}", yellow, break_id, "─".repeat(width - 12 - break_id.to_string().len()), reset);
            eprintln!("{}│{} {}{:<width$}{}{}│{}", yellow, reset, cyan, location, reset, yellow, reset, width = width - 2);
            eprintln!("{}└{}{}", yellow, "─".repeat(width), reset);

            $crate::handle_input();
        }
    }};
    ($($var:expr),+ $(,)?) => {{
        if $crate::is_enabled() {
            use std::io::Write;

            let break_id = $crate::next_break_id();
            let location = format!("{}:{}", file!(), line!());
            let width = 50;
            let tty = $crate::is_tty();

            let (yellow, cyan, green, white, reset) = if tty {
                ("\x1b[1;33m", "\x1b[36m", "\x1b[1;32m", "\x1b[37m", "\x1b[0m")
            } else {
                ("", "", "", "", "")
            };

            // Collect full output for "more" option
            let mut full_output = String::new();

            eprintln!();
            eprintln!("{}┌─ BREAK #{} {}{}", yellow, break_id, "─".repeat(width - 12 - break_id.to_string().len()), reset);
            eprintln!("{}│{} {}{:<width$}{}{}│{}", yellow, reset, cyan, location, reset, yellow, reset, width = width - 2);
            eprintln!("{}├{}{}", yellow, "─".repeat(width), reset);

            $(
                let formatted = $crate::format_value(&$var);
                let name = stringify!($var);

                // Store untruncated version
                full_output.push_str(&format!("{} = {}\n\n", name, $crate::format_value_full(&$var)));

                if formatted.contains('\n') {
                    eprintln!("{}│{} {}{}{}=", yellow, reset, green, name, reset);
                    for line in formatted.lines() {
                        eprintln!("{}│{}   {}{}{}", yellow, reset, white, line, reset);
                    }
                } else {
                    eprintln!("{}│{} {}{}{} = {}{}{}", yellow, reset, green, name, reset, white, formatted, reset);
                }
            )+

            $crate::store_full_output(full_output);

            eprintln!("{}└{}{}", yellow, "─".repeat(width), reset);
            $crate::handle_input();
        }
    }};
}

/// Conditional breakpoint - only triggers if condition is true.
///
/// # Examples
///
/// ```rust,no_run
/// use print_break::print_break_if;
///
/// for i in 0..100 {
///     print_break_if!(i == 50, i);  // Only breaks when i is 50
/// }
///
/// let x = 42;
/// print_break_if!(x > 10, x);  // Breaks because x > 10
/// ```
#[macro_export]
#[cfg(debug_assertions)]
macro_rules! print_break_if {
    ($cond:expr) => {{
        if $cond {
            $crate::print_break!();
        }
    }};
    ($cond:expr, $($var:expr),+ $(,)?) => {{
        if $cond {
            $crate::print_break!($($var),+);
        }
    }};
}

/// In release builds, print_break_if! compiles to nothing
#[macro_export]
#[cfg(not(debug_assertions))]
macro_rules! print_break_if {
    ($cond:expr) => {{}};
    ($cond:expr, $($var:expr),+ $(,)?) => {{}};
}

/// In release builds, print_break! compiles to nothing
#[macro_export]
#[cfg(not(debug_assertions))]
macro_rules! print_break {
    () => {{}};
    ($($var:expr),+ $(,)?) => {{}};
}

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

    #[test]
    fn format_json_string() {
        let json = r#"{"name": "test", "value": 42}"#;
        let formatted = format_value(&json);
        assert!(formatted.contains("\"name\": \"test\""));
        assert!(formatted.contains('\n')); // Should be pretty-printed
    }

    #[test]
    fn format_non_json() {
        let x = 42;
        let formatted = format_value(&x);
        assert_eq!(formatted, "42");
    }

    #[test]
    fn format_struct() {
        #[derive(Debug)]
        struct Test { a: i32, b: String }

        let t = Test { a: 1, b: "hello".to_string() };
        let formatted = format_value(&t);
        assert!(formatted.contains("Test"));
    }

    #[test]
    fn truncation_works() {
        let long_vec: Vec<i32> = (0..1000).collect();
        let formatted = format_value(&long_vec);
        assert!(formatted.contains("more lines"));
    }

    #[test]
    fn env_var_disable() {
        std::env::set_var("PRINT_BREAK", "0");
        assert!(!is_enabled());
        std::env::set_var("PRINT_BREAK", "1");
        assert!(is_enabled());
        std::env::remove_var("PRINT_BREAK");
    }
}