path: root/src/color.rs

use clap::ValueEnum;
// No external sysinfo dependency — use environment heuristics instead for Windows shell detection.
use std::error::Error;
use std::fmt;
use std::str::FromStr;

#[derive(Debug, Clone, PartialEq)]
pub enum Color {
    Named(NamedColor),
    Hex(String),
    Rgb(u8, u8, u8),
    Hsl(u16, u8, u8),      // h: 0-360, s: 0-100, l: 0-100
    Ansi(u8),              // ANSI color code (0-255)
    Truecolor(u8, u8, u8), // 24-bit RGB
}

#[derive(Debug, Clone, Copy, PartialEq, ValueEnum)]
pub enum NamedColor {
    Black,
    Red,
    Green,
    Yellow,
    Blue,
    Magenta,
    Cyan,
    White,
    BrightBlack,
    BrightRed,
    BrightGreen,
    BrightYellow,
    BrightBlue,
    BrightMagenta,
    BrightCyan,
    BrightWhite,
}

#[derive(Debug)]
pub enum ColorParseError {
    InvalidFormat,
    InvalidHex,
    InvalidRgb,
    InvalidHsl,
    UnknownNamedColor,
}

impl fmt::Display for ColorParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ColorParseError::InvalidFormat => write!(f, "Invalid color format"),
            ColorParseError::InvalidHex => write!(f, "Invalid hex color code"),
            ColorParseError::InvalidRgb => write!(f, "Invalid RGB format. Expected format: R,G,B"),
            ColorParseError::InvalidHsl => {
                write!(f, "Invalid HSL format. Expected format: hsl(H,S%,L%)")
            }
            ColorParseError::UnknownNamedColor => write!(f, "Unknown named color"),
        }
    }
}

impl Error for ColorParseError {}

impl FromStr for Color {
    type Err = ColorParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s_lower = s.to_lowercase();

        // Try named color first
        if let Ok(named) = NamedColor::from_str(s, true) {
            return Ok(Color::Named(named));
        }

        // Try hex color (#RRGGBB or #RGB)
        if s.starts_with('#') {
            return parse_hex_color(s);
        }

        // Try HSL (hsl(180,100%,50%))
        if s_lower.starts_with("hsl(") && s.ends_with(')') {
            return parse_hsl_color(s);
        }

        // Try RGB tuple (255,0,128)
        if s.contains(',') {
            return parse_rgb_color(s);
        }

        // Try ANSI code (number between 0-255)
        if let Ok(code) = s.parse::<u8>() {
            return Ok(Color::Ansi(code));
        }

        Err(ColorParseError::InvalidFormat)
    }
}

impl FromStr for NamedColor {
    type Err = ColorParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::from_str(s, false)
    }
}

impl NamedColor {
    fn from_str(s: &str, ignore_case: bool) -> Result<Self, ColorParseError> {
        let s = if ignore_case {
            s.to_lowercase()
        } else {
            s.to_string()
        };

        match s.as_str() {
            "black" => Ok(NamedColor::Black),
            "red" => Ok(NamedColor::Red),
            "green" => Ok(NamedColor::Green),
            "yellow" => Ok(NamedColor::Yellow),
            "blue" => Ok(NamedColor::Blue),
            "magenta" => Ok(NamedColor::Magenta),
            "cyan" => Ok(NamedColor::Cyan),
            "white" => Ok(NamedColor::White),
            "brightblack" | "bright_black" => Ok(NamedColor::BrightBlack),
            "brightred" | "bright_red" => Ok(NamedColor::BrightRed),
            "brightgreen" | "bright_green" => Ok(NamedColor::BrightGreen),
            "brightyellow" | "bright_yellow" => Ok(NamedColor::BrightYellow),
            "brightblue" | "bright_blue" => Ok(NamedColor::BrightBlue),
            "brightmagenta" | "bright_magenta" => Ok(NamedColor::BrightMagenta),
            "brightcyan" | "bright_cyan" => Ok(NamedColor::BrightCyan),
            "brightwhite" | "bright_white" => Ok(NamedColor::BrightWhite),
            _ => Err(ColorParseError::UnknownNamedColor),
        }
    }
}

fn parse_hex_color(s: &str) -> Result<Color, ColorParseError> {
    let hex = s.trim_start_matches('#');

    match hex.len() {
        3 => {
            // #RGB format
            let r = u8::from_str_radix(&hex[0..1].repeat(2), 16)
                .map_err(|_| ColorParseError::InvalidHex)?;
            let g = u8::from_str_radix(&hex[1..2].repeat(2), 16)
                .map_err(|_| ColorParseError::InvalidHex)?;
            let b = u8::from_str_radix(&hex[2..3].repeat(2), 16)
                .map_err(|_| ColorParseError::InvalidHex)?;
            Ok(Color::Hex(format!("#{:02x}{:02x}{:02x}", r, g, b)))
        }
        6 => {
            // #RRGGBB format
            let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| ColorParseError::InvalidHex)?;
            let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| ColorParseError::InvalidHex)?;
            let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| ColorParseError::InvalidHex)?;
            Ok(Color::Hex(format!("#{:02x}{:02x}{:02x}", r, g, b)))
        }
        _ => Err(ColorParseError::InvalidHex),
    }
}

fn parse_rgb_color(s: &str) -> Result<Color, ColorParseError> {
    let parts: Vec<&str> = s.split(',').map(|p| p.trim()).collect();
    if parts.len() != 3 {
        return Err(ColorParseError::InvalidRgb);
    }

    let r = parts[0]
        .parse::<u8>()
        .map_err(|_| ColorParseError::InvalidRgb)?;
    let g = parts[1]
        .parse::<u8>()
        .map_err(|_| ColorParseError::InvalidRgb)?;
    let b = parts[2]
        .parse::<u8>()
        .map_err(|_| ColorParseError::InvalidRgb)?;

    Ok(Color::Rgb(r, g, b))
}

fn parse_hsl_color(s: &str) -> Result<Color, ColorParseError> {
    let content = s.trim_start_matches("hsl(").trim_end_matches(')');
    let parts: Vec<&str> = content.split(',').map(|p| p.trim()).collect();

    if parts.len() != 3 {
        return Err(ColorParseError::InvalidHsl);
    }

    let h = parts[0]
        .trim_end_matches(|c: char| !c.is_ascii_digit())
        .parse::<u16>()
        .map_err(|_| ColorParseError::InvalidHsl)?;
    let s = parts[1]
        .trim_end_matches('%')
        .parse::<u8>()
        .map_err(|_| ColorParseError::InvalidHsl)?;
    let l = parts[2]
        .trim_end_matches('%')
        .parse::<u8>()
        .map_err(|_| ColorParseError::InvalidHsl)?;

    if h > 360 || s > 100 || l > 100 {
        return Err(ColorParseError::InvalidHsl);
    }

    Ok(Color::Hsl(h, s, l))
}

impl Color {
    /// Convert color to RGB tuple
    pub fn to_rgb(&self) -> (u8, u8, u8) {
        match self {
            Color::Named(named) => named.to_rgb(),
            Color::Hex(hex) => {
                let hex = hex.trim_start_matches('#');
                match hex.len() {
                    3 => {
                        // #RGB format
                        let r = u8::from_str_radix(&hex[0..1].repeat(2), 16).unwrap_or(0);
                        let g = u8::from_str_radix(&hex[1..2].repeat(2), 16).unwrap_or(0);
                        let b = u8::from_str_radix(&hex[2..3].repeat(2), 16).unwrap_or(0);
                        (r, g, b)
                    }
                    6 => {
                        // #RRGGBB format
                        let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(0);
                        let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(0);
                        let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(0);
                        (r, g, b)
                    }
                    _ => (0, 0, 0),
                }
            }
            Color::Rgb(r, g, b) => (*r, *g, *b),
            Color::Hsl(h, s, l) => hsl_to_rgb(*h, *s, *l),
            Color::Ansi(code) => ansi_to_rgb(*code),
            Color::Truecolor(r, g, b) => (*r, *g, *b),
        }
    }

    /// Convert color to ANSI escape code for foreground
    pub fn to_ansi_fg(&self, color_mode: ColorMode) -> String {
        match color_mode {
            ColorMode::Truecolor => self.to_truecolor_fg(),
            ColorMode::Ansi256 => self.to_ansi256_fg(),
            ColorMode::Ansi16 => self.to_ansi16_fg(),
            ColorMode::NoColor => "".to_string(),
        }
    }

    fn to_truecolor_fg(&self) -> String {
        let (r, g, b) = self.to_rgb();
        format!("\x1b[38;2;{};{};{}m", r, g, b)
    }

    fn to_ansi256_fg(&self) -> String {
        let (r, g, b) = self.to_rgb();
        let code = rgb_to_ansi256(r, g, b);
        format!("\x1b[38;5;{}m", code)
    }

    fn to_ansi16_fg(&self) -> String {
        let (r, g, b) = self.to_rgb();
        let code = rgb_to_ansi16(r, g, b);
        format!("\x1b[{}m", code)
    }
}

impl NamedColor {
    pub fn to_rgb(self) -> (u8, u8, u8) {
        match self {
            NamedColor::Black => (0, 0, 0),
            NamedColor::Red => (197, 15, 31),
            NamedColor::Green => (19, 161, 14),
            NamedColor::Yellow => (193, 156, 0),
            NamedColor::Blue => (0, 55, 218),
            NamedColor::Magenta => (136, 23, 152),
            NamedColor::Cyan => (58, 150, 221),
            NamedColor::White => (204, 204, 204),
            NamedColor::BrightBlack => (118, 118, 118),
            NamedColor::BrightRed => (231, 72, 86),
            NamedColor::BrightGreen => (22, 198, 12),
            NamedColor::BrightYellow => (249, 241, 165),
            NamedColor::BrightBlue => (59, 120, 255),
            NamedColor::BrightMagenta => (180, 0, 158),
            NamedColor::BrightCyan => (97, 214, 214),
            NamedColor::BrightWhite => (242, 242, 242),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ColorMode {
    Truecolor,
    Ansi256,
    Ansi16,
    NoColor,
}

/// Convert HSL to RGB
fn hsl_to_rgb(h: u16, s: u8, l: u8) -> (u8, u8, u8) {
    let h = h as f32 / 360.0;
    let s = s as f32 / 100.0;
    let l = l as f32 / 100.0;

    let r;
    let g;
    let b;

    if s == 0.0 {
        r = l;
        g = l;
        b = l;
    } else {
        let hue_to_rgb = |p: f32, q: f32, t: f32| -> f32 {
            let mut t = t;
            if t < 0.0 {
                t += 1.0;
            }
            if t > 1.0 {
                t -= 1.0;
            }
            if t < 1.0 / 6.0 {
                return p + (q - p) * 6.0 * t;
            }
            if t < 1.0 / 2.0 {
                return q;
            }
            if t < 2.0 / 3.0 {
                return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
            }
            p
        };

        let q = if l < 0.5 {
            l * (1.0 + s)
        } else {
            l + s - l * s
        };
        let p = 2.0 * l - q;

        r = hue_to_rgb(p, q, h + 1.0 / 3.0);
        g = hue_to_rgb(p, q, h);
        b = hue_to_rgb(p, q, h - 1.0 / 3.0);
    }

    (
        (r * 255.0).round() as u8,
        (g * 255.0).round() as u8,
        (b * 255.0).round() as u8,
    )
}

/// Convert RGB to ANSI 256 color code
fn rgb_to_ansi256(r: u8, g: u8, b: u8) -> u8 {
    // Calculate grayscale value
    let gray = (r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114).round() as u8;

    // Check if it's a grayscale color
    if r == g && g == b {
        // Grayscale ramp (232-255)
        if gray <= 8 {
            16
        } else if gray >= 248 {
            231
        } else {
            ((gray as f32 - 8.0) / 247.0 * 24.0).round() as u8 + 232
        }
    } else {
        // Color cube (16-231)
        let r = (r as f32 / 255.0 * 5.0).round() as u8;
        let g = (g as f32 / 255.0 * 5.0).round() as u8;
        let b = (b as f32 / 255.0 * 5.0).round() as u8;

        16 + (r * 36) + (g * 6) + b
    }
}

/// Convert RGB to ANSI 16 color code
pub(crate) fn rgb_to_ansi16(r: u8, g: u8, b: u8) -> u8 {
    // Calculate brightness (perceived luminance)
    let brightness = (r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114).round() as u8;
    let is_bright = brightness > 128;

    // Determine base color using simple thresholding on each channel, producing an index 0..7
    let r_on = r > 128;
    let g_on = g > 128;
    let b_on = b > 128;
    let base_idx = (r_on as u8) + (g_on as u8) * 2 + (b_on as u8) * 4; // 0..7

    // SGR color codes: 30..37 for normal, 90..97 for bright
    if is_bright {
        90 + base_idx
    } else {
        30 + base_idx
    }
}

/// Convert ANSI color code to RGB
fn ansi_to_rgb(code: u8) -> (u8, u8, u8) {
    match code {
        // Standard 16 colors
        0 => (0, 0, 0),        // Black
        1 => (128, 0, 0),      // Red
        2 => (0, 128, 0),      // Green
        3 => (128, 128, 0),    // Yellow
        4 => (0, 0, 128),      // Blue
        5 => (128, 0, 128),    // Magenta
        6 => (0, 128, 128),    // Cyan
        7 => (192, 192, 192),  // White
        8 => (128, 128, 128),  // Bright Black
        9 => (255, 0, 0),      // Bright Red
        10 => (0, 255, 0),     // Bright Green
        11 => (255, 255, 0),   // Bright Yellow
        12 => (0, 0, 255),     // Bright Blue
        13 => (255, 0, 255),   // Bright Magenta
        14 => (0, 255, 255),   // Bright Cyan
        15 => (255, 255, 255), // Bright White

        // 256-color mode
        16..=231 => {
            // Color cube
            let code = code - 16;
            let r = ((code / 36) % 6) * 51;
            let g = ((code / 6) % 6) * 51;
            let b = (code % 6) * 51;
            (r, g, b)
        }

        232..=255 => {
            // Grayscale ramp
            let gray = (code - 232) * 10 + 8;
            (gray, gray, gray)
        }
    }
}

// (Removed older detect_color_mode to keep a single refactored implementation)

/// Try to enable ANSI (virtual terminal processing) on Windows consoles.
/// Returns true if enabling succeeded or isn't necessary, false otherwise.
#[cfg(windows)]
pub fn enable_windows_ansi() -> bool {
    // no ptr usage required; removed unused import
    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
    use winapi::um::processenv::GetStdHandle;
    use winapi::um::winbase::STD_OUTPUT_HANDLE;
    use winapi::um::wincon::ENABLE_VIRTUAL_TERMINAL_PROCESSING;

    unsafe {
        let stdout = GetStdHandle(STD_OUTPUT_HANDLE);
        if stdout == INVALID_HANDLE_VALUE {
            return false;
        }

        let mut mode: u32 = 0;
        if GetConsoleMode(stdout, &mut mode) == 0 {
            return false;
        }

        let new_mode = mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
        if SetConsoleMode(stdout, new_mode) == 0 {
            return false;
        }
    }

    true
}

/// Detect the parent shell name on Windows, using environment hints.
#[cfg(windows)]
pub fn detect_windows_shell() -> Option<String> {
    // Heuristic checks using common env vars
    if std::env::var("PSModulePath").is_ok() {
        return Some("powershell".to_string());
    }
    if std::env::var("PWshPROFILE").is_ok() || std::env::var("PWSH_VERSION").is_ok() {
        return Some("pwsh".to_string());
    }
    if let Ok(comspec) = std::env::var("COMSPEC") {
        if comspec.to_lowercase().ends_with("cmd.exe") {
            return Some("cmd.exe".to_string());
        }
    }
    if std::env::var("WT_SESSION").is_ok() {
        return Some("windows_terminal".to_string());
    }
    None
}

#[cfg(not(windows))]
#[allow(dead_code)]
pub fn detect_windows_shell() -> Option<String> {
    None
}

/// Convert Color to a crossterm Color (helper for use across platforms)
pub fn to_crossterm_color(color: &Color) -> crossterm::style::Color {
    let (r, g, b) = color.to_rgb();
    crossterm::style::Color::Rgb { r, g, b }
}

/// Detect the parent shell name on Windows, using the sysinfo crate.
pub fn detect_color_mode() -> ColorMode {
    if std::env::var("NO_COLOR").is_ok() {
        return ColorMode::NoColor;
    }

    // Early checks
    if std::env::var("COLORTERM")
        .is_ok_and(|colorterm| colorterm.contains("truecolor") || colorterm.contains("24bit"))
    {
        return ColorMode::Truecolor;
    }

    if std::env::var("TERM").is_ok_and(|term| term.contains("256color")) {
        return ColorMode::Ansi256;
    }
    if std::env::var("TERM").is_ok_and(|term| term.contains("color")) {
        return ColorMode::Ansi16;
    }

    // Default fallback
    #[cfg(windows)]
    let mut mode = ColorMode::Ansi16;
    #[cfg(not(windows))]
    let mode = ColorMode::Ansi16;

    // If running on Windows, try to enable ANSI (virtual terminal processing)
    #[cfg(windows)]
    {
        if enable_windows_ansi() {
            // Re-check for a better mode
            if let Ok(colorterm) = std::env::var("COLORTERM") {
                if colorterm.contains("truecolor") || colorterm.contains("24bit") {
                    mode = ColorMode::Truecolor;
                }
            }
            if let Ok(term) = std::env::var("TERM") {
                if term.contains("256color") {
                    mode = ColorMode::Ansi256;
                }
            }
        } else if let Some(shell) = detect_windows_shell() {
            let shell = shell.to_lowercase();
            if shell.contains("cmd.exe") {
                // cmd historically doesn't support ANSI; use 16 colors fallback
                mode = ColorMode::Ansi16;
            } else if shell.contains("powershell") || shell.contains("pwsh") {
                if let Ok(term) = std::env::var("TERM") {
                    if term.contains("256color") {
                        mode = ColorMode::Ansi256;
                    }
                }
            } else {
                mode = ColorMode::Ansi16;
            }
        }
    }

    mode
}

/// Convert RGB to HSV
fn rgb_to_hsv((r, g, b): (u8, u8, u8)) -> (f32, f32, f32) {
    let r = r as f32 / 255.0;
    let g = g as f32 / 255.0;
    let b = b as f32 / 255.0;

    let max = r.max(g).max(b);
    let min = r.min(g).min(b);
    let delta = max - min;

    let h = if delta == 0.0 {
        0.0
    } else if max == r {
        60.0 * (((g - b) / delta) % 6.0)
    } else if max == g {
        60.0 * (((b - r) / delta) + 2.0)
    } else {
        60.0 * (((r - g) / delta) + 4.0)
    };

    let h = if h < 0.0 { h + 360.0 } else { h };

    let s = if max == 0.0 { 0.0 } else { delta / max };
    let v = max;

    (h, s, v)
}

/// Linear interpolation between two colors in HSV space
pub fn lerp_color_hsv(start: &Color, end: &Color, t: f32) -> Color {
    let (h1, s1, v1) = rgb_to_hsv(start.to_rgb());
    let (h2, s2, v2) = rgb_to_hsv(end.to_rgb());

    // Handle hue interpolation correctly (shortest path around the color wheel)
    let h_diff = (h2 - h1 + 180.0) % 360.0 - 180.0;
    let h = (h1 + h_diff * t + 360.0) % 360.0;

    let s = s1 + (s2 - s1) * t;
    let v = v1 + (v2 - v1) * t;

    let (r, g, b) = hsv_to_rgb(h, s, v);
    Color::Truecolor(r, g, b)
}

/// Convert HSV to RGB
fn hsv_to_rgb(h: f32, s: f32, v: f32) -> (u8, u8, u8) {
    let c = v * s;
    let x = c * (1.0 - ((h / 60.0) % 2.0 - 1.0).abs());
    let m = v - c;

    let (r, g, b) = match h {
        h if (0.0..60.0).contains(&h) => (c, x, 0.0),
        h if (60.0..120.0).contains(&h) => (x, c, 0.0),
        h if (120.0..180.0).contains(&h) => (0.0, c, x),
        h if (180.0..240.0).contains(&h) => (0.0, x, c),
        h if (240.0..300.0).contains(&h) => (x, 0.0, c),
        _ => (c, 0.0, x),
    };

    (
        ((r + m) * 255.0).round() as u8,
        ((g + m) * 255.0).round() as u8,
        ((b + m) * 255.0).round() as u8,
    )
}