rustyle_css/

errors.rs

//! Error types and utilities for Rustyle
//!
//! Provides comprehensive error handling with helpful error messages.

use std::fmt;

/// Rustyle error types with enhanced context
#[derive(Debug, Clone)]
pub enum RustyleError {
    /// CSS parsing error with detailed location
    CssParseError {
        message: String,
        line: Option<usize>,
        column: Option<usize>,
        source_snippet: Option<String>,
        file: Option<String>,
    },
    /// Invalid CSS property with suggestions
    InvalidProperty {
        property: String,
        suggestions: Vec<String>,
        context: Option<String>,
        line: Option<usize>,
        column: Option<usize>,
    },
    /// Invalid CSS value with suggestions
    InvalidValue {
        property: String,
        value: String,
        suggestions: Vec<String>,
        expected_types: Vec<String>,
        line: Option<usize>,
        column: Option<usize>,
    },
    /// Missing required property
    MissingProperty {
        property: String,
        context: Option<String>,
        suggestions: Vec<String>,
    },
    /// Style registration error
    RegistrationError {
        message: String,
        class_name: Option<String>,
    },
    /// Invalid design tokens
    InvalidTokens { errors: Vec<String> },
    /// Browser compatibility warning
    BrowserCompatibility {
        property: String,
        value: Option<String>,
        unsupported_browsers: Vec<String>,
        suggestion: Option<String>,
    },
    /// Selector validation error
    InvalidSelector {
        selector: String,
        message: String,
        suggestion: Option<String>,
    },
}

impl fmt::Display for RustyleError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RustyleError::CssParseError {
                message,
                line,
                column,
                source_snippet,
                file,
            } => {
                if let Some(file_name) = file {
                    write!(f, "Error in {}: ", file_name)?;
                }
                write!(f, "CSS parsing error: {}", message)?;
                if let Some(l) = line {
                    write!(f, " (line {})", l)?;
                }
                if let Some(c) = column {
                    write!(f, " (column {})", c)?;
                }
                if let Some(snippet) = source_snippet {
                    write!(f, "\n\nCode snippet:\n{}", snippet)?;
                }
                Ok(())
            }
            RustyleError::InvalidProperty {
                property,
                suggestions,
                context,
                line,
                column,
            } => {
                write!(f, "Invalid CSS property: '{}'", property)?;
                if let Some(l) = line {
                    write!(f, " (line {})", l)?;
                }
                if let Some(c) = column {
                    write!(f, " (column {})", c)?;
                }
                if let Some(ctx) = context {
                    write!(f, "\nContext: {}", ctx)?;
                }
                if !suggestions.is_empty() {
                    write!(f, "\n\nDid you mean one of these?")?;
                    for (i, sug) in suggestions.iter().take(3).enumerate() {
                        write!(f, "\n  {}. {}", i + 1, sug)?;
                    }
                }
                Ok(())
            }
            RustyleError::InvalidValue {
                property,
                value,
                suggestions,
                expected_types,
                line,
                column,
            } => {
                write!(f, "Invalid value '{}' for property '{}'", value, property)?;
                if let Some(l) = line {
                    write!(f, " (line {})", l)?;
                }
                if let Some(c) = column {
                    write!(f, " (column {})", c)?;
                }
                if !expected_types.is_empty() {
                    write!(f, "\n\nExpected one of: {}", expected_types.join(", "))?;
                }
                if !suggestions.is_empty() {
                    write!(f, "\n\nDid you mean one of these?")?;
                    for (i, sug) in suggestions.iter().take(3).enumerate() {
                        write!(f, "\n  {}. {}", i + 1, sug)?;
                    }
                }
                Ok(())
            }
            RustyleError::MissingProperty {
                property,
                context,
                suggestions,
            } => {
                write!(f, "Missing required property: '{}'", property)?;
                if let Some(c) = context {
                    write!(f, " in context: {}", c)?;
                }
                if !suggestions.is_empty() {
                    write!(f, "\n\nSimilar properties: {}", suggestions.join(", "))?;
                }
                Ok(())
            }
            RustyleError::RegistrationError {
                message,
                class_name,
            } => {
                write!(f, "Style registration error: {}", message)?;
                if let Some(class) = class_name {
                    write!(f, " (class: {})", class)?;
                }
                Ok(())
            }
            RustyleError::InvalidTokens { errors } => {
                write!(f, "Invalid design tokens:")?;
                for error in errors {
                    write!(f, "\n  - {}", error)?;
                }
                Ok(())
            }
            RustyleError::BrowserCompatibility {
                property,
                value,
                unsupported_browsers,
                suggestion,
            } => {
                write!(
                    f,
                    "Browser compatibility warning for property '{}'",
                    property
                )?;
                if let Some(val) = value {
                    write!(f, " with value '{}'", val)?;
                }
                write!(f, "\nNot supported in: {}", unsupported_browsers.join(", "))?;
                if let Some(sug) = suggestion {
                    write!(f, "\nSuggestion: {}", sug)?;
                }
                Ok(())
            }
            RustyleError::InvalidSelector {
                selector,
                message,
                suggestion,
            } => {
                write!(f, "Invalid CSS selector '{}': {}", selector, message)?;
                if let Some(sug) = suggestion {
                    write!(f, "\nSuggestion: {}", sug)?;
                }
                Ok(())
            }
        }
    }
}

impl std::error::Error for RustyleError {}

/// Helper to suggest similar property names (returns multiple suggestions)
pub fn suggest_property(property: &str) -> Vec<String> {
    let common_properties = vec![
        "background-color",
        "background",
        "color",
        "padding",
        "margin",
        "border",
        "border-radius",
        "border-width",
        "border-style",
        "border-color",
        "font-size",
        "font-weight",
        "font-family",
        "font-style",
        "line-height",
        "display",
        "flex-direction",
        "justify-content",
        "align-items",
        "flex-wrap",
        "width",
        "height",
        "max-width",
        "min-width",
        "max-height",
        "min-height",
        "opacity",
        "transform",
        "transition",
        "animation",
        "box-shadow",
        "text-align",
        "text-decoration",
        "text-transform",
        "overflow",
        "position",
        "top",
        "right",
        "bottom",
        "left",
        "z-index",
        "cursor",
        "pointer-events",
    ];

    // Find all similar properties within threshold
    let mut suggestions: Vec<(&str, usize)> = Vec::new();

    for prop in &common_properties {
        let distance = levenshtein_distance(property, prop);
        if distance <= 3 {
            suggestions.push((prop, distance));
        }
    }

    // Sort by distance and return top suggestions
    suggestions.sort_by_key(|(_, dist)| *dist);
    suggestions
        .into_iter()
        .take(5)
        .map(|(prop, _)| prop.to_string())
        .collect()
}

/// Get all valid CSS properties (comprehensive list)
pub fn get_all_css_properties() -> Vec<&'static str> {
    vec![
        // Layout
        "display",
        "position",
        "top",
        "right",
        "bottom",
        "left",
        "z-index",
        "float",
        "clear",
        "overflow",
        "overflow-x",
        "overflow-y",
        // Flexbox
        "flex",
        "flex-direction",
        "flex-wrap",
        "flex-flow",
        "justify-content",
        "align-items",
        "align-content",
        "align-self",
        "flex-grow",
        "flex-shrink",
        "flex-basis",
        // Grid
        "grid",
        "grid-template",
        "grid-template-rows",
        "grid-template-columns",
        "grid-template-areas",
        "grid-auto-rows",
        "grid-auto-columns",
        "grid-auto-flow",
        "grid-gap",
        "grid-row-gap",
        "grid-column-gap",
        "grid-row",
        "grid-column",
        // Box Model
        "width",
        "height",
        "min-width",
        "max-width",
        "min-height",
        "max-height",
        "margin",
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left",
        "padding",
        "padding-top",
        "padding-right",
        "padding-bottom",
        "padding-left",
        "box-sizing",
        "border",
        "border-width",
        "border-style",
        "border-color",
        "border-top",
        "border-right",
        "border-bottom",
        "border-left",
        "border-radius",
        "border-top-left-radius",
        "border-top-right-radius",
        "border-bottom-left-radius",
        "border-bottom-right-radius",
        // Typography
        "font",
        "font-family",
        "font-size",
        "font-weight",
        "font-style",
        "font-variant",
        "line-height",
        "text-align",
        "text-decoration",
        "text-transform",
        "text-indent",
        "letter-spacing",
        "word-spacing",
        "white-space",
        "word-wrap",
        "text-overflow",
        // Colors
        "color",
        "background",
        "background-color",
        "background-image",
        "background-repeat",
        "background-position",
        "background-size",
        "background-attachment",
        // Visual
        "opacity",
        "visibility",
        "cursor",
        "pointer-events",
        "user-select",
        "box-shadow",
        "text-shadow",
        "outline",
        "outline-width",
        "outline-style",
        "outline-color",
        // Transform & Animation
        "transform",
        "transform-origin",
        "transition",
        "transition-property",
        "transition-duration",
        "transition-timing-function",
        "transition-delay",
        "animation",
        "animation-name",
        "animation-duration",
        "animation-timing-function",
        "animation-delay",
        "animation-iteration-count",
        "animation-direction",
        "animation-fill-mode",
        // Other
        "content",
        "quotes",
        "counter-reset",
        "counter-increment",
        "resize",
        "clip",
    ]
}

/// Simple Levenshtein distance calculation
fn levenshtein_distance(s1: &str, s2: &str) -> usize {
    let s1_chars: Vec<char> = s1.chars().collect();
    let s2_chars: Vec<char> = s2.chars().collect();
    let s1_len = s1_chars.len();
    let s2_len = s2_chars.len();

    if s1_len == 0 {
        return s2_len;
    }
    if s2_len == 0 {
        return s1_len;
    }

    let mut matrix = vec![vec![0; s2_len + 1]; s1_len + 1];

    for i in 0..=s1_len {
        matrix[i][0] = i;
    }
    for j in 0..=s2_len {
        matrix[0][j] = j;
    }

    for i in 1..=s1_len {
        for j in 1..=s2_len {
            let cost = if s1_chars[i - 1] == s2_chars[j - 1] {
                0
            } else {
                1
            };
            matrix[i][j] = (matrix[i - 1][j] + 1)
                .min(matrix[i][j - 1] + 1)
                .min(matrix[i - 1][j - 1] + cost);
        }
    }

    matrix[s1_len][s2_len]
}

/// Create a helpful error message with context and visual formatting
pub fn create_error_message(
    error: &RustyleError,
    file: Option<&str>,
    line: Option<usize>,
) -> String {
    let mut msg = String::new();

    // Add file and line context if not already in error
    match error {
        RustyleError::CssParseError {
            file: err_file,
            line: err_line,
            ..
        } => {
            if let Some(f) = file.or(err_file.as_ref().map(|s| s.as_str())) {
                msg.push_str(&format!("Error in {}: ", f));
            }
            if let Some(l) = line.or(*err_line) {
                msg.push_str(&format!("line {}: ", l));
            }
        }
        _ => {
            if let Some(f) = file {
                msg.push_str(&format!("Error in {}: ", f));
            }
            if let Some(l) = line {
                msg.push_str(&format!("line {}: ", l));
            }
        }
    }

    msg.push_str(&error.to_string());

    // Add helpful links and documentation
    msg.push_str("\n\nFor more information:");
    msg.push_str("\n  - Documentation: https://github.com/usvx/rustyle");
    msg.push_str("\n  - CSS Reference: https://developer.mozilla.org/en-US/docs/Web/CSS");

    // Add quick fix suggestions for common errors
    if let RustyleError::InvalidProperty { property, .. } = error {
        if property.contains("colour") {
            msg.push_str("\n\n💡 Tip: Use 'color' instead of 'colour' (American spelling)");
        }
    }

    msg
}

/// Extract code snippet around an error location
pub fn extract_code_snippet(
    source: &str,
    line: usize,
    column: Option<usize>,
    context_lines: usize,
) -> String {
    let lines: Vec<&str> = source.lines().collect();
    let line_num = line.saturating_sub(1);

    if line_num >= lines.len() {
        return String::new();
    }

    let start = line_num.saturating_sub(context_lines);
    let end = (line_num + context_lines + 1).min(lines.len());

    let mut snippet = String::new();
    for i in start..end {
        let line_content = lines[i];
        let line_no = i + 1;

        // Add line number
        snippet.push_str(&format!("{:4} | ", line_no));
        snippet.push_str(line_content);
        snippet.push('\n');

        // Add caret pointing to error column
        if i == line_num {
            if let Some(col) = column {
                let spaces = "     | ".len() + col.saturating_sub(1);
                snippet.push_str(&" ".repeat(spaces));
                snippet.push_str("^\n");
            }
        }
    }

    snippet
}

/// Validate CSS property name
pub fn validate_property(property: &str) -> Result<(), RustyleError> {
    let valid_properties = get_all_css_properties();

    if valid_properties.contains(&property) {
        return Ok(());
    }

    let suggestions = suggest_property(property);
    Err(RustyleError::InvalidProperty {
        property: property.to_string(),
        suggestions,
        context: None,
        line: None,
        column: None,
    })
}

/// Validate CSS value for a property
pub fn validate_value(property: &str, value: &str) -> Result<(), RustyleError> {
    // Basic validation - can be extended with more sophisticated checks
    if value.trim().is_empty() {
        return Err(RustyleError::InvalidValue {
            property: property.to_string(),
            value: value.to_string(),
            suggestions: vec![],
            expected_types: vec!["non-empty value".to_string()],
            line: None,
            column: None,
        });
    }

    Ok(())
}