voirs-evaluation 0.1.0-rc.1

//! Cross-cultural perceptual modeling for audio evaluation
//!
//! This module provides advanced cross-cultural adaptation algorithms that model
//! how cultural background affects perceptual evaluation of speech synthesis.

use crate::perceptual::{CulturalProfile, CulturalRegion, DemographicProfile};
use crate::traits::{EvaluationResult, QualityScore};
use crate::EvaluationError;
use scirs2_core::random::prelude::*;
use std::collections::HashMap;
use voirs_sdk::AudioBuffer;

/// Cross-cultural perceptual model configuration
#[derive(Debug, Clone)]
pub struct CrossCulturalConfig {
    /// Enable phonetic distance modeling
    pub enable_phonetic_distance: bool,
    /// Enable prosodic preference modeling
    pub enable_prosodic_preferences: bool,
    /// Enable accent familiarity effects
    pub enable_accent_familiarity: bool,
    /// Enable cultural communication style effects
    pub enable_communication_styles: bool,
    /// Model linguistic distance effects
    pub enable_linguistic_distance: bool,
}

impl Default for CrossCulturalConfig {
    fn default() -> Self {
        Self {
            enable_phonetic_distance: true,
            enable_prosodic_preferences: true,
            enable_accent_familiarity: true,
            enable_communication_styles: true,
            enable_linguistic_distance: true,
        }
    }
}

/// Language family classifications for linguistic distance modeling
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LanguageFamily {
    /// Indo-European language family
    IndoEuropean,
    /// Sino-Tibetan language family
    SinoTibetan,
    /// Afro-Asiatic language family
    AfroAsiatic,
    /// Niger-Congo language family
    NigerCongo,
    /// Trans-New Guinea language family
    TransNewGuinea,
    /// Austronesian language family
    Austronesian,
    /// Japonic language family
    Japonic,
    /// Koreanic language family
    Koreanic,
    /// Other language families
    Other,
}

/// Phonetic inventory characteristics for different languages
#[derive(Debug, Clone)]
pub struct PhoneticInventory {
    /// Number of vowels in the language
    pub vowel_count: usize,
    /// Number of consonants in the language
    pub consonant_count: usize,
    /// Has tonal distinctions
    pub has_tones: bool,
    /// Has complex consonant clusters
    pub has_consonant_clusters: bool,
    /// Common phonemes (simplified representation)
    pub common_phonemes: Vec<String>,
}

/// Prosodic preferences based on cultural background
#[derive(Debug, Clone)]
pub struct ProsodicPreferences {
    /// Preferred speech rate (syllables per second)
    pub preferred_speech_rate: f32,
    /// Tolerance for pitch variation
    pub pitch_variation_tolerance: f32,
    /// Preference for stress patterns
    pub stress_pattern_preference: StressPattern,
    /// Intonation pattern preference
    pub intonation_preference: IntonationPattern,
}

/// Stress pattern types
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum StressPattern {
    /// Stress on fixed syllable position
    Fixed,
    /// Stress position varies by word
    Variable,
    /// Tone-based instead of stress
    Tonal,
}

/// Intonation pattern preferences
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum IntonationPattern {
    /// Preference for rising intonation
    Rising,
    /// Preference for falling intonation
    Falling,
    /// Preference for level intonation
    Level,
    /// Complex intonation patterns
    Complex,
}

/// Communication style characteristics
#[derive(Debug, Clone)]
pub struct CommunicationStyle {
    /// Preference for direct vs indirect communication
    pub directness_preference: f32, // 0.0 = very indirect, 1.0 = very direct
    /// Tolerance for silence/pauses
    pub silence_tolerance: f32,
    /// Preference for emotional expressiveness
    pub expressiveness_preference: f32,
    /// Formality expectations
    pub formality_expectation: f32,
}

/// Cross-cultural adaptation factors
#[derive(Debug, Clone)]
pub struct CrossCulturalAdaptation {
    /// Phonetic distance effect
    pub phonetic_distance_factor: f32,
    /// Prosodic mismatch penalty
    pub prosodic_mismatch_factor: f32,
    /// Accent familiarity bonus
    pub accent_familiarity_factor: f32,
    /// Communication style alignment
    pub communication_style_factor: f32,
    /// Linguistic distance penalty
    pub linguistic_distance_factor: f32,
}

/// Cross-cultural perceptual model
pub struct CrossCulturalPerceptualModel {
    /// Configuration
    config: CrossCulturalConfig,
    /// Language inventory database
    phonetic_inventories: HashMap<String, PhoneticInventory>,
    /// Prosodic preferences by region
    prosodic_preferences: HashMap<CulturalRegion, ProsodicPreferences>,
    /// Communication styles by region
    communication_styles: HashMap<CulturalRegion, CommunicationStyle>,
    /// Language family mappings
    language_families: HashMap<String, LanguageFamily>,
}

impl CrossCulturalPerceptualModel {
    /// Create a new cross-cultural perceptual model
    pub fn new(config: CrossCulturalConfig) -> Self {
        let mut model = Self {
            config,
            phonetic_inventories: HashMap::new(),
            prosodic_preferences: HashMap::new(),
            communication_styles: HashMap::new(),
            language_families: HashMap::new(),
        };

        model.initialize_language_data();
        model.initialize_cultural_preferences();

        model
    }

    /// Initialize phonetic inventory and language family data
    fn initialize_language_data(&mut self) {
        // English
        self.phonetic_inventories.insert(
            "en".to_string(),
            PhoneticInventory {
                vowel_count: 12,
                consonant_count: 24,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["t", "n", "r", "s", "l", "d", "k", "m", "p", "w"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("en".to_string(), LanguageFamily::IndoEuropean);

        // Mandarin Chinese
        self.phonetic_inventories.insert(
            "zh".to_string(),
            PhoneticInventory {
                vowel_count: 8,
                consonant_count: 21,
                has_tones: true,
                has_consonant_clusters: false,
                common_phonemes: vec!["n", "t", "l", "s", "k", "x", "w", "m", "p", "f"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("zh".to_string(), LanguageFamily::SinoTibetan);

        // Spanish
        self.phonetic_inventories.insert(
            "es".to_string(),
            PhoneticInventory {
                vowel_count: 5,
                consonant_count: 19,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["s", "n", "r", "l", "t", "d", "k", "m", "p", "b"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("es".to_string(), LanguageFamily::IndoEuropean);

        // Japanese
        self.phonetic_inventories.insert(
            "ja".to_string(),
            PhoneticInventory {
                vowel_count: 5,
                consonant_count: 15,
                has_tones: false,
                has_consonant_clusters: false,
                common_phonemes: vec!["n", "k", "s", "t", "r", "m", "w", "h", "g", "d"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("ja".to_string(), LanguageFamily::Japonic);

        // Hindi
        self.phonetic_inventories.insert(
            "hi".to_string(),
            PhoneticInventory {
                vowel_count: 11,
                consonant_count: 33,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["n", "r", "k", "t", "s", "m", "l", "d", "p", "h"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("hi".to_string(), LanguageFamily::IndoEuropean);

        // Arabic
        self.phonetic_inventories.insert(
            "ar".to_string(),
            PhoneticInventory {
                vowel_count: 6,
                consonant_count: 28,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["l", "n", "m", "r", "t", "k", "s", "h", "d", "b"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("ar".to_string(), LanguageFamily::AfroAsiatic);

        // Portuguese
        self.phonetic_inventories.insert(
            "pt".to_string(),
            PhoneticInventory {
                vowel_count: 14,
                consonant_count: 19,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["s", "r", "n", "t", "l", "d", "m", "k", "p", "v"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("pt".to_string(), LanguageFamily::IndoEuropean);

        // Russian
        self.phonetic_inventories.insert(
            "ru".to_string(),
            PhoneticInventory {
                vowel_count: 6,
                consonant_count: 35,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["n", "t", "r", "s", "l", "v", "k", "d", "m", "p"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("ru".to_string(), LanguageFamily::IndoEuropean);

        // German
        self.phonetic_inventories.insert(
            "de".to_string(),
            PhoneticInventory {
                vowel_count: 16,
                consonant_count: 23,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["n", "r", "s", "t", "l", "d", "k", "m", "h", "g"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("de".to_string(), LanguageFamily::IndoEuropean);

        // French
        self.phonetic_inventories.insert(
            "fr".to_string(),
            PhoneticInventory {
                vowel_count: 16,
                consonant_count: 20,
                has_tones: false,
                has_consonant_clusters: true,
                common_phonemes: vec!["r", "n", "t", "s", "l", "d", "k", "m", "p", "v"]
                    .iter()
                    .map(|s| s.to_string())
                    .collect(),
            },
        );
        self.language_families
            .insert("fr".to_string(), LanguageFamily::IndoEuropean);
    }

    /// Initialize cultural preferences by region
    fn initialize_cultural_preferences(&mut self) {
        // North American preferences
        self.prosodic_preferences.insert(
            CulturalRegion::NorthAmerica,
            ProsodicPreferences {
                preferred_speech_rate: 4.5,
                pitch_variation_tolerance: 0.8,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Falling,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::NorthAmerica,
            CommunicationStyle {
                directness_preference: 0.7,
                silence_tolerance: 0.3,
                expressiveness_preference: 0.6,
                formality_expectation: 0.4,
            },
        );

        // European preferences
        self.prosodic_preferences.insert(
            CulturalRegion::Europe,
            ProsodicPreferences {
                preferred_speech_rate: 4.2,
                pitch_variation_tolerance: 0.7,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Complex,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::Europe,
            CommunicationStyle {
                directness_preference: 0.6,
                silence_tolerance: 0.5,
                expressiveness_preference: 0.5,
                formality_expectation: 0.6,
            },
        );

        // East Asian preferences
        self.prosodic_preferences.insert(
            CulturalRegion::EastAsia,
            ProsodicPreferences {
                preferred_speech_rate: 3.8,
                pitch_variation_tolerance: 0.9,
                stress_pattern_preference: StressPattern::Tonal,
                intonation_preference: IntonationPattern::Rising,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::EastAsia,
            CommunicationStyle {
                directness_preference: 0.3,
                silence_tolerance: 0.8,
                expressiveness_preference: 0.4,
                formality_expectation: 0.8,
            },
        );

        // South Asian preferences
        self.prosodic_preferences.insert(
            CulturalRegion::SouthAsia,
            ProsodicPreferences {
                preferred_speech_rate: 4.0,
                pitch_variation_tolerance: 0.9,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Complex,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::SouthAsia,
            CommunicationStyle {
                directness_preference: 0.4,
                silence_tolerance: 0.6,
                expressiveness_preference: 0.7,
                formality_expectation: 0.7,
            },
        );

        // Middle Eastern preferences
        self.prosodic_preferences.insert(
            CulturalRegion::MiddleEast,
            ProsodicPreferences {
                preferred_speech_rate: 4.3,
                pitch_variation_tolerance: 0.8,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Complex,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::MiddleEast,
            CommunicationStyle {
                directness_preference: 0.5,
                silence_tolerance: 0.4,
                expressiveness_preference: 0.8,
                formality_expectation: 0.7,
            },
        );

        // African preferences (generalized)
        self.prosodic_preferences.insert(
            CulturalRegion::Africa,
            ProsodicPreferences {
                preferred_speech_rate: 4.1,
                pitch_variation_tolerance: 0.9,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Complex,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::Africa,
            CommunicationStyle {
                directness_preference: 0.6,
                silence_tolerance: 0.7,
                expressiveness_preference: 0.8,
                formality_expectation: 0.6,
            },
        );

        // South American preferences
        self.prosodic_preferences.insert(
            CulturalRegion::SouthAmerica,
            ProsodicPreferences {
                preferred_speech_rate: 4.4,
                pitch_variation_tolerance: 0.8,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Rising,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::SouthAmerica,
            CommunicationStyle {
                directness_preference: 0.5,
                silence_tolerance: 0.3,
                expressiveness_preference: 0.9,
                formality_expectation: 0.5,
            },
        );

        // Oceanian preferences
        self.prosodic_preferences.insert(
            CulturalRegion::Oceania,
            ProsodicPreferences {
                preferred_speech_rate: 4.3,
                pitch_variation_tolerance: 0.7,
                stress_pattern_preference: StressPattern::Variable,
                intonation_preference: IntonationPattern::Falling,
            },
        );
        self.communication_styles.insert(
            CulturalRegion::Oceania,
            CommunicationStyle {
                directness_preference: 0.6,
                silence_tolerance: 0.4,
                expressiveness_preference: 0.6,
                formality_expectation: 0.4,
            },
        );
    }

    /// Calculate cross-cultural adaptation factors for a listener
    pub fn calculate_adaptation_factors(
        &self,
        listener_cultural: &CulturalProfile,
        listener_demographic: &DemographicProfile,
        audio: &AudioBuffer,
        target_language: &str,
    ) -> EvaluationResult<CrossCulturalAdaptation> {
        let mut adaptation = CrossCulturalAdaptation {
            phonetic_distance_factor: 1.0,
            prosodic_mismatch_factor: 1.0,
            accent_familiarity_factor: 1.0,
            communication_style_factor: 1.0,
            linguistic_distance_factor: 1.0,
        };

        // Calculate phonetic distance factor
        if self.config.enable_phonetic_distance {
            adaptation.phonetic_distance_factor = self.calculate_phonetic_distance_factor(
                &listener_demographic.native_language,
                target_language,
            )?;
        }

        // Calculate prosodic mismatch factor
        if self.config.enable_prosodic_preferences {
            adaptation.prosodic_mismatch_factor =
                self.calculate_prosodic_mismatch_factor(listener_cultural.region, audio)?;
        }

        // Calculate accent familiarity factor
        if self.config.enable_accent_familiarity {
            adaptation.accent_familiarity_factor =
                self.calculate_accent_familiarity_factor(listener_cultural, target_language);
        }

        // Calculate communication style factor
        if self.config.enable_communication_styles {
            adaptation.communication_style_factor =
                self.calculate_communication_style_factor(listener_cultural.region, audio)?;
        }

        // Calculate linguistic distance factor
        if self.config.enable_linguistic_distance {
            adaptation.linguistic_distance_factor = self.calculate_linguistic_distance_factor(
                &listener_demographic.native_language,
                target_language,
            );
        }

        Ok(adaptation)
    }

    /// Calculate phonetic distance factor between languages
    fn calculate_phonetic_distance_factor(
        &self,
        native_lang: &str,
        target_lang: &str,
    ) -> EvaluationResult<f32> {
        let native_inventory = self.phonetic_inventories.get(native_lang).ok_or_else(|| {
            EvaluationError::QualityEvaluationError {
                message: format!("Language {} not supported", native_lang),
                source: None,
            }
        })?;

        let target_inventory = self.phonetic_inventories.get(target_lang).ok_or_else(|| {
            EvaluationError::QualityEvaluationError {
                message: format!("Language {} not supported", target_lang),
                source: None,
            }
        })?;

        // Calculate similarity based on inventory characteristics
        let vowel_similarity = 1.0
            - ((native_inventory.vowel_count as f32 - target_inventory.vowel_count as f32).abs()
                / 20.0)
                .min(1.0);
        let consonant_similarity = 1.0
            - ((native_inventory.consonant_count as f32 - target_inventory.consonant_count as f32)
                .abs()
                / 40.0)
                .min(1.0);

        let tone_penalty = if native_inventory.has_tones != target_inventory.has_tones {
            0.8
        } else {
            1.0
        };
        let cluster_penalty =
            if native_inventory.has_consonant_clusters != target_inventory.has_consonant_clusters {
                0.9
            } else {
                1.0
            };

        // Calculate phoneme overlap
        let common_phonemes: std::collections::HashSet<_> =
            native_inventory.common_phonemes.iter().collect();
        let target_phonemes: std::collections::HashSet<_> =
            target_inventory.common_phonemes.iter().collect();
        let intersection_size = common_phonemes.intersection(&target_phonemes).count();
        let union_size = common_phonemes.union(&target_phonemes).count();
        let phoneme_overlap = if union_size > 0 {
            intersection_size as f32 / union_size as f32
        } else {
            0.0
        };

        // Combine factors
        let similarity =
            (vowel_similarity * 0.3 + consonant_similarity * 0.3 + phoneme_overlap * 0.4)
                * tone_penalty
                * cluster_penalty;

        // Convert to adaptation factor (higher similarity = less adaptation needed)
        Ok(0.7 + 0.3 * similarity)
    }

    /// Calculate prosodic mismatch factor
    fn calculate_prosodic_mismatch_factor(
        &self,
        listener_region: CulturalRegion,
        audio: &AudioBuffer,
    ) -> EvaluationResult<f32> {
        let preferences = self
            .prosodic_preferences
            .get(&listener_region)
            .ok_or_else(|| EvaluationError::QualityEvaluationError {
                message: format!("Region {:?} not supported", listener_region),
                source: None,
            })?;

        // Analyze audio prosodic characteristics (simplified)
        let samples = audio.samples();
        if samples.is_empty() {
            return Ok(1.0);
        }

        // Estimate speech rate based on energy variations
        let estimated_rate = self.estimate_speech_rate(samples);
        let rate_factor =
            1.0 - ((estimated_rate - preferences.preferred_speech_rate).abs() / 3.0).min(0.3);

        // Estimate pitch variation
        let pitch_variation = self.estimate_pitch_variation(samples);
        let pitch_factor =
            1.0 - ((pitch_variation - preferences.pitch_variation_tolerance).abs()).min(0.2);

        // Combine factors
        Ok(rate_factor * 0.6 + pitch_factor * 0.4)
    }

    /// Estimate speech rate from audio samples
    fn estimate_speech_rate(&self, samples: &[f32]) -> f32 {
        if samples.is_empty() {
            return 4.0; // Default rate
        }

        // Simple energy-based syllable estimation
        let chunk_size = 800; // ~50ms at 16kHz
        let mut energy_peaks = 0;
        let mut prev_energy = 0.0;

        for chunk in samples.chunks(chunk_size) {
            let energy = chunk.iter().map(|&x| x * x).sum::<f32>() / chunk.len() as f32;
            if energy > prev_energy * 1.5 && energy > 0.01 {
                energy_peaks += 1;
            }
            prev_energy = energy;
        }

        let duration_seconds = samples.len() as f32 / 16000.0; // Assume 16kHz
        if duration_seconds > 0.0 {
            (energy_peaks as f32 / duration_seconds).clamp(2.0, 8.0)
        } else {
            4.0
        }
    }

    /// Estimate pitch variation from audio samples
    fn estimate_pitch_variation(&self, samples: &[f32]) -> f32 {
        if samples.len() < 1600 {
            return 0.5; // Default variation
        }

        // Simple autocorrelation-based pitch estimation
        let mut variations = Vec::new();
        let chunk_size = 1600; // ~100ms at 16kHz

        for chunk in samples.chunks(chunk_size) {
            if chunk.len() == chunk_size {
                let pitch_estimate = self.simple_pitch_detection(chunk);
                variations.push(pitch_estimate);
            }
        }

        if variations.len() < 2 {
            return 0.5;
        }

        // Calculate coefficient of variation
        let mean = variations.iter().sum::<f32>() / variations.len() as f32;
        let variance =
            variations.iter().map(|&x| (x - mean).powi(2)).sum::<f32>() / variations.len() as f32;
        let std_dev = variance.sqrt();

        if mean > 0.0 {
            (std_dev / mean).clamp(0.1, 1.0)
        } else {
            0.5
        }
    }

    /// Simple pitch detection using autocorrelation
    fn simple_pitch_detection(&self, samples: &[f32]) -> f32 {
        let min_period = 40; // ~400Hz max
        let max_period = 400; // ~40Hz min

        let mut best_corr = 0.0;
        let mut best_period = min_period;

        for period in min_period..=max_period.min(samples.len() / 2) {
            let mut correlation = 0.0;
            let mut count = 0;

            for i in 0..(samples.len() - period) {
                correlation += samples[i] * samples[i + period];
                count += 1;
            }

            if count > 0 {
                correlation /= count as f32;
                if correlation > best_corr {
                    best_corr = correlation;
                    best_period = period;
                }
            }
        }

        16000.0 / best_period as f32 // Convert to Hz
    }

    /// Calculate accent familiarity factor
    fn calculate_accent_familiarity_factor(
        &self,
        listener_cultural: &CulturalProfile,
        target_language: &str,
    ) -> f32 {
        // Check if target language is in familiarity list
        let is_familiar = listener_cultural
            .language_familiarity
            .contains(&target_language.to_string());

        if is_familiar {
            1.0 // No penalty for familiar language
        } else {
            // Apply penalty based on accent tolerance
            0.6 + 0.4 * listener_cultural.accent_tolerance
        }
    }

    /// Calculate communication style factor
    fn calculate_communication_style_factor(
        &self,
        listener_region: CulturalRegion,
        audio: &AudioBuffer,
    ) -> EvaluationResult<f32> {
        let style = self
            .communication_styles
            .get(&listener_region)
            .ok_or_else(|| EvaluationError::QualityEvaluationError {
                message: format!("Region {:?} not supported", listener_region),
                source: None,
            })?;

        // Analyze audio for communication style characteristics (simplified)
        let samples = audio.samples();
        if samples.is_empty() {
            return Ok(1.0);
        }

        // Estimate expressiveness based on dynamic range
        let rms = (samples.iter().map(|&x| x * x).sum::<f32>() / samples.len() as f32).sqrt();
        let peak = samples.iter().map(|&x| x.abs()).fold(0.0f32, f32::max);
        let dynamic_range = if rms > 0.0 { peak / rms } else { 1.0 };
        let audio_expressiveness = (dynamic_range / 10.0).clamp(0.0, 1.0);

        // Calculate alignment with preferred expressiveness
        let expressiveness_alignment =
            1.0 - (audio_expressiveness - style.expressiveness_preference).abs();

        // Estimate formality (simplified based on pitch stability)
        let pitch_variation = self.estimate_pitch_variation(samples);
        let audio_formality = 1.0 - pitch_variation; // More stable = more formal
        let formality_alignment = 1.0 - (audio_formality - style.formality_expectation).abs();

        // Combine factors
        Ok(expressiveness_alignment * 0.6 + formality_alignment * 0.4)
    }

    /// Calculate linguistic distance factor
    pub fn calculate_linguistic_distance_factor(
        &self,
        native_lang: &str,
        target_lang: &str,
    ) -> f32 {
        if native_lang == target_lang {
            return 1.0; // Same language, no distance
        }

        let native_family = self
            .language_families
            .get(native_lang)
            .unwrap_or(&LanguageFamily::Other);
        let target_family = self
            .language_families
            .get(target_lang)
            .unwrap_or(&LanguageFamily::Other);

        if native_family == target_family {
            0.9 // Same family, small penalty
        } else {
            // Different families, larger penalty
            match (native_family, target_family) {
                // Indo-European languages are generally closer to each other
                (LanguageFamily::IndoEuropean, _) | (_, LanguageFamily::IndoEuropean) => 0.8,
                // Other combinations
                _ => 0.7,
            }
        }
    }

    /// Apply cross-cultural adaptation to a base score
    pub fn apply_cultural_adaptation(
        &self,
        base_score: f32,
        adaptation: &CrossCulturalAdaptation,
    ) -> f32 {
        let mut adapted_score = base_score;

        // Apply each adaptation factor
        adapted_score *= adaptation.phonetic_distance_factor;
        adapted_score *= adaptation.prosodic_mismatch_factor;
        adapted_score *= adaptation.accent_familiarity_factor;
        adapted_score *= adaptation.communication_style_factor;
        adapted_score *= adaptation.linguistic_distance_factor;

        adapted_score.clamp(0.0, 1.0)
    }

    /// Get supported languages
    pub fn get_supported_languages(&self) -> Vec<String> {
        self.phonetic_inventories.keys().cloned().collect()
    }

    /// Get cultural regions
    pub fn get_cultural_regions(&self) -> Vec<CulturalRegion> {
        self.prosodic_preferences.keys().cloned().collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::perceptual::{CulturalProfile, CulturalRegion, DemographicProfile};

    #[test]
    fn test_cross_cultural_model_creation() {
        let config = CrossCulturalConfig::default();
        let model = CrossCulturalPerceptualModel::new(config);

        assert!(!model.get_supported_languages().is_empty());
        assert!(!model.get_cultural_regions().is_empty());
    }

    #[test]
    fn test_phonetic_distance_calculation() {
        let model = CrossCulturalPerceptualModel::new(CrossCulturalConfig::default());

        // Same language should have high similarity
        let same_lang_factor = model
            .calculate_phonetic_distance_factor("en", "en")
            .unwrap();
        assert!(same_lang_factor > 0.9);

        // Related languages should have moderate similarity
        let related_factor = model
            .calculate_phonetic_distance_factor("en", "de")
            .unwrap();
        // Adjust the assertion range based on actual calculated values
        assert!(related_factor > 0.6 && related_factor < 1.0);

        // Distant languages should have lower similarity
        let distant_factor = model
            .calculate_phonetic_distance_factor("en", "zh")
            .unwrap();
        assert!(distant_factor < 1.0); // Should be less than same language (1.0)
    }

    #[test]
    fn test_linguistic_distance_factor() {
        let model = CrossCulturalPerceptualModel::new(CrossCulturalConfig::default());

        // Same language
        assert_eq!(model.calculate_linguistic_distance_factor("en", "en"), 1.0);

        // Same family
        let same_family = model.calculate_linguistic_distance_factor("en", "de");
        assert_eq!(same_family, 0.9);

        // Different families
        let diff_family = model.calculate_linguistic_distance_factor("en", "zh");
        assert_eq!(diff_family, 0.8);
    }

    #[tokio::test]
    async fn test_adaptation_factor_calculation() {
        let model = CrossCulturalPerceptualModel::new(CrossCulturalConfig::default());

        let cultural_profile = CulturalProfile {
            region: CulturalRegion::NorthAmerica,
            language_familiarity: vec!["en".to_string()],
            musical_training: false,
            accent_tolerance: 0.7,
        };

        let demographic_profile = DemographicProfile {
            age_group: crate::perceptual::AgeGroup::MiddleAged,
            gender: crate::perceptual::Gender::Other,
            education_level: crate::perceptual::EducationLevel::Bachelor,
            native_language: "en".to_string(),
            audio_experience: crate::perceptual::ExperienceLevel::Intermediate,
        };

        let samples = (0..1000)
            .map(|i| [0.1, 0.2, -0.1, -0.2][i % 4])
            .collect::<Vec<f32>>();
        let audio = AudioBuffer::new(samples, 16000, 1);

        let adaptation = model
            .calculate_adaptation_factors(&cultural_profile, &demographic_profile, &audio, "en")
            .unwrap();

        // All factors should be reasonable values
        assert!(
            adaptation.phonetic_distance_factor >= 0.5
                && adaptation.phonetic_distance_factor <= 1.0
        );
        assert!(
            adaptation.prosodic_mismatch_factor >= 0.5
                && adaptation.prosodic_mismatch_factor <= 1.0
        );
        assert!(
            adaptation.accent_familiarity_factor >= 0.5
                && adaptation.accent_familiarity_factor <= 1.0
        );
        assert!(
            adaptation.communication_style_factor >= 0.5
                && adaptation.communication_style_factor <= 1.0
        );
        assert!(
            adaptation.linguistic_distance_factor >= 0.5
                && adaptation.linguistic_distance_factor <= 1.0
        );
    }

    #[test]
    fn test_cultural_adaptation_application() {
        let model = CrossCulturalPerceptualModel::new(CrossCulturalConfig::default());

        let adaptation = CrossCulturalAdaptation {
            phonetic_distance_factor: 0.9,
            prosodic_mismatch_factor: 0.8,
            accent_familiarity_factor: 1.0,
            communication_style_factor: 0.9,
            linguistic_distance_factor: 0.9,
        };

        let base_score = 0.8;
        let adapted_score = model.apply_cultural_adaptation(base_score, &adaptation);

        // Score should be adjusted downward due to various factors
        assert!(adapted_score < base_score);
        assert!(adapted_score >= 0.0 && adapted_score <= 1.0);
    }
}