errcraft 0.1.0

//! Display and rendering utilities for error frames.

use crate::{utils, ErrFrame};
use std::fmt::Write;

/// Options for controlling error display.
#[derive(Debug, Clone)]
pub struct DisplayOptions {
    /// Whether to use emoji in output
    pub emoji: bool,
    /// Color mode for output
    pub color: ColorMode,
    /// Maximum depth for nested errors (None = unlimited)
    pub max_depth: Option<usize>,
    /// Backtrace display mode
    pub show_backtrace: BacktraceMode,
}

impl Default for DisplayOptions {
    fn default() -> Self {
        Self {
            emoji: cfg!(feature = "emoji"),
            color: ColorMode::Auto,
            max_depth: None,
            show_backtrace: BacktraceMode::Auto,
        }
    }
}

impl DisplayOptions {
    /// Creates new display options with default values.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets whether to use emoji.
    pub fn with_emoji(mut self, emoji: bool) -> Self {
        self.emoji = emoji;
        self
    }

    /// Sets the color mode.
    pub fn with_color(mut self, color: ColorMode) -> Self {
        self.color = color;
        self
    }

    /// Sets the maximum depth for nested errors.
    pub fn with_max_depth(mut self, depth: Option<usize>) -> Self {
        self.max_depth = depth;
        self
    }

    /// Sets the backtrace display mode.
    pub fn with_backtrace(mut self, mode: BacktraceMode) -> Self {
        self.show_backtrace = mode;
        self
    }

    /// Loads display options from environment variables.
    pub fn from_env() -> Self {
        let mut opts = Self::default();

        // Check NO_COLOR environment variable
        if std::env::var("NO_COLOR").is_ok() {
            opts.color = ColorMode::Never;
        }

        // Check RUST_BACKTRACE
        if let Ok(val) = std::env::var("RUST_BACKTRACE") {
            if val == "1" || val == "full" {
                opts.show_backtrace = BacktraceMode::Shown;
            }
        }

        opts
    }

    /// Determines if colors should be used based on current settings and TTY detection.
    pub fn should_colorize(&self) -> bool {
        match self.color {
            ColorMode::Always => true,
            ColorMode::Never => false,
            ColorMode::Auto => {
                #[cfg(feature = "is-terminal")]
                {
                    use is_terminal::IsTerminal;
                    std::io::stderr().is_terminal()
                }
                #[cfg(not(feature = "is-terminal"))]
                {
                    false
                }
            }
        }
    }
}

/// Color mode for error display.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ColorMode {
    /// Automatically detect based on TTY
    Auto,
    /// Always use colors
    Always,
    /// Never use colors
    Never,
}

/// Backtrace display mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BacktraceMode {
    /// Automatically decide based on environment
    Auto,
    /// Never show backtraces
    Hidden,
    /// Always show backtraces
    Shown,
}

impl ErrFrame {
    /// Prints the error to stdout with default formatting.
    pub fn print(&self) {
        println!("{}", self.to_string_styled(&DisplayOptions::from_env()));
    }

    /// Prints the error to stderr with default formatting.
    pub fn eprint(&self) {
        eprintln!("{}", self.to_string_styled(&DisplayOptions::from_env()));
    }

    /// Converts the error to a styled string using the given options.
    pub fn to_string_styled(&self, opts: &DisplayOptions) -> String {
        let mut output = String::new();
        let colorize = opts.should_colorize();

        // Error header
        let error_prefix = if opts.emoji { "❌ Error: " } else { "Error: " };

        if colorize {
            write!(
                &mut output,
                "{}{}",
                colorize_text(error_prefix, Color::Red, true),
                colorize_text(&self.message, Color::Red, false)
            )
            .unwrap();
        } else {
            write!(&mut output, "{}{}", error_prefix, self.message).unwrap();
        }
        output.push('\n');

        // Context
        if !self.context.is_empty() {
            output.push('\n');
            let context_prefix = if opts.emoji {
                "📦 Context:"
            } else {
                "Context:"
            };

            if colorize {
                writeln!(
                    &mut output,
                    "{}",
                    colorize_text(context_prefix, Color::Cyan, true)
                )
                .unwrap();
            } else {
                writeln!(&mut output, "{}", context_prefix).unwrap();
            }

            for layer in self.context.iter() {
                if let Some(key) = layer.key() {
                    if colorize {
                        writeln!(
                            &mut output,
                            "   {} = {}",
                            colorize_text(key, Color::Yellow, false),
                            layer.value().as_str()
                        )
                        .unwrap();
                    } else {
                        writeln!(&mut output, "   {} = {}", key, layer.value().as_str()).unwrap();
                    }
                } else {
                    writeln!(&mut output, "   {}", layer.value().as_str()).unwrap();
                }
            }
        }

        // Source chain
        #[cfg(feature = "std")]
        if let Some(source) = self.source.as_ref() {
            output.push('\n');
            let caused_by = if opts.emoji {
                "⚠️  Caused by:"
            } else {
                "Caused by:"
            };

            if colorize {
                writeln!(
                    &mut output,
                    "{}",
                    colorize_text(caused_by, Color::Yellow, true)
                )
                .unwrap();
            } else {
                writeln!(&mut output, "{}", caused_by).unwrap();
            }

            let mut current: &dyn std::error::Error = source.as_ref();
            let mut depth = 0;
            let max_depth = opts.max_depth.unwrap_or(usize::MAX);

            loop {
                if depth >= max_depth {
                    writeln!(
                        &mut output,
                        "   ... ({} more)",
                        count_remaining_sources(current)
                    )
                    .unwrap();
                    break;
                }

                let is_last = current.source().is_none();
                let prefix = if is_last { "  └─ " } else { "  ├─ " };

                if colorize {
                    writeln!(
                        &mut output,
                        "{}{}",
                        prefix,
                        colorize_text(&current.to_string(), Color::White, false)
                    )
                    .unwrap();
                } else {
                    writeln!(&mut output, "{}{}", prefix, current).unwrap();
                }

                if let Some(next) = current.source() {
                    current = next;
                    depth += 1;
                } else {
                    break;
                }
            }
        }

        // Backtrace
        #[cfg(all(feature = "std", feature = "backtrace"))]
        {
            let should_show = match opts.show_backtrace {
                BacktraceMode::Shown => true,
                BacktraceMode::Hidden => false,
                BacktraceMode::Auto => std::env::var("RUST_BACKTRACE").is_ok(),
            };

            if should_show {
                if let Some(bt) = &self.backtrace {
                    if bt.status() == std::backtrace::BacktraceStatus::Captured {
                        output.push('\n');
                        let bt_prefix = if opts.emoji {
                            "📍 Backtrace:"
                        } else {
                            "Backtrace:"
                        };

                        if colorize {
                            writeln!(
                                &mut output,
                                "{}",
                                colorize_text(bt_prefix, Color::Magenta, true)
                            )
                            .unwrap();
                        } else {
                            writeln!(&mut output, "{}", bt_prefix).unwrap();
                        }

                        writeln!(&mut output, "{}", utils::indent(&bt.to_string(), 3)).unwrap();
                    }
                }
            }
        }

        output
    }
}

#[cfg(feature = "std")]
fn count_remaining_sources(mut err: &dyn std::error::Error) -> usize {
    let mut count = 0;
    while let Some(next) = err.source() {
        count += 1;
        err = next;
    }
    count
}

// Color abstraction
#[derive(Debug, Clone, Copy)]
enum Color {
    Red,
    Yellow,
    Cyan,
    Magenta,
    White,
}

fn colorize_text(text: &str, color: Color, bold: bool) -> String {
    #[cfg(feature = "colors-owo")]
    {
        use owo_colors::OwoColorize;
        let result = match color {
            Color::Red => {
                if bold {
                    text.red().bold().to_string()
                } else {
                    text.red().to_string()
                }
            }
            Color::Yellow => {
                if bold {
                    text.yellow().bold().to_string()
                } else {
                    text.yellow().to_string()
                }
            }
            Color::Cyan => {
                if bold {
                    text.cyan().bold().to_string()
                } else {
                    text.cyan().to_string()
                }
            }
            Color::Magenta => {
                if bold {
                    text.magenta().bold().to_string()
                } else {
                    text.magenta().to_string()
                }
            }
            Color::White => {
                if bold {
                    text.white().bold().to_string()
                } else {
                    text.white().to_string()
                }
            }
        };
        result
    }

    #[cfg(all(feature = "colors-yansi", not(feature = "colors-owo")))]
    {
        use yansi::Paint;
        let result = match color {
            Color::Red => {
                if bold {
                    text.red().bold().to_string()
                } else {
                    text.red().to_string()
                }
            }
            Color::Yellow => {
                if bold {
                    text.yellow().bold().to_string()
                } else {
                    text.yellow().to_string()
                }
            }
            Color::Cyan => {
                if bold {
                    text.cyan().bold().to_string()
                } else {
                    text.cyan().to_string()
                }
            }
            Color::Magenta => {
                if bold {
                    text.magenta().bold().to_string()
                } else {
                    text.magenta().to_string()
                }
            }
            Color::White => {
                if bold {
                    text.white().bold().to_string()
                } else {
                    text.white().to_string()
                }
            }
        };
        result
    }

    #[cfg(all(
        feature = "colors-anstyle",
        not(feature = "colors-owo"),
        not(feature = "colors-yansi")
    ))]
    {
        use anstyle::{AnsiColor, Style};
        let style_color = match color {
            Color::Red => AnsiColor::Red,
            Color::Yellow => AnsiColor::Yellow,
            Color::Cyan => AnsiColor::Cyan,
            Color::Magenta => AnsiColor::Magenta,
            Color::White => AnsiColor::White,
        };
        let mut style = Style::new().fg_color(Some(anstyle::Color::Ansi(style_color)));
        if bold {
            style = style.bold();
        }
        format!("{}{}{}", style.render(), text, style.render_reset())
    }

    #[cfg(not(any(
        feature = "colors-owo",
        feature = "colors-yansi",
        feature = "colors-anstyle"
    )))]
    {
        let _ = (color, bold);
        text.to_string()
    }
}