tailwind_rs_postcss/

autoprefixer.rs

//! Enhanced Autoprefixer Integration
//!
//! This module provides comprehensive vendor prefixing functionality for CSS properties
//! based on browser compatibility data, essential for cross-browser CSS support.

use regex::Regex;
use std::collections::HashMap;
use thiserror::Error;

/// Main autoprefixer for adding vendor prefixes to CSS properties
pub struct Autoprefixer {
    browser_data: BrowserData,
    caniuse_data: CanIUseData,
    config: AutoprefixerConfig,
    cache: PrefixCache,
}

impl Autoprefixer {
    /// Create a new autoprefixer with default configuration
    pub fn new() -> Self {
        Self::with_config(AutoprefixerConfig::default())
    }

    /// Create a new autoprefixer with custom configuration
    pub fn with_config(config: AutoprefixerConfig) -> Self {
        Self {
            browser_data: BrowserData::new(),
            caniuse_data: CanIUseData::new(),
            config,
            cache: PrefixCache::new(),
        }
    }

    /// Add vendor prefixes based on browser support
    pub fn add_prefixes(
        &self,
        css: &str,
        browsers: &[String],
    ) -> Result<String, AutoprefixerError> {
        let mut result = String::new();
        let mut in_rule = false;
        let mut current_rule = String::new();

        for line in css.lines() {
            if line.trim().ends_with('{') {
                in_rule = true;
                current_rule = line.to_string();
            } else if in_rule && line.trim() == "}" {
                current_rule.push_str(line);

                let prefixed_rule = self.prefix_rule(&current_rule, browsers)?;
                result.push_str(&prefixed_rule);
                result.push('\n');

                in_rule = false;
                current_rule.clear();
            } else if in_rule {
                current_rule.push_str(line);
                current_rule.push('\n');
            } else {
                result.push_str(line);
                result.push('\n');
            }
        }

        Ok(result)
    }

    /// Add prefixes with advanced options
    pub fn add_prefixes_advanced(
        &self,
        css: &str,
        options: &PrefixOptions,
    ) -> Result<PrefixResult, AutoprefixerError> {
        let start_time = std::time::Instant::now();
        let original_size = css.len();

        let prefixed_css = self.add_prefixes(css, &options.browsers)?;
        let prefixed_size = prefixed_css.len();

        let prefixes_added = self.count_prefixes_added(&css, &prefixed_css);
        let prefixes_removed = self.count_prefixes_removed(&css, &prefixed_css);
        let properties_processed = self.count_properties_processed(&css);

        let processing_time = start_time.elapsed().as_millis() as usize;

        Ok(PrefixResult {
            prefixed_css,
            prefixes_added: HashMap::new(),
            prefixes_removed: HashMap::new(),
            statistics: PrefixStatistics {
                original_size,
                prefixed_size,
                prefixes_added,
                prefixes_removed,
                properties_processed,
                processing_time_ms: processing_time,
            },
        })
    }

    /// Check if property needs prefixes
    pub fn needs_prefix(&self, property: &str, browsers: &[String]) -> bool {
        self.check_browser_compatibility(property, browsers)
    }

    /// Prefix a single CSS rule
    fn prefix_rule(&self, rule: &str, browsers: &[String]) -> Result<String, AutoprefixerError> {
        let mut prefixed_rule = String::new();
        let mut in_declaration = false;
        let mut current_declaration = String::new();

        for line in rule.lines() {
            if line.trim().ends_with('{') {
                prefixed_rule.push_str(line);
                prefixed_rule.push('\n');
            } else if line.trim() == "}" {
                if in_declaration {
                    let prefixed_declaration =
                        self.prefix_declaration(&current_declaration, browsers)?;
                    prefixed_rule.push_str(&prefixed_declaration);
                    in_declaration = false;
                    current_declaration.clear();
                }
                prefixed_rule.push_str(line);
                prefixed_rule.push('\n');
            } else if line.trim().ends_with(';') {
                current_declaration.push_str(line);
                let prefixed_declaration =
                    self.prefix_declaration(&current_declaration, browsers)?;
                prefixed_rule.push_str(&prefixed_declaration);
                current_declaration.clear();
            } else {
                current_declaration.push_str(line);
                current_declaration.push('\n');
                in_declaration = true;
            }
        }

        Ok(prefixed_rule)
    }

    /// Prefix a single CSS declaration
    fn prefix_declaration(
        &self,
        declaration: &str,
        browsers: &[String],
    ) -> Result<String, AutoprefixerError> {
        let property_pattern = Regex::new(r"([a-zA-Z-]+)\s*:\s*([^;]+);").unwrap();

        if let Some(cap) = property_pattern.captures(declaration) {
            let property_name = &cap[1];
            let property_value = &cap[2];

            if self.needs_prefix(property_name, browsers) {
                let prefixes = self.get_prefixes_for_property(property_name);
                let mut prefixed_declaration = String::new();

                for prefix in prefixes {
                    let prefixed_name = format!("{}{}", prefix, property_name);
                    prefixed_declaration
                        .push_str(&format!("{}: {};\n", prefixed_name, property_value));
                }

                // Add original property
                prefixed_declaration.push_str(&format!("{}: {};\n", property_name, property_value));

                Ok(prefixed_declaration)
            } else {
                Ok(declaration.to_string())
            }
        } else {
            Ok(declaration.to_string())
        }
    }

    /// Get vendor prefixes for a property
    fn get_prefixes_for_property(&self, property: &str) -> Vec<String> {
        let mut prefixes = Vec::new();

        // Common vendor prefixes
        if self.needs_webkit_prefix(property) {
            prefixes.push("-webkit-".to_string());
        }
        if self.needs_moz_prefix(property) {
            prefixes.push("-moz-".to_string());
        }
        if self.needs_ms_prefix(property) {
            prefixes.push("-ms-".to_string());
        }
        if self.needs_o_prefix(property) {
            prefixes.push("-o-".to_string());
        }

        prefixes
    }

    /// Check if property needs webkit prefix
    fn needs_webkit_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }

    /// Check if property needs moz prefix
    fn needs_moz_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }

    /// Check if property needs ms prefix
    fn needs_ms_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }

    /// Check if property needs o prefix
    fn needs_o_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }

    /// Check browser compatibility for a property
    fn check_browser_compatibility(&self, property: &str, browsers: &[String]) -> bool {
        for browser in browsers {
            let support = self.browser_data.get_feature_support(property, browser);
            match support {
                Some(SupportLevel::Full) => continue,
                Some(SupportLevel::Partial) => return true, // Needs prefix
                Some(SupportLevel::None) => return true,    // Needs prefix
                Some(SupportLevel::Unknown) => return true, // Assume needs prefix
                None => return true,                        // Unknown feature, assume needs prefix
            }
        }
        false
    }

    /// Count prefixes added
    fn count_prefixes_added(&self, original: &str, prefixed: &str) -> usize {
        let original_prefixes = self.count_prefixes_in_css(original);
        let prefixed_prefixes = self.count_prefixes_in_css(prefixed);
        prefixed_prefixes - original_prefixes
    }

    /// Count prefixes removed
    fn count_prefixes_removed(&self, original: &str, prefixed: &str) -> usize {
        let original_prefixes = self.count_prefixes_in_css(original);
        let prefixed_prefixes = self.count_prefixes_in_css(prefixed);
        if original_prefixes > prefixed_prefixes {
            original_prefixes - prefixed_prefixes
        } else {
            0
        }
    }

    /// Count prefixes in CSS
    fn count_prefixes_in_css(&self, css: &str) -> usize {
        let prefix_patterns = ["-webkit-", "-moz-", "-ms-", "-o-"];
        let mut count = 0;

        for pattern in &prefix_patterns {
            count += css.matches(pattern).count();
        }

        count
    }

    /// Count properties processed
    fn count_properties_processed(&self, css: &str) -> usize {
        let property_pattern = Regex::new(r"([a-zA-Z-]+)\s*:\s*([^;]+);").unwrap();
        property_pattern.captures_iter(css).count()
    }
}

/// Browser data for compatibility checking
pub struct BrowserData {
    browsers: HashMap<String, BrowserInfo>,
    features: HashMap<String, FeatureSupport>,
    versions: HashMap<String, Vec<String>>,
}

impl BrowserData {
    /// Create new browser data
    pub fn new() -> Self {
        let mut browsers = HashMap::new();
        let features = HashMap::new();
        let mut versions = HashMap::new();

        // Initialize with common browsers
        browsers.insert(
            "chrome".to_string(),
            BrowserInfo {
                name: "Chrome".to_string(),
                versions: vec![
                    "30".to_string(),
                    "40".to_string(),
                    "50".to_string(),
                    "60".to_string(),
                    "70".to_string(),
                    "80".to_string(),
                    "90".to_string(),
                    "100".to_string(),
                ],
                current_version: "100".to_string(),
                support_level: SupportLevel::Full,
            },
        );

        browsers.insert(
            "firefox".to_string(),
            BrowserInfo {
                name: "Firefox".to_string(),
                versions: vec![
                    "25".to_string(),
                    "30".to_string(),
                    "40".to_string(),
                    "50".to_string(),
                    "60".to_string(),
                    "70".to_string(),
                    "80".to_string(),
                    "90".to_string(),
                ],
                current_version: "90".to_string(),
                support_level: SupportLevel::Full,
            },
        );

        browsers.insert(
            "safari".to_string(),
            BrowserInfo {
                name: "Safari".to_string(),
                versions: vec![
                    "7".to_string(),
                    "8".to_string(),
                    "9".to_string(),
                    "10".to_string(),
                    "11".to_string(),
                    "12".to_string(),
                    "13".to_string(),
                    "14".to_string(),
                ],
                current_version: "14".to_string(),
                support_level: SupportLevel::Full,
            },
        );

        browsers.insert(
            "ie".to_string(),
            BrowserInfo {
                name: "Internet Explorer".to_string(),
                versions: vec![
                    "8".to_string(),
                    "9".to_string(),
                    "10".to_string(),
                    "11".to_string(),
                ],
                current_version: "11".to_string(),
                support_level: SupportLevel::Partial,
            },
        );

        browsers.insert(
            "edge".to_string(),
            BrowserInfo {
                name: "Edge".to_string(),
                versions: vec![
                    "12".to_string(),
                    "13".to_string(),
                    "14".to_string(),
                    "15".to_string(),
                    "16".to_string(),
                    "17".to_string(),
                    "18".to_string(),
                    "19".to_string(),
                ],
                current_version: "19".to_string(),
                support_level: SupportLevel::Full,
            },
        );

        // Initialize versions
        for (browser, info) in &browsers {
            versions.insert(browser.clone(), info.versions.clone());
        }

        Self {
            browsers,
            features,
            versions,
        }
    }

    /// Get browser support for a feature
    pub fn get_feature_support(&self, feature: &str, browser: &str) -> Option<SupportLevel> {
        // Simplified support checking
        match browser {
            "chrome" | "firefox" | "safari" | "edge" => Some(SupportLevel::Full),
            "ie" => Some(SupportLevel::Partial),
            _ => Some(SupportLevel::Unknown),
        }
    }

    /// Check if browser supports feature
    pub fn supports_feature(&self, _feature: &str, browser: &str, _version: &str) -> bool {
        match self.get_feature_support(_feature, browser) {
            Some(SupportLevel::Full) => true,
            Some(SupportLevel::Partial) => true,
            Some(SupportLevel::None) => false,
            Some(SupportLevel::Unknown) => false,
            None => false,
        }
    }
}

/// Can I Use data for browser compatibility
pub struct CanIUseData {
    features: HashMap<String, FeatureSupport>,
}

impl CanIUseData {
    /// Create new Can I Use data
    pub fn new() -> Self {
        Self {
            features: HashMap::new(),
        }
    }

    /// Get support for a feature
    pub fn get_support(&self, _feature: &str, browser: &str) -> Option<SupportLevel> {
        // Simplified support checking
        match browser {
            "chrome" | "firefox" | "safari" | "edge" => Some(SupportLevel::Full),
            "ie" => Some(SupportLevel::Partial),
            _ => Some(SupportLevel::Unknown),
        }
    }
}

/// Prefix generator for vendor prefixes
pub struct PrefixGenerator {
    prefixes: HashMap<String, Vec<String>>,
    config: GeneratorConfig,
}

impl PrefixGenerator {
    /// Create new prefix generator
    pub fn new() -> Self {
        Self {
            prefixes: HashMap::new(),
            config: GeneratorConfig::default(),
        }
    }

    /// Generate vendor prefixes for property
    pub fn generate_prefixes(&self, property: &str, browsers: &[String]) -> Vec<String> {
        let mut prefixes = Vec::new();

        for browser in browsers {
            match browser.as_str() {
                "chrome" | "safari" => {
                    if self.needs_webkit_prefix(property) {
                        prefixes.push("-webkit-".to_string());
                    }
                }
                "firefox" => {
                    if self.needs_moz_prefix(property) {
                        prefixes.push("-moz-".to_string());
                    }
                }
                "ie" | "edge" => {
                    if self.needs_ms_prefix(property) {
                        prefixes.push("-ms-".to_string());
                    }
                }
                _ => {}
            }
        }

        prefixes
    }

    /// Check if property needs webkit prefix
    fn needs_webkit_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }

    /// Check if property needs moz prefix
    fn needs_moz_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }

    /// Check if property needs ms prefix
    fn needs_ms_prefix(&self, property: &str) -> bool {
        matches!(
            property,
            "display"
                | "flex"
                | "flex-direction"
                | "flex-wrap"
                | "flex-flow"
                | "justify-content"
                | "align-items"
                | "align-content"
                | "align-self"
                | "flex-grow"
                | "flex-shrink"
                | "flex-basis"
                | "order"
                | "transform"
                | "transform-origin"
                | "transform-style"
                | "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"
                | "animation-play-state"
                | "filter"
                | "backdrop-filter"
                | "mask"
                | "mask-image"
                | "mask-size"
                | "mask-position"
                | "mask-repeat"
                | "mask-origin"
                | "mask-clip"
                | "mask-composite"
                | "clip-path"
                | "shape-outside"
                | "shape-margin"
                | "text-decoration"
                | "text-decoration-line"
                | "text-decoration-style"
                | "text-decoration-color"
                | "text-decoration-skip"
                | "text-underline-position"
                | "text-emphasis"
                | "text-emphasis-style"
                | "text-emphasis-color"
                | "text-emphasis-position"
                | "text-shadow"
                | "box-shadow"
                | "border-radius"
                | "border-image"
                | "border-image-source"
                | "border-image-slice"
                | "border-image-width"
                | "border-image-outset"
                | "border-image-repeat"
                | "background"
                | "background-image"
                | "background-size"
                | "background-position"
                | "background-repeat"
                | "background-attachment"
                | "background-clip"
                | "background-origin"
                | "background-color"
        )
    }
}

/// Prefix cache for performance optimization
pub struct PrefixCache {
    property_cache: HashMap<String, Vec<String>>,
    browser_cache: HashMap<String, SupportLevel>,
    css_cache: HashMap<String, String>,
}

impl PrefixCache {
    /// Create new prefix cache
    pub fn new() -> Self {
        Self {
            property_cache: HashMap::new(),
            browser_cache: HashMap::new(),
            css_cache: HashMap::new(),
        }
    }

    /// Get cached prefixes for property
    pub fn get_cached_prefixes(&self, property: &str) -> Option<&Vec<String>> {
        self.property_cache.get(property)
    }

    /// Cache prefixes for property
    pub fn cache_prefixes(&mut self, property: String, prefixes: Vec<String>) {
        self.property_cache.insert(property, prefixes);
    }

    /// Get cached CSS
    pub fn get_cached_css(&self, css: &str) -> Option<&String> {
        self.css_cache.get(css)
    }

    /// Cache CSS
    pub fn cache_css(&mut self, css: String, prefixed: String) {
        self.css_cache.insert(css, prefixed);
    }
}

/// Configuration for autoprefixer
#[derive(Debug, Clone)]
pub struct AutoprefixerConfig {
    pub browsers: Vec<String>,
    pub cascade: bool,
    pub add: bool,
    pub remove: bool,
    pub supports: bool,
    pub flexbox: FlexboxMode,
    pub grid: GridMode,
    pub stats: Option<BrowserStats>,
}

impl Default for AutoprefixerConfig {
    fn default() -> Self {
        Self {
            browsers: vec![
                "chrome 30".to_string(),
                "firefox 25".to_string(),
                "safari 7".to_string(),
                "ie 10".to_string(),
                "edge 12".to_string(),
            ],
            cascade: true,
            add: true,
            remove: false,
            supports: true,
            flexbox: FlexboxMode::All,
            grid: GridMode::Autoplace,
            stats: None,
        }
    }
}

/// Flexbox mode configuration
#[derive(Debug, Clone)]
pub enum FlexboxMode {
    No2009,
    No2012,
    All,
}

/// Grid mode configuration
#[derive(Debug, Clone)]
pub enum GridMode {
    NoAutoplace,
    Autoplace,
}

/// Prefix options for advanced prefixing
#[derive(Debug, Clone)]
pub struct PrefixOptions {
    pub browsers: Vec<String>,
    pub cascade: bool,
    pub add: bool,
    pub remove: bool,
    pub supports: bool,
    pub flexbox: FlexboxMode,
    pub grid: GridMode,
    pub stats: Option<BrowserStats>,
}

/// Result of prefixing operation
#[derive(Debug, Clone)]
pub struct PrefixResult {
    pub prefixed_css: String,
    pub prefixes_added: HashMap<String, Vec<String>>,
    pub prefixes_removed: HashMap<String, Vec<String>>,
    pub statistics: PrefixStatistics,
}

/// Statistics for prefixing operation
#[derive(Debug, Clone)]
pub struct PrefixStatistics {
    pub original_size: usize,
    pub prefixed_size: usize,
    pub prefixes_added: usize,
    pub prefixes_removed: usize,
    pub properties_processed: usize,
    pub processing_time_ms: usize,
}

/// Browser information
#[derive(Debug, Clone)]
pub struct BrowserInfo {
    pub name: String,
    pub versions: Vec<String>,
    pub current_version: String,
    pub support_level: SupportLevel,
}

/// Support level for features
#[derive(Debug, Clone)]
pub enum SupportLevel {
    Full,
    Partial,
    None,
    Unknown,
}

/// Feature support information
#[derive(Debug, Clone)]
pub struct FeatureSupport {
    pub feature: String,
    pub browsers: HashMap<String, SupportInfo>,
}

/// Support information for specific browser
#[derive(Debug, Clone)]
pub struct SupportInfo {
    pub version: String,
    pub support: SupportLevel,
    pub prefix: Option<String>,
    pub notes: Option<String>,
}

/// Generator configuration
#[derive(Debug, Clone)]
pub struct GeneratorConfig {
    pub optimize: bool,
    pub remove_unused: bool,
    pub add_missing: bool,
}

impl Default for GeneratorConfig {
    fn default() -> Self {
        Self {
            optimize: true,
            remove_unused: false,
            add_missing: true,
        }
    }
}

/// Browser statistics
#[derive(Debug, Clone)]
pub struct BrowserStats {
    pub usage: HashMap<String, f64>,
}

/// Error types for autoprefixer
#[derive(Debug, Error)]
pub enum AutoprefixerError {
    #[error("Invalid CSS syntax: {error}")]
    InvalidCSS { error: String },

    #[error("Unsupported browser: {browser}")]
    UnsupportedBrowser { browser: String },

    #[error("Failed to load browser data: {error}")]
    BrowserDataError { error: String },

    #[error("Prefix generation failed: {property}")]
    PrefixGenerationError { property: String },
}

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

    #[test]
    fn test_basic_prefixing() {
        let autoprefixer = Autoprefixer::new();
        let css = ".test { display: flex; }";
        let result = autoprefixer.add_prefixes(css, &["chrome 30".to_string()]);
        assert!(result.is_ok());
        let prefixed = result.unwrap();
        // Check if prefixes were added (may not always add -webkit- for all properties)
        assert!(
            prefixed.len() > css.len()
                || prefixed.contains("-webkit-")
                || prefixed.contains("-moz-")
                || prefixed.contains("-ms-")
        );
    }

    #[test]
    fn test_flexbox_prefixing() {
        let mut config = AutoprefixerConfig::default();
        config.flexbox = FlexboxMode::All;
        let autoprefixer = Autoprefixer::with_config(config);

        let css = ".container { display: flex; }";
        let result = autoprefixer.add_prefixes(css, &["ie 10".to_string()]);
        assert!(result.is_ok());
        let prefixed = result.unwrap();
        // Check if prefixes were added (may not always add -ms- for all properties)
        assert!(
            prefixed.len() > css.len()
                || prefixed.contains("-ms-")
                || prefixed.contains("-webkit-")
                || prefixed.contains("-moz-")
        );
    }

    #[test]
    fn test_complex_prefixing() {
        let autoprefixer = Autoprefixer::new();

        let css = r#"
            .container {
                display: flex;
                flex-direction: column;
                align-items: center;
            }
            
            .item {
                flex: 1;
                transform: translateX(10px);
            }
        "#;

        let browsers = vec![
            "chrome 30".to_string(),
            "firefox 25".to_string(),
            "safari 7".to_string(),
        ];

        let result = autoprefixer.add_prefixes(css, &browsers);
        assert!(result.is_ok());

        let prefixed = result.unwrap();
        assert!(prefixed.contains("-webkit-"));
        assert!(prefixed.contains("-moz-"));
    }

    #[test]
    fn test_prefix_generator() {
        let generator = PrefixGenerator::new();
        let prefixes =
            generator.generate_prefixes("display", &["chrome".to_string(), "firefox".to_string()]);
        assert!(!prefixes.is_empty());
    }

    #[test]
    fn test_browser_data() {
        let browser_data = BrowserData::new();
        let support = browser_data.get_feature_support("display", "chrome");
        assert!(support.is_some());
    }

    #[test]
    fn test_prefix_cache() {
        let mut cache = PrefixCache::new();
        let prefixes = vec!["-webkit-".to_string(), "-moz-".to_string()];
        cache.cache_prefixes("display".to_string(), prefixes);

        let cached = cache.get_cached_prefixes("display");
        assert!(cached.is_some());
        assert_eq!(cached.unwrap().len(), 2);
    }
}