reasonkit-core 0.1.8

//! Cross-Cultural Validation for Vibe Protocol
//!
//! Multi-language, multi-cultural validation system that detects and corrects
//! cultural biases, language context issues, and regional appropriateness.

use crate::vibe::{VIBEError, ValidationResult};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Cultural context configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CulturalConfig {
    /// Target languages for validation
    pub target_languages: Vec<String>,

    /// Target regions for cultural adaptation
    pub target_regions: Vec<String>,

    /// Cultural sensitivity threshold
    pub sensitivity_threshold: f32,

    /// Enable language translation validation
    pub enable_translation_validation: bool,

    /// Enable cultural bias detection
    pub enable_bias_detection: bool,

    /// Enable regional adaptation
    pub enable_regional_adaptation: bool,
}

impl Default for CulturalConfig {
    fn default() -> Self {
        Self {
            target_languages: vec!["en".to_string(), "es".to_string(), "fr".to_string()],
            target_regions: vec!["US".to_string(), "EU".to_string(), "Asia".to_string()],
            sensitivity_threshold: 0.8,
            enable_translation_validation: true,
            enable_bias_detection: true,
            enable_regional_adaptation: true,
        }
    }
}

/// Cultural validation result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CulturalValidationResult {
    /// Overall cultural appropriateness score
    pub cultural_score: f32,

    /// Language-specific scores
    pub language_scores: HashMap<String, f32>,

    /// Region-specific scores
    pub region_scores: HashMap<String, f32>,

    /// Detected cultural issues
    pub cultural_issues: Vec<CulturalIssue>,

    /// Cultural adaptation recommendations
    pub adaptation_recommendations: Vec<String>,

    /// Bias detection results
    pub bias_detection: Option<BiasAnalysis>,
}

/// Cultural issues detected during validation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CulturalIssue {
    /// Type of cultural issue
    pub issue_type: CulturalIssueType,

    /// Severity level
    pub severity: CulturalSeverity,

    /// Description of the issue
    pub description: String,

    /// Affected language/region
    pub affected_context: String,

    /// Suggested fix
    pub suggested_fix: String,
}

/// Types of cultural issues
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CulturalIssueType {
    LanguageContext,
    CulturalReference,
    RegionalNorm,
    ReligiousSensitivity,
    LegalCompliance,
    DemographicBias,
}

/// Severity levels for cultural issues
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CulturalSeverity {
    Low,
    Medium,
    High,
    Critical,
}

/// Bias analysis results
#[derive(Debug, Clone, Serialize, Serialize)]
pub struct BiasAnalysis {
    /// Overall bias score (lower is better)
    pub overall_bias_score: f32,

    /// Detected bias types
    pub bias_types: Vec<BiasType>,

    /// Bias mitigation strategies
    pub mitigation_strategies: Vec<String>,

    /// Bias impact assessment
    pub impact_assessment: BiasImpact,
}

/// Types of detected bias
#[derive(Debug, Clone, Serialize, Serialize)]
pub enum BiasType {
    GenderBias,
    RacialBias,
    AgeBias,
    CulturalBias,
    SocioeconomicBias,
    GeographicBias,
}

/// Bias impact assessment
#[derive(Debug, Clone, Serialize, Serialize)]
pub enum BiasImpact {
    Minimal,      // < 5% impact
    Moderate,     // 5-20% impact
    Significant,  // 20-50% impact
    Severe,       // > 50% impact
}

/// Cross-cultural validation engine
pub struct CulturalValidationEngine {
    config: CulturalConfig,
    language_databases: HashMap<String, LanguageDatabase>,
    cultural_databases: HashMap<String, CulturalDatabase>,
}

/// Language-specific validation database
#[derive(Debug, Clone)]
struct LanguageDatabase {
    language_code: String,
    grammar_rules: Vec<GrammarRule>,
    context_rules: Vec<ContextRule>,
    idioms: Vec<Idiom>,
}

/// Cultural-specific validation database
#[derive(Debug, Clone)]
struct CulturalDatabase {
    region_code: String,
    cultural_norms: Vec<CulturalNorm>,
    legal_requirements: Vec<LegalRequirement>,
    religious_considerations: Vec<ReligiousConsideration>,
}

/// Validation rules and data structures
#[derive(Debug, Clone)]
struct GrammarRule {
    pattern: String,
    validator: fn(&str) -> bool,
    description: String,
}

#[derive(Debug, Clone)]
struct ContextRule {
    context: String,
    validator: fn(&str, &str) -> bool,
    description: String,
}

#[derive(Debug, Clone)]
struct Idiom {
    idiom: String,
    meaning: String,
    cultural_context: String,
}

#[derive(Debug, Clone)]
struct CulturalNorm {
    norm: String,
    description: String,
    severity: CulturalSeverity,
}

#[derive(Debug, Clone)]
struct LegalRequirement {
    requirement: String,
    jurisdiction: String,
    description: String,
}

#[derive(Debug, Clone)]
struct ReligiousConsideration {
    consideration: String,
    religion: String,
    description: String,
}

impl CulturalValidationEngine {
    /// Create new cultural validation engine
    pub fn new(config: CulturalConfig) -> Result<Self, VIBEError> {
        let mut engine = Self {
            config,
            language_databases: HashMap::new(),
            cultural_databases: HashMap::new(),
        };

        // Initialize language databases
        engine.initialize_language_databases()?;

        // Initialize cultural databases
        engine.initialize_cultural_databases()?;

        Ok(engine)
    }

    /// Create with default configuration
    pub fn default() -> Result<Self, VIBEError> {
        Self::new(CulturalConfig::default())
    }

    /// Perform comprehensive cultural validation
    pub async fn validate_cultural(
        &self,
        protocol: &str,
        base_validation: ValidationResult,
    ) -> Result<CulturalValidationResult, VIBEError> {
        let mut cultural_score = base_validation.overall_score / 100.0;
        let mut language_scores = HashMap::new();
        let mut region_scores = HashMap::new();
        let mut cultural_issues = Vec::new();
        let mut adaptation_recommendations = Vec::new();

        // Language validation
        if self.config.enable_translation_validation {
            let language_analysis = self.validate_languages(protocol).await?;
            cultural_score = (cultural_score + language_analysis.overall_score) / 2.0;
            language_scores = language_analysis.language_scores;
            cultural_issues.extend(language_analysis.issues);
            adaptation_recommendations.extend(language_analysis.recommendations);
        }

        // Cultural bias detection
        let bias_analysis = if self.config.enable_bias_detection {
            Some(self.detect_cultural_bias(protocol).await?)
        } else {
            None
        };

        // Regional adaptation
        if self.config.enable_regional_adaptation {
            let regional_analysis = self.validate_regional(protocol).await?;
            cultural_score = (cultural_score + regional_analysis.overall_score) / 2.0;
            region_scores = regional_analysis.region_scores;
            cultural_issues.extend(regional_analysis.issues);
            adaptation_recommendations.extend(regional_analysis.recommendations);
        }

        Ok(CulturalValidationResult {
            cultural_score: cultural_score * 100.0,
            language_scores,
            region_scores,
            cultural_issues,
            adaptation_recommendations,
            bias_detection: bias_analysis,
        })
    }

    /// Validate protocol across multiple languages
    async fn validate_languages(
        &self,
        protocol: &str,
    ) -> Result<LanguageAnalysis, VIBEError> {
        let mut language_scores = HashMap::new();
        let mut issues = Vec::new();
        let mut recommendations = Vec::new();

        for language in &self.config.target_languages {
            if let Some(database) = self.language_databases.get(language) {
                let score = self.validate_single_language(protocol, database).await?;
                language_scores.insert(language.clone(), score);

                // Generate language-specific recommendations
                if score < self.config.sensitivity_threshold {
                    recommendations.push(format!(
                        "Consider cultural adaptation for {} language",
                        language
                    ));
                }
            }
        }

        let overall_score = language_scores.values().sum::<f32>()
            / language_scores.len() as f32;

        Ok(LanguageAnalysis {
            overall_score,
            language_scores,
            issues,
            recommendations,
        })
    }

    /// Validate single language
    async fn validate_single_language(
        &self,
        protocol: &str,
        database: &LanguageDatabase,
    ) -> Result<f32, VIBEError> {
        // Simplified language validation
        let mut score = 0.8; // Base score

        // Check for language-specific patterns
        for rule in &database.grammar_rules {
            if protocol.contains(&rule.pattern) {
                score += 0.05; // Positive if pattern found
            }
        }

        // Check for potential issues
        for idiom in &database.idioms {
            if protocol.contains(&idiom.idiom) {
                score -= 0.1; // Deduct for cultural idioms without context
            }
        }

        Ok(score.min(1.0).max(0.0))
    }

    /// Detect cultural bias in protocol
    async fn detect_cultural_bias(&self, protocol: &str) -> Result<BiasAnalysis, VIBEError> {
        let mut bias_types = Vec::new();
        let mut mitigation_strategies = Vec::new();

        // Simplified bias detection
        let bias_keywords = [
            ("gender", BiasType::GenderBias),
            ("race", BiasType::RacialBias),
            ("age", BiasType::AgeBias),
            ("culture", BiasType::CulturalBias),
            ("socioeconomic", BiasType::SocioeconomicBias),
            ("geographic", BiasType::GeographicBias),
        ];

        let mut bias_score = 1.0;

        for (keyword, bias_type) in &bias_keywords {
            if protocol.to_lowercase().contains(keyword) {
                bias_types.push(bias_type.clone());
                bias_score -= 0.1;
                mitigation_strategies.push(format!(
                    "Review {} bias considerations",
                    keyword
                ));
            }
        }

        let impact_assessment = if bias_score > 0.9 {
            BiasImpact::Minimal
        } else if bias_score > 0.7 {
            BiasImpact::Moderate
        } else if bias_score > 0.5 {
            BiasImpact::Significant
        } else {
            BiasImpact::Severe
        };

        Ok(BiasAnalysis {
            overall_bias_score: bias_score,
            bias_types,
            mitigation_strategies,
            impact_assessment,
        })
    }

    /// Validate regional appropriateness
    async fn validate_regional(
        &self,
        protocol: &str,
    ) -> Result<RegionalAnalysis, VIBEError> {
        let mut region_scores = HashMap::new();
        let mut issues = Vec::new();
        let mut recommendations = Vec::new();

        for region in &self.config.target_regions {
            if let Some(database) = self.cultural_databases.get(region) {
                let score = self.validate_single_region(protocol, database).await?;
                region_scores.insert(region.clone(), score);

                if score < self.config.sensitivity_threshold {
                    recommendations.push(format!(
                        "Adapt protocol for {} region",
                        region
                    ));
                }
            }
        }

        let overall_score = region_scores.values().sum::<f32>()
            / region_scores.len() as f32;

        Ok(RegionalAnalysis {
            overall_score,
            region_scores,
            issues,
            recommendations,
        })
    }

    /// Validate single region
    async fn validate_single_region(
        &self,
        protocol: &str,
        database: &CulturalDatabase,
    ) -> Result<f32, VIBEError> {
        // Simplified regional validation
        let mut score = 0.7; // Base score

        // Check for regional compliance
        for requirement in &database.legal_requirements {
            if protocol.contains(&requirement.requirement) {
                score += 0.1; // Positive if compliant
            }
        }

        // Check for cultural sensitivity
        for norm in &database.cultural_norms {
            if protocol.contains(&norm.norm) {
                match norm.severity {
                    CulturalSeverity::Low => score -= 0.05,
                    CulturalSeverity::Medium => score -= 0.1,
                    CulturalSeverity::High => score -= 0.2,
                    CulturalSeverity::Critical => score -= 0.5,
                }
            }
        }

        Ok(score.min(1.0).max(0.0))
    }

    /// Initialize language databases
    fn initialize_language_databases(&mut self) -> Result<(), VIBEError> {
        for language in &self.config.target_languages {
            // Simplified initialization - in practice, load from files/APIs
            self.language_databases.insert(
                language.clone(),
                LanguageDatabase {
                    language_code: language.clone(),
                    grammar_rules: Vec::new(),
                    context_rules: Vec::new(),
                    idioms: Vec::new(),
                },
            );
        }
        Ok(())
    }

    /// Initialize cultural databases
    fn initialize_cultural_databases(&mut self) -> Result<(), VIBEError> {
        for region in &self.config.target_regions {
            // Simplified initialization
            self.cultural_databases.insert(
                region.clone(),
                CulturalDatabase {
                    region_code: region.clone(),
                    cultural_norms: Vec::new(),
                    legal_requirements: Vec::new(),
                    religious_considerations: Vec::new(),
                },
            );
        }
        Ok(())
    }
}

/// Language analysis results
#[derive(Debug, Clone)]
struct LanguageAnalysis {
    overall_score: f32,
    language_scores: HashMap<String, f32>,
    issues: Vec<CulturalIssue>,
    recommendations: Vec<String>,
}

/// Regional analysis results
#[derive(Debug, Clone)]
struct RegionalAnalysis {
    overall_score: f32,
    region_scores: HashMap<String, f32>,
    issues: Vec<CulturalIssue>,
    recommendations: Vec<String>,
}

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

    #[tokio::test]
    async fn test_cultural_validation_engine() {
        let engine = CulturalValidationEngine::default().unwrap();
        let base_validation = ValidationResult {
            overall_score: 85.0,
            platform_scores: HashMap::new(),
            confidence_interval: None,
            status: crate::vibe::validation::ValidationStatus::Validated,
            detailed_results: HashMap::new(),
            validation_time_ms: 100,
            issues: Vec::new(),
            recommendations: Vec::new(),
            timestamp: chrono::Utc::now(),
            protocol_id: uuid::Uuid::new_v4(),
        };

        let result = engine
            .validate_cultural("Sample protocol", base_validation)
            .await
            .unwrap();

        assert!(result.cultural_score > 0.0);
    }

    #[tokio::test]
    async fn test_bias_detection() {
        let engine = CulturalValidationEngine::default().unwrap();
        let result = engine.detect_cultural_bias("Protocol with gender considerations").await.unwrap();

        assert!(result.overall_bias_score > 0.0);
    }
}