webpage_quality_analyzer 1.0.2

//! WASM bindings for webpage-quality-analyzer
//!
//! **Version**: 1.0.2
//!
//! This module provides WebAssembly bindings using wasm-bindgen to expose
//! the full analyzer functionality to JavaScript/TypeScript environments.
//!
//! **What's New in 1.0.2**:
//! - Product profile restored to e-commerce focus (breaking: use "general" for software)
//! - Login page validation stricter (Forms weight: 40%)
//! - Homepage/General profiles more balanced
//! - Fixed MetricEquals penalty trigger
//!
//! # Features
//! - Full async support via JavaScript Promises
//! - Profile-aware scoring with all Phase 3 features
//! - All 115 metrics calculated
//! - Batch processing support
//! - Custom profile configurations

use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

#[cfg(target_arch = "wasm32")]
use crate::async_runtime::WasmRuntime;

#[cfg(not(target_arch = "wasm32"))]
type WasmRuntime = crate::async_runtime::DefaultRuntime;

use crate::{AnalyzeError, Analyzer, PageQualityReport};

/// WASM wrapper for the webpage quality analyzer
///
/// This provides a JavaScript-friendly interface to the full Rust analyzer,
/// bridging async Rust to JavaScript Promises via wasm-bindgen-futures.
#[wasm_bindgen]
pub struct WasmAnalyzer {
    analyzer: Analyzer<WasmRuntime>,
}

/// Configuration options for creating a WasmAnalyzer
///
/// This struct is not directly exposed to JavaScript. Use the methods
/// on WasmAnalyzer to configure instead.
#[derive(Debug, Clone, Serialize, Deserialize)]
struct WasmAnalyzerConfig {
    /// Profile name to use (e.g., "default", "news", "blog", "ecommerce")
    profile: Option<String>,

    /// Enable NLP features (language detection, keyword extraction)
    enable_nlp: bool,

    /// Add detailed report sections
    add_report: bool,
}

impl WasmAnalyzerConfig {
    fn new() -> Self {
        WasmAnalyzerConfig {
            profile: None,
            enable_nlp: true,
            add_report: true,
        }
    }
}

impl Default for WasmAnalyzerConfig {
    fn default() -> Self {
        Self::new()
    }
}

#[wasm_bindgen]
impl WasmAnalyzer {
    /// Create a new analyzer with default configuration
    #[wasm_bindgen(constructor)]
    pub fn new() -> Result<WasmAnalyzer, JsValue> {
        // Set panic hook for better error messages in browser console
        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        let analyzer = Analyzer::<WasmRuntime>::builder()
            .build()
            .map_err(|e| JsValue::from_str(&format!("Failed to create analyzer: {}", e)))?;

        Ok(WasmAnalyzer { analyzer })
    }

    /// Create analyzer with custom configuration
    ///
    /// # Arguments
    /// * `profile` - Optional profile name ("default", "news", "blog", etc.)
    /// * `enable_nlp` - Enable NLP features (default: true)
    /// * `add_report` - Include detailed report sections (default: true)
    #[wasm_bindgen(js_name = withConfig)]
    pub fn with_config(
        profile: Option<String>,
        enable_nlp: Option<bool>,
        add_report: Option<bool>,
    ) -> Result<WasmAnalyzer, JsValue> {
        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        let mut builder = Analyzer::<WasmRuntime>::builder();

        if let Some(profile_name) = profile {
            builder = builder
                .with_profile_name(&profile_name)
                .map_err(|e| JsValue::from_str(&format!("Invalid profile: {}", e)))?;
        }

        #[cfg(feature = "nlp")]
        if let Some(nlp) = enable_nlp {
            builder = builder.enable_nlp(nlp);
        }

        if let Some(report) = add_report {
            builder = builder.add_report(report);
        }

        let analyzer = builder
            .build()
            .map_err(|e| JsValue::from_str(&format!("Failed to create analyzer: {}", e)))?;

        Ok(WasmAnalyzer { analyzer })
    }

    /// Analyze HTML content
    ///
    /// # Arguments
    /// * `html` - HTML content as string
    ///
    /// # Returns
    /// Promise that resolves to a PageQualityReport JSON object
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const analyzer = new WasmAnalyzer();
    /// const report = await analyzer.analyze('<html>...</html>');
    /// console.log(`Score: ${report.score}, Quality: ${report.verdict}`);
    /// ```
    #[wasm_bindgen]
    pub async fn analyze(&self, html: String) -> Result<JsValue, JsValue> {
        let report = self
            .analyzer
            .run("http://unknown.local", Some(&html))
            .await
            .map_err(|e| convert_error(e))?;

        serde_wasm_bindgen::to_value(&report)
            .map_err(|e| JsValue::from_str(&format!("Serialization failed: {}", e)))
    }

    /// Analyze HTML with a specific URL context
    ///
    /// # Arguments
    /// * `url` - URL of the page (used for context, not fetched)
    /// * `html` - HTML content as string
    ///
    /// # Returns
    /// Promise that resolves to a PageQualityReport JSON object
    #[wasm_bindgen(js_name = analyzeWithUrl)]
    pub async fn analyze_with_url(&self, url: String, html: String) -> Result<JsValue, JsValue> {
        let report = self
            .analyzer
            .run(&url, Some(&html))
            .await
            .map_err(|e| convert_error(e))?;

        serde_wasm_bindgen::to_value(&report)
            .map_err(|e| JsValue::from_str(&format!("Serialization failed: {}", e)))
    }

    /// Fetch and analyze a URL using browser's fetch API
    ///
    /// # Arguments
    /// * `url` - URL to fetch and analyze
    ///
    /// # Returns
    /// Promise that resolves to a PageQualityReport JSON object
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const analyzer = new WasmAnalyzer();
    /// const report = await analyzer.fetchAndAnalyze('https://example.com');
    /// ```
    #[wasm_bindgen(js_name = fetchAndAnalyze)]
    pub async fn fetch_and_analyze(&self, url: String) -> Result<JsValue, JsValue> {
        let report = self
            .analyzer
            .run(&url, None) // None triggers fetch via WasmRuntime
            .await
            .map_err(|e| convert_error(e))?;

        serde_wasm_bindgen::to_value(&report)
            .map_err(|e| JsValue::from_str(&format!("Serialization failed: {}", e)))
    }

    /// Get available profile names
    ///
    /// # Returns
    /// Array of profile names as strings (from enhanced_profiles.json)
    #[wasm_bindgen(js_name = getAvailableProfiles)]
    pub fn get_available_profiles() -> Vec<String> {
        vec![
            "general".to_string(),
            "news".to_string(),
            "content_article".to_string(),
            "blog".to_string(),
            "product".to_string(),
            "login_page".to_string(),
            "homepage".to_string(),
            "portfolio".to_string(),
        ]
    }

    /// Get version information
    #[wasm_bindgen(js_name = getVersion)]
    pub fn get_version() -> String {
        env!("CARGO_PKG_VERSION").to_string()
    }
}

/// Batch analysis result container
#[wasm_bindgen]
pub struct WasmBatchResult {
    results: Vec<Result<PageQualityReport, AnalyzeError>>,
}

#[wasm_bindgen]
impl WasmBatchResult {
    /// Get number of results
    #[wasm_bindgen(js_name = getCount)]
    pub fn get_count(&self) -> usize {
        self.results.len()
    }

    /// Get number of successful analyses
    #[wasm_bindgen(js_name = getSuccessCount)]
    pub fn get_success_count(&self) -> usize {
        self.results.iter().filter(|r| r.is_ok()).count()
    }

    /// Get number of failed analyses
    #[wasm_bindgen(js_name = getFailureCount)]
    pub fn get_failure_count(&self) -> usize {
        self.results.iter().filter(|r| r.is_err()).count()
    }

    /// Get all results as JSON array
    ///
    /// Each element is either:
    /// - `{ success: true, report: PageQualityReport }`
    /// - `{ success: false, error: string }`
    #[wasm_bindgen(js_name = getResults)]
    pub fn get_results(&self) -> Result<JsValue, JsValue> {
        #[derive(Serialize)]
        #[serde(tag = "success")]
        enum BatchItem {
            #[serde(rename = "true")]
            Success { report: PageQualityReport },
            #[serde(rename = "false")]
            Failure { error: String },
        }

        let items: Vec<BatchItem> = self
            .results
            .iter()
            .map(|result| match result {
                Ok(report) => BatchItem::Success {
                    report: report.clone(),
                },
                Err(e) => BatchItem::Failure {
                    error: e.to_string(),
                },
            })
            .collect();

        serde_wasm_bindgen::to_value(&items)
            .map_err(|e| JsValue::from_str(&format!("Serialization failed: {}", e)))
    }
}

/// Batch analyzer for processing multiple HTML documents
#[wasm_bindgen]
pub struct WasmBatchAnalyzer {
    analyzer: Analyzer<WasmRuntime>,
}

#[wasm_bindgen]
impl WasmBatchAnalyzer {
    /// Create new batch analyzer
    #[wasm_bindgen(constructor)]
    pub fn new() -> Result<WasmBatchAnalyzer, JsValue> {
        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        let analyzer = Analyzer::<WasmRuntime>::builder()
            .build()
            .map_err(|e| JsValue::from_str(&format!("Failed to create analyzer: {}", e)))?;

        Ok(WasmBatchAnalyzer { analyzer })
    }

    /// Analyze multiple HTML documents in batch
    ///
    /// # Arguments
    /// * `html_documents` - Array of HTML strings
    ///
    /// # Returns
    /// Promise that resolves to WasmBatchResult
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const batch = new WasmBatchAnalyzer();
    /// const result = await batch.analyzeBatch([
    ///   '<html>page 1</html>',
    ///   '<html>page 2</html>',
    /// ]);
    /// console.log(`${result.getSuccessCount()} succeeded`);
    /// const reports = result.getResults();
    /// ```
    #[wasm_bindgen(js_name = analyzeBatch)]
    pub async fn analyze_batch(
        &self,
        html_documents: Vec<String>,
    ) -> Result<WasmBatchResult, JsValue> {
        let mut results = Vec::new();

        for html in html_documents {
            let result = self.analyzer.run("unknown", Some(&html)).await;
            results.push(result);
        }

        Ok(WasmBatchResult { results })
    }
}

// ============================================================================
// Phase 1: Custom Field Selection Support
// ============================================================================

/// WASM wrapper for FieldSelector - enables custom output field filtering
///
/// This allows JavaScript/TypeScript to select only specific fields from the
/// analysis report, reducing JSON payload size by 60-70% for production use.
///
/// # Example (JavaScript)
/// ```js
/// const analyzer = new WasmAnalyzer();
/// const report = await analyzer.analyzeWithFields(html, ['url', 'score', 'metadata']);
/// // Returns only the 3 requested fields
/// ```
#[wasm_bindgen]
pub struct WasmFieldSelector {
    include_fields: Vec<String>,
    exclude_fields: Vec<String>,
    include_sections: Vec<String>,
    exclude_sections: Vec<String>,
}

#[wasm_bindgen]
impl WasmFieldSelector {
    /// Create a new empty field selector
    #[wasm_bindgen(constructor)]
    pub fn new() -> WasmFieldSelector {
        WasmFieldSelector {
            include_fields: Vec::new(),
            exclude_fields: Vec::new(),
            include_sections: Vec::new(),
            exclude_sections: Vec::new(),
        }
    }

    /// Add fields to include (chainable)
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const selector = new WasmFieldSelector()
    ///   .includeFields(['url', 'score', 'metadata']);
    /// ```
    #[wasm_bindgen(js_name = includeFields)]
    pub fn include_fields(mut self, fields: Vec<String>) -> Self {
        self.include_fields.extend(fields);
        self
    }

    /// Add fields to exclude (chainable)
    #[wasm_bindgen(js_name = excludeFields)]
    pub fn exclude_fields(mut self, fields: Vec<String>) -> Self {
        self.exclude_fields.extend(fields);
        self
    }

    /// Add sections to include (chainable)
    #[wasm_bindgen(js_name = includeSections)]
    pub fn include_sections(mut self, sections: Vec<String>) -> Self {
        self.include_sections.extend(sections);
        self
    }

    /// Add sections to exclude (chainable)
    #[wasm_bindgen(js_name = excludeSections)]
    pub fn exclude_sections(mut self, sections: Vec<String>) -> Self {
        self.exclude_sections.extend(sections);
        self
    }

    /// Convert to internal FieldSelector
    fn to_field_selector(&self) -> crate::utils::json_optimizer::FieldSelector {
        use crate::utils::json_optimizer::FieldSelector;

        let mut builder = FieldSelector::builder();

        if !self.include_fields.is_empty() {
            builder = builder.include_fields(self.include_fields.clone());
        }

        if !self.exclude_fields.is_empty() {
            builder = builder.exclude_fields(self.exclude_fields.clone());
        }

        if !self.include_sections.is_empty() {
            builder = builder.include_sections(self.include_sections.clone());
        }

        if !self.exclude_sections.is_empty() {
            builder = builder.exclude_sections(self.exclude_sections.clone());
        }

        builder.build()
    }
}

#[wasm_bindgen]
impl WasmAnalyzer {
    /// Analyze HTML with custom field selection
    ///
    /// This method allows you to select only specific fields from the analysis
    /// report, reducing bandwidth usage by 60-70% for production deployments.
    ///
    /// # Arguments
    /// * `html` - HTML content to analyze
    /// * `fields` - Array of field names to include (e.g., ['url', 'score', 'metadata'])
    ///
    /// # Returns
    /// Promise that resolves to a filtered PageQualityReport with only requested fields
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const analyzer = new WasmAnalyzer();
    /// const report = await analyzer.analyzeWithFields(html, [
    ///   'url',
    ///   'score',
    ///   'metadata',
    ///   'processed_document'
    /// ]);
    /// // Returns only these 4 fields (60-70% smaller JSON)
    /// ```
    #[wasm_bindgen(js_name = analyzeWithFields)]
    pub async fn analyze_with_fields(
        &self,
        html: String,
        fields: Vec<String>,
    ) -> Result<JsValue, JsValue> {
        use crate::utils::json_optimizer::{
            FieldSelector, OptimizedSerializer, SerializationOptions,
        };

        // Run full analysis
        let report = self
            .analyzer
            .run("unknown", Some(&html))
            .await
            .map_err(|e| convert_error(e))?;

        // Build field selector from provided fields
        let selector = FieldSelector::builder().include_fields(fields).build();

        // Serialize with field selection (minimal format for bandwidth)
        let opts = SerializationOptions::minimal();
        let json = OptimizedSerializer::serialize_with_selector(&report, &selector, Some(&opts))
            .map_err(|e| JsValue::from_str(&format!("Serialization failed: {}", e)))?;

        // Parse JSON string back to JsValue for JavaScript consumption
        let json_value: serde_json::Value = serde_json::from_str(&json)
            .map_err(|e| JsValue::from_str(&format!("JSON parse failed: {}", e)))?;

        serde_wasm_bindgen::to_value(&json_value)
            .map_err(|e| JsValue::from_str(&format!("WASM serialization failed: {}", e)))
    }

    /// Analyze HTML with advanced field selector
    ///
    /// Provides full control over field selection including sections,
    /// include/exclude rules, and nested field access.
    ///
    /// # Arguments
    /// * `html` - HTML content to analyze
    /// * `selector` - WasmFieldSelector with custom rules
    ///
    /// # Returns
    /// Promise that resolves to a filtered PageQualityReport
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const selector = new WasmFieldSelector()
    ///   .includeFields(['url', 'score'])
    ///   .includeSections(['metadata'])
    ///   .excludeFields(['metadata.og_tags']);
    ///
    /// const report = await analyzer.analyzeWithSelector(html, selector);
    /// ```
    #[wasm_bindgen(js_name = analyzeWithSelector)]
    pub async fn analyze_with_selector(
        &self,
        html: String,
        selector: &WasmFieldSelector,
    ) -> Result<JsValue, JsValue> {
        use crate::utils::json_optimizer::{OptimizedSerializer, SerializationOptions};

        // Run full analysis
        let report = self
            .analyzer
            .run("unknown", Some(&html))
            .await
            .map_err(|e| convert_error(e))?;

        // Convert WASM selector to internal selector
        let field_selector = selector.to_field_selector();

        // Serialize with field selection
        let opts = SerializationOptions::minimal();
        let json =
            OptimizedSerializer::serialize_with_selector(&report, &field_selector, Some(&opts))
                .map_err(|e| JsValue::from_str(&format!("Serialization failed: {}", e)))?;

        // Parse JSON string back to JsValue
        let json_value: serde_json::Value = serde_json::from_str(&json)
            .map_err(|e| JsValue::from_str(&format!("JSON parse failed: {}", e)))?;

        serde_wasm_bindgen::to_value(&json_value)
            .map_err(|e| JsValue::from_str(&format!("WASM serialization failed: {}", e)))
    }
}

#[wasm_bindgen]
impl WasmBatchAnalyzer {
    /// Analyze batch with custom field selection
    ///
    /// Analyze multiple HTML documents and return only selected fields,
    /// optimizing bandwidth for production batch processing.
    ///
    /// # Arguments
    /// * `html_documents` - Array of HTML strings
    /// * `fields` - Array of field names to include
    ///
    /// # Returns
    /// Promise that resolves to array of filtered reports
    #[wasm_bindgen(js_name = analyzeBatchWithFields)]
    pub async fn analyze_batch_with_fields(
        &self,
        html_documents: Vec<String>,
        fields: Vec<String>,
    ) -> Result<JsValue, JsValue> {
        use crate::utils::json_optimizer::{
            FieldSelector, OptimizedSerializer, SerializationOptions,
        };

        let mut reports = Vec::new();

        // Analyze all documents
        for html in html_documents {
            match self.analyzer.run("unknown", Some(&html)).await {
                Ok(report) => reports.push(report),
                Err(_) => continue, // Skip failed analyses
            }
        }

        // Build field selector
        let selector = FieldSelector::builder().include_fields(fields).build();

        // Serialize batch with field selection
        let opts = SerializationOptions {
            compact: true,
            skip_empty_fields: true,
            minimal_output: false,
            streaming: true,
            buffer_size: 16384,
        };

        let json =
            OptimizedSerializer::serialize_batch_with_selector(&reports, &selector, Some(&opts))
                .map_err(|e| JsValue::from_str(&format!("Batch serialization failed: {}", e)))?;

        // Parse JSON string back to JsValue
        let json_value: serde_json::Value = serde_json::from_str(&json)
            .map_err(|e| JsValue::from_str(&format!("JSON parse failed: {}", e)))?;

        serde_wasm_bindgen::to_value(&json_value)
            .map_err(|e| JsValue::from_str(&format!("WASM serialization failed: {}", e)))
    }
}

// ============================================================================
// Phase 2: Config File Loading Support
// ============================================================================

#[wasm_bindgen]
impl WasmAnalyzer {
    /// Create analyzer from JSON configuration
    ///
    /// Since WASM cannot directly read files, pass the config as a JSON string.
    /// In browser environments, fetch the config file and pass its content.
    ///
    /// # Arguments
    /// * `config_json` - JSON string containing profile configuration
    ///
    /// # Returns
    /// New WasmAnalyzer configured with the provided settings
    ///
    /// # Example (JavaScript - Browser)
    /// ```js
    /// const configJson = await fetch('/configs/my-config.json').then(r => r.text());
    /// const analyzer = WasmAnalyzer.fromConfig(configJson);
    /// ```
    ///
    /// # Example (JavaScript - Node.js)
    /// ```js
    /// const fs = require('fs');
    /// const configJson = fs.readFileSync('config.json', 'utf-8');
    /// const analyzer = WasmAnalyzer.fromConfig(configJson);
    /// ```
    #[wasm_bindgen(js_name = fromConfig)]
    pub fn from_config(config_json: String) -> Result<WasmAnalyzer, JsValue> {
        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        // Parse JSON to extract profile name
        // Expected format: { "profile": "news", "enable_nlp": true, ... }
        let config_value: serde_json::Value = serde_json::from_str(&config_json)
            .map_err(|e| JsValue::from_str(&format!("Invalid JSON: {}", e)))?;

        // Extract profile name (default to 'general' if not specified)
        let profile_name = config_value["profile"].as_str().unwrap_or("general");

        // Build analyzer with profile name
        let analyzer = Analyzer::<WasmRuntime>::builder()
            .with_profile_name(profile_name)
            .map_err(|e| JsValue::from_str(&format!("Failed to set profile: {}", e)))?
            .build()
            .map_err(|e| JsValue::from_str(&format!("Failed to create analyzer: {}", e)))?;

        Ok(WasmAnalyzer { analyzer })
    }

    /// Get the current profile configuration as JSON string
    ///
    /// Returns the active profile configuration, which can be:
    /// - Saved to a file
    /// - Modified and reloaded
    /// - Shared across team members
    ///
    /// # Returns
    /// JSON string of the current ProfileConfig
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const analyzer = new WasmAnalyzer();
    /// const configJson = analyzer.getConfig();
    /// console.log('Current config:', JSON.parse(configJson));
    ///
    /// // Save to file or modify
    /// localStorage.setItem('analyzer-config', configJson);
    /// ```
    #[wasm_bindgen(js_name = getConfig)]
    pub fn get_config(&self) -> Result<String, JsValue> {
        // Get the profile config from analyzer (requires exposing it in Analyzer struct)
        // For now, return a placeholder - need to add config getter to Analyzer
        Err(JsValue::from_str(
            "getConfig not yet implemented - requires Analyzer to expose config",
        ))
    }
}

// ============================================================================
// Phase 3: Per-Metric Configuration & Builder Pattern
// ============================================================================

/// WASM Analyzer Builder for advanced configuration
///
/// Provides a fluent API for customizing analyzer behavior including:
/// - Profile selection
/// - Metric toggling (enable/disable specific metrics)
/// - Custom thresholds per metric
/// - NLP and grammar features
///
/// # Example (JavaScript)
/// ```js
/// const analyzer = WasmAnalyzer.builder()
///   .withProfile('news')
///   .disableMetric('grammar_score')  // Skip expensive grammar checking
///   .setThreshold('word_count', 500, 2000, 5000)
///   .enableNlp(true)
///   .build();
/// ```
#[wasm_bindgen]
pub struct WasmAnalyzerBuilder {
    profile: Option<String>,
    enabled_metrics: Vec<String>,
    disabled_metrics: Vec<String>,
    custom_thresholds: Vec<(String, f32, f32, f32, f32)>, // (metric, min, optimal_min, optimal_max, max)
    metric_weights: Vec<(String, f32)>,                   // (metric, weight) - Phase 4
    custom_penalties: Vec<crate::config::enhanced_models::GlobalPenalty>, // Phase 5
    custom_bonuses: Vec<crate::config::enhanced_models::GlobalBonus>, // Phase 5
    enable_nlp: bool,
    enable_link_check: bool, // Phase 6
    add_report: bool,
}

#[wasm_bindgen]
impl WasmAnalyzerBuilder {
    /// Create a new builder with default settings
    #[wasm_bindgen(constructor)]
    pub fn new() -> WasmAnalyzerBuilder {
        WasmAnalyzerBuilder {
            profile: None,
            enabled_metrics: Vec::new(),
            disabled_metrics: Vec::new(),
            custom_thresholds: Vec::new(),
            metric_weights: Vec::new(),   // Phase 4
            custom_penalties: Vec::new(), // Phase 5
            custom_bonuses: Vec::new(),   // Phase 5
            enable_nlp: true,
            enable_link_check: false, // Phase 6 - disabled by default (CORS issues in browser)
            add_report: true,
        }
    }

    /// Set the profile to use (chainable)
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .withProfile('news');
    /// ```
    #[wasm_bindgen(js_name = withProfile)]
    pub fn with_profile(mut self, profile: String) -> Self {
        self.profile = Some(profile);
        self
    }

    /// Enable a specific metric (chainable)
    ///
    /// By default, all metrics in the profile are enabled. Use this to
    /// explicitly enable a metric that might be disabled in the profile.
    ///
    /// # Arguments
    /// * `metric_name` - Name of metric (e.g., "word_count", "image_count")
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .enableMetric('word_count')
    ///   .enableMetric('readability_score');
    /// ```
    #[wasm_bindgen(js_name = enableMetric)]
    pub fn enable_metric(mut self, metric_name: String) -> Self {
        self.enabled_metrics.push(metric_name);
        self
    }

    /// Disable a specific metric (chainable)
    ///
    /// Disabling metrics can improve performance by skipping expensive
    /// calculations you don't need.
    ///
    /// # Arguments
    /// * `metric_name` - Name of metric to disable
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .disableMetric('grammar_score')  // Skip grammar checking
    ///   .disableMetric('link_check');     // Skip external link validation
    /// ```
    #[wasm_bindgen(js_name = disableMetric)]
    pub fn disable_metric(mut self, metric_name: String) -> Self {
        self.disabled_metrics.push(metric_name);
        self
    }

    /// Set custom threshold for a metric (chainable)
    ///
    /// Customize the thresholds used for scoring a metric with full control
    /// over the scoring curve.
    ///
    /// Thresholds define the scoring curve:
    /// - `min`: Below this value, score is 0
    /// - `optimal_min`: Start of optimal range (100% score)
    /// - `optimal_max`: End of optimal range (100% score)
    /// - `max`: Above this value, score doesn't improve
    ///
    /// # Arguments
    /// * `metric_name` - Name of the metric
    /// * `min` - Minimum acceptable value
    /// * `optimal_min` - Start of optimal range
    /// * `optimal_max` - End of optimal range
    /// * `max` - Maximum useful value
    ///
    /// # Validation
    /// Thresholds must satisfy: min < optimal_min <= optimal_max < max
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .setThreshold(
    ///     'word_count',
    ///     100,    // min - articles < 100 words score poorly
    ///     500,    // optimal_min - ideal range starts
    ///     2000,   // optimal_max - ideal range ends
    ///     5000    // max - diminishing returns after this
    ///   );
    /// ```
    #[wasm_bindgen(js_name = setThreshold)]
    pub fn set_threshold(
        mut self,
        metric_name: String,
        min: f32,
        optimal_min: f32,
        optimal_max: f32,
        max: f32,
    ) -> Self {
        self.custom_thresholds
            .push((metric_name, min, optimal_min, optimal_max, max));
        self
    }

    /// Set simple threshold for a metric (chainable)
    ///
    /// Convenience method for metrics with a single optimal value rather than a range.
    /// This creates optimal_min == optimal_max.
    ///
    /// # Arguments
    /// * `metric_name` - Name of the metric
    /// * `min` - Minimum acceptable value
    /// * `optimal` - Single optimal value (100% score)
    /// * `max` - Maximum useful value
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .setSimpleThreshold(
    ///     'title_len',
    ///     30,   // min - titles < 30 chars are poor
    ///     60,   // optimal - 60 chars is perfect
    ///     120   // max - longer titles don't help
    ///   );
    /// ```
    #[wasm_bindgen(js_name = setSimpleThreshold)]
    pub fn set_simple_threshold(
        mut self,
        metric_name: String,
        min: f32,
        optimal: f32,
        max: f32,
    ) -> Self {
        self.custom_thresholds
            .push((metric_name, min, optimal, optimal, max));
        self
    }

    /// Set custom weight for a metric (chainable)
    ///
    /// Weights control the relative importance of metrics in scoring.
    /// Default weight is 1.0. Use >1.0 to increase importance, <1.0 to decrease.
    ///
    /// # Arguments
    /// * `metric_name` - Name of the metric to adjust
    /// * `weight` - Multiplier for metric's contribution (0.0-10.0, typically 0.1-3.0)
    ///
    /// # Weight Guidelines
    /// * 0.0 - Disables the metric
    /// * 0.1-0.5 - Significantly reduce importance
    /// * 0.5-0.9 - Moderately reduce importance
    /// * 1.0 - Default (unchanged)
    /// * 1.1-2.0 - Moderately increase importance
    /// * 2.0-3.0 - Significantly increase importance
    /// * >3.0 - Extreme emphasis (use sparingly)
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .setMetricWeight('seo_title_quality', 2.0)  // Double SEO importance
    ///   .setMetricWeight('grammar_score', 0.5);     // Reduce grammar weight
    /// ```
    #[wasm_bindgen(js_name = setMetricWeight)]
    pub fn set_metric_weight(mut self, metric_name: String, weight: f32) -> Self {
        self.metric_weights.push((metric_name, weight));
        self
    }

    // ============================================================================
    // Phase 5: Custom Penalties & Bonuses APIs (WASM)
    // ============================================================================

    /// Add a penalty that reduces score when metric falls below threshold
    ///
    /// Penalties help enforce content quality standards by automatically reducing
    /// scores when important metrics don't meet expectations.
    ///
    /// # Parameters
    /// - `penalty_id`: Unique identifier for this penalty
    /// - `metric`: Metric name to monitor (e.g., "word_count", "heading_depth")
    /// - `threshold`: Trigger penalty when metric value is below this
    /// - `penalty_points`: Number of points to subtract (0-100)
    /// - `description`: Human-readable explanation
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .withProfile('content_article')
    ///   .addPenaltyBelow('short_content', 'word_count', 300, 10, 'Content too short')
    ///   .addPenaltyBelow('shallow_structure', 'heading_depth', 2, 5, 'Insufficient headings');
    /// ```
    #[wasm_bindgen(js_name = addPenaltyBelow)]
    pub fn add_penalty_below(
        mut self,
        penalty_id: String,
        metric: String,
        threshold: f32,
        penalty_points: f32,
        description: String,
    ) -> Self {
        use crate::config::enhanced_models::{GlobalPenalty, PenaltyTrigger, PenaltyType};

        let penalty = GlobalPenalty {
            trigger_condition: PenaltyTrigger::MetricBelow { metric, threshold },
            penalty_type: PenaltyType::FixedPoints {
                points: penalty_points,
            },
            description: format!("{} (ID: {})", description, penalty_id),
            enabled: true,
        };

        self.custom_penalties.push(penalty);
        self
    }

    /// Add a penalty that reduces score when metric exceeds threshold
    ///
    /// Useful for penalizing excessive values (e.g., too many links, overly long titles).
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .addPenaltyAbove('title_too_long', 'title_len', 70, 5, 'Title too long for SEO');
    /// ```
    #[wasm_bindgen(js_name = addPenaltyAbove)]
    pub fn add_penalty_above(
        mut self,
        penalty_id: String,
        metric: String,
        threshold: f32,
        penalty_points: f32,
        description: String,
    ) -> Self {
        use crate::config::enhanced_models::{GlobalPenalty, PenaltyTrigger, PenaltyType};

        let penalty = GlobalPenalty {
            trigger_condition: PenaltyTrigger::MetricAbove { metric, threshold },
            penalty_type: PenaltyType::FixedPoints {
                points: penalty_points,
            },
            description: format!("{} (ID: {})", description, penalty_id),
            enabled: true,
        };

        self.custom_penalties.push(penalty);
        self
    }

    /// Add a bonus that increases score when metric exceeds excellence threshold
    ///
    /// Bonuses reward exceptional quality, comprehensiveness, or excellence.
    ///
    /// # Parameters
    /// - `bonus_id`: Unique identifier for this bonus
    /// - `metric`: Metric name to monitor
    /// - `threshold`: Grant bonus when metric value exceeds this
    /// - `bonus_points`: Number of points to add (0-50 recommended)
    /// - `description`: Human-readable explanation
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .withProfile('content_article')
    ///   .addBonusAbove('comprehensive', 'word_count', 2000, 5, 'Comprehensive content')
    ///   .addBonusAbove('deep_structure', 'heading_depth', 4, 3, 'Excellent organization');
    /// ```
    #[wasm_bindgen(js_name = addBonusAbove)]
    pub fn add_bonus_above(
        mut self,
        bonus_id: String,
        metric: String,
        threshold: f32,
        bonus_points: f32,
        description: String,
    ) -> Self {
        use crate::config::enhanced_models::{BonusTrigger, GlobalBonus};

        let bonus = GlobalBonus {
            trigger_condition: BonusTrigger::MetricExcellence { metric, threshold },
            bonus_points,
            description: format!("{} (ID: {})", description, bonus_id),
            enabled: true,
        };

        self.custom_bonuses.push(bonus);
        self
    }

    /// Add a bonus when multiple metrics are all above thresholds
    ///
    /// Creates a synergy bonus that rewards consistent quality across metrics.
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .addBonusMultiple(
    ///     'seo_excellence',
    ///     ['title_len', 'meta_desc_len', 'heading_depth'],
    ///     50,
    ///     5,
    ///     'Excellent SEO across the board'
    ///   );
    /// ```
    #[wasm_bindgen(js_name = addBonusMultiple)]
    pub fn add_bonus_multiple(
        mut self,
        bonus_id: String,
        metrics: Vec<String>,
        threshold: f32,
        bonus_points: f32,
        description: String,
    ) -> Self {
        use crate::config::enhanced_models::{BonusTrigger, GlobalBonus};

        let bonus = GlobalBonus {
            trigger_condition: BonusTrigger::MultipleMetricsGood { metrics, threshold },
            bonus_points,
            description: format!("{} (ID: {})", description, bonus_id),
            enabled: true,
        };

        self.custom_bonuses.push(bonus);
        self
    }

    // End Phase 5 APIs

    /// Enable or disable NLP features (chainable)
    ///
    /// NLP features include language detection and keyword extraction.
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .enableNlp(false);  // Disable for faster processing
    /// ```
    #[wasm_bindgen(js_name = enableNlp)]
    pub fn enable_nlp(mut self, enable: bool) -> Self {
        self.enable_nlp = enable;
        self
    }

    /// Enable or disable link checking (chainable)
    ///
    /// Note: Link checking in WASM uses browser fetch API and may be subject
    /// to CORS restrictions. Only works when 'linkcheck' feature is enabled.
    ///
    /// # Example
    /// ```js
    /// const builder = new WasmAnalyzerBuilder()
    ///   .enableLinkCheck(true);  // Enable link validation
    /// ```
    #[wasm_bindgen(js_name = enableLinkCheck)]
    pub fn enable_link_check(mut self, enable: bool) -> Self {
        self.enable_link_check = enable;
        self
    }

    /// Enable or disable detailed report sections (chainable)
    #[wasm_bindgen(js_name = addReport)]
    pub fn add_report(mut self, add: bool) -> Self {
        self.add_report = add;
        self
    }

    // ============================================================================
    // Configuration Loading Methods (WASM Alternative to from_config_file)
    // ============================================================================

    /// Load configuration from JSON string (WASM alternative to from_config_file)
    ///
    /// Since WASM doesn't have file system access, use this method to load
    /// configuration from a JSON string instead. You can fetch the config via
    /// HTTP or embed it in your JavaScript code.
    ///
    /// # Parameters
    /// - `config_json`: JSON string containing the configuration
    ///
    /// # Returns
    /// New WasmAnalyzer instance configured from the JSON
    ///
    /// # Example (JavaScript)
    /// ```js
    /// // Fetch config from server
    /// const configResponse = await fetch('/config/analyzer-config.json');
    /// const configJson = await configResponse.text();
    /// const analyzer = WasmAnalyzerBuilder.fromConfigJson(configJson);
    ///
    /// // Or use embedded config
    /// const config = JSON.stringify({
    ///   active_profile: "news",
    ///   presets: {
    ///     news: {
    ///       category_weights: { content: 2.0, seo: 1.5 }
    ///     }
    ///   }
    /// });
    /// const analyzer = WasmAnalyzerBuilder.fromConfigJson(config);
    /// ```
    #[wasm_bindgen(js_name = fromConfigJson)]
    pub fn from_config_json(config_json: &str) -> Result<WasmAnalyzer, JsValue> {
        use crate::config::config_manager::{ConfigFormat, ConfigManager};

        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        // Parse JSON config
        let config_manager = ConfigManager::from_str(config_json, ConfigFormat::Json)
            .map_err(|e| JsValue::from_str(&format!("Failed to parse JSON config: {}", e)))?;

        // Build analyzer with config
        let analyzer = Analyzer::<WasmRuntime>::builder()
            .with_config_manager(config_manager)
            .build()
            .map_err(|e| {
                JsValue::from_str(&format!("Failed to build analyzer from config: {}", e))
            })?;

        Ok(WasmAnalyzer { analyzer })
    }

    /// Load configuration from YAML string (WASM alternative to from_config_file)
    ///
    /// Since WASM doesn't have file system access, use this method to load
    /// configuration from a YAML string instead.
    ///
    /// # Parameters
    /// - `config_yaml`: YAML string containing the configuration
    ///
    /// # Returns
    /// New WasmAnalyzer instance configured from the YAML
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const configYaml = `
    /// active_profile: content_article
    /// presets:
    ///   content_article:
    ///     category_weights:
    ///       content: 2.0
    ///       seo: 1.5
    /// `;
    /// const analyzer = WasmAnalyzerBuilder.fromConfigYaml(configYaml);
    /// ```
    #[wasm_bindgen(js_name = fromConfigYaml)]
    pub fn from_config_yaml(config_yaml: &str) -> Result<WasmAnalyzer, JsValue> {
        use crate::config::config_manager::{ConfigFormat, ConfigManager};

        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        // Parse YAML config
        let config_manager = ConfigManager::from_str(config_yaml, ConfigFormat::Yaml)
            .map_err(|e| JsValue::from_str(&format!("Failed to parse YAML config: {}", e)))?;

        // Build analyzer with config
        let analyzer = Analyzer::<WasmRuntime>::builder()
            .with_config_manager(config_manager)
            .build()
            .map_err(|e| {
                JsValue::from_str(&format!("Failed to build analyzer from config: {}", e))
            })?;

        Ok(WasmAnalyzer { analyzer })
    }

    /// Load configuration from TOML string (WASM alternative to from_config_file)
    ///
    /// Since WASM doesn't have file system access, use this method to load
    /// configuration from a TOML string instead.
    ///
    /// # Parameters
    /// - `config_toml`: TOML string containing the configuration
    ///
    /// # Returns
    /// New WasmAnalyzer instance configured from the TOML
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const configToml = `
    /// active_profile = "blog"
    ///
    /// [presets.blog]
    /// [presets.blog.category_weights]
    /// content = 2.0
    /// seo = 1.5
    /// `;
    /// const analyzer = WasmAnalyzerBuilder.fromConfigToml(configToml);
    /// ```
    #[wasm_bindgen(js_name = fromConfigToml)]
    pub fn from_config_toml(config_toml: &str) -> Result<WasmAnalyzer, JsValue> {
        use crate::config::config_manager::{ConfigFormat, ConfigManager};

        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        // Parse TOML config
        let config_manager = ConfigManager::from_str(config_toml, ConfigFormat::Toml)
            .map_err(|e| JsValue::from_str(&format!("Failed to parse TOML config: {}", e)))?;

        // Build analyzer with config
        let analyzer = Analyzer::<WasmRuntime>::builder()
            .with_config_manager(config_manager)
            .build()
            .map_err(|e| {
                JsValue::from_str(&format!("Failed to build analyzer from config: {}", e))
            })?;

        Ok(WasmAnalyzer { analyzer })
    }

    // End Configuration Loading Methods

    /// Build the analyzer with configured settings
    ///
    /// # Returns
    /// WasmAnalyzer instance with custom configuration
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const analyzer = new WasmAnalyzerBuilder()
    ///   .withProfile('news')
    ///   .disableMetric('grammar_score')
    ///   .setThreshold('word_count', 500, 2000, 5000)
    ///   .build();
    ///
    /// const report = await analyzer.analyze(html);
    /// ```
    #[wasm_bindgen]
    pub fn build(self) -> Result<WasmAnalyzer, JsValue> {
        #[cfg(feature = "console_error_panic_hook")]
        console_error_panic_hook::set_once();

        let mut builder = Analyzer::<WasmRuntime>::builder();

        // Set profile if specified
        if let Some(profile_name) = self.profile {
            builder = builder.with_profile_name(&profile_name).map_err(|e| {
                JsValue::from_str(&format!("Invalid profile '{}': {}", profile_name, e))
            })?;
        }

        // Phase 2: Apply enabled/disabled metrics
        for metric_name in &self.enabled_metrics {
            builder = builder.enable_metric(metric_name).map_err(|e| {
                JsValue::from_str(&format!("Failed to enable metric '{}': {}", metric_name, e))
            })?;
        }

        for metric_name in &self.disabled_metrics {
            builder = builder.disable_metric(metric_name).map_err(|e| {
                JsValue::from_str(&format!(
                    "Failed to disable metric '{}': {}",
                    metric_name, e
                ))
            })?;
        }

        // Phase 3: Apply custom thresholds
        for (metric_name, min, optimal_min, optimal_max, max) in self.custom_thresholds {
            builder = builder
                .set_metric_threshold(&metric_name, min, optimal_min, optimal_max, max)
                .map_err(|e| {
                    JsValue::from_str(&format!(
                        "Failed to set threshold for '{}': {}",
                        metric_name, e
                    ))
                })?;
        }

        // Phase 4: Apply custom metric weights
        for (metric_name, weight) in self.metric_weights {
            builder = builder
                .set_metric_weight(&metric_name, weight)
                .map_err(|e| {
                    JsValue::from_str(&format!(
                        "Failed to set weight for '{}': {}",
                        metric_name, e
                    ))
                })?;
        }

        // Phase 5: Apply custom penalties and bonuses
        for penalty in self.custom_penalties {
            builder = builder
                .add_penalty(penalty)
                .map_err(|e| JsValue::from_str(&format!("Failed to add penalty: {}", e)))?;
        }

        for bonus in self.custom_bonuses {
            builder = builder
                .add_bonus(bonus)
                .map_err(|e| JsValue::from_str(&format!("Failed to add bonus: {}", e)))?;
        }

        #[cfg(feature = "nlp")]
        {
            builder = builder.enable_nlp(self.enable_nlp);
        }

        // Phase 6: Apply link check setting (if feature enabled)
        #[cfg(feature = "linkcheck")]
        {
            builder = builder.enable_linkcheck(self.enable_link_check);
        }

        builder = builder.add_report(self.add_report);

        let analyzer = builder
            .build()
            .map_err(|e| JsValue::from_str(&format!("Failed to build analyzer: {}", e)))?;

        Ok(WasmAnalyzer { analyzer })
    }
}

#[wasm_bindgen]
impl WasmAnalyzer {
    /// Create a builder for advanced analyzer configuration
    ///
    /// # Returns
    /// WasmAnalyzerBuilder for fluent configuration
    ///
    /// # Example (JavaScript)
    /// ```js
    /// const analyzer = WasmAnalyzer.builder()
    ///   .withProfile('news')
    ///   .disableMetric('grammar_score')
    ///   .build();
    /// ```
    #[wasm_bindgen]
    pub fn builder() -> WasmAnalyzerBuilder {
        WasmAnalyzerBuilder::new()
    }
}

/// Helper function to convert AnalyzeError to JsValue with better error messages
fn convert_error(error: AnalyzeError) -> JsValue {
    let error_msg = match error {
        AnalyzeError::InvalidUrl(msg) => format!("Invalid URL: {}", msg),
        AnalyzeError::NetworkError(msg) => format!("Network error: {}", msg),
        AnalyzeError::ParseError(msg) => format!("Parse error: {}", msg),
        AnalyzeError::ConfigError(msg) => format!("Configuration error: {}", msg),
        AnalyzeError::AnalysisError(msg) => format!("Analysis error: {}", msg),
        _ => format!("Error: {}", error),
    };

    JsValue::from_str(&error_msg)
}

/// Initialize the WASM module (call this once when loading)
///
/// Sets up panic hooks and other initialization
#[wasm_bindgen(start)]
pub fn init() {
    #[cfg(feature = "console_error_panic_hook")]
    console_error_panic_hook::set_once();

    // Optional: Set up custom logger for web console
    #[cfg(feature = "wasm-logger")]
    wasm_logger::init(wasm_logger::Config::default());
}

/// Get the library version
#[wasm_bindgen(js_name = getVersion)]
pub fn get_version() -> String {
    env!("CARGO_PKG_VERSION").to_string()
}

/// Get version changelog for current version
#[wasm_bindgen(js_name = getVersionChangelog)]
pub fn get_version_changelog() -> String {
    format!(
        "v{} - Profile scoring improvements:\n\
         - Product profile: Reverted to e-commerce focus (breaking change)\n\
         - Login page: Stricter validation (Forms: 40% weight)\n\
         - Homepage/General: More balanced scoring with new bonuses\n\
         - Fixed: MetricEquals penalty trigger implementation\n\
         See CHANGELOG.md for full details.",
        env!("CARGO_PKG_VERSION")
    )
}

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

    #[test]
    fn test_config_creation() {
        let config = WasmAnalyzerConfig::new();
        assert_eq!(config.profile, None);
        assert!(config.enable_nlp);
        assert!(config.add_report);
    }

    #[test]
    fn test_version() {
        let version = get_version();
        assert!(version.starts_with("1.0"));
    }

    #[test]
    fn test_profile_list() {
        let profiles = WasmAnalyzer::get_available_profiles();
        assert!(profiles.contains(&"default".to_string()));
        assert!(profiles.contains(&"news".to_string()));
        assert!(profiles.len() >= 6);
    }
}