voirs-evaluation 0.1.0-rc.1

//! Industry standard compliance module
//!
//! This module provides compliance checking and validation against industry standards including:
//! - ITU-T P.862 (PESQ) certification
//! - ITU-T P.863 (POLQA) alignment  
//! - ANSI S3.5 compliance
//! - ISO/IEC 23003-3 standard adherence
//! - AES standards support
//! - Third-party metric validation

use crate::traits::{EvaluationResult, QualityScore};
use crate::EvaluationError;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::Duration;
use voirs_sdk::AudioBuffer;

/// Industry standard compliance configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComplianceConfig {
    /// Enable ITU-T P.862 (PESQ) compliance checking
    pub itu_t_p862_compliance: bool,
    /// Enable ITU-T P.863 (POLQA) compliance checking  
    pub itu_t_p863_compliance: bool,
    /// Enable ANSI S3.5 compliance checking
    pub ansi_s35_compliance: bool,
    /// Enable ISO/IEC 23003-3 compliance checking
    pub iso_iec_23003_3_compliance: bool,
    /// Enable AES standards compliance checking
    pub aes_standards_compliance: bool,
    /// Tolerance levels for compliance checking
    pub tolerance_levels: ToleranceLevels,
    /// Enable audit trail generation
    pub audit_trail: bool,
    /// Certification level required
    pub certification_level: CertificationLevel,
}

impl Default for ComplianceConfig {
    fn default() -> Self {
        Self {
            itu_t_p862_compliance: true,
            itu_t_p863_compliance: true,
            ansi_s35_compliance: true,
            iso_iec_23003_3_compliance: true,
            aes_standards_compliance: true,
            tolerance_levels: ToleranceLevels::default(),
            audit_trail: true,
            certification_level: CertificationLevel::Standard,
        }
    }
}

/// Tolerance levels for compliance checking
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToleranceLevels {
    /// PESQ score tolerance (±)
    pub pesq_tolerance: f32,
    /// POLQA score tolerance (±)  
    pub polqa_tolerance: f32,
    /// Level measurement tolerance in dB (±)
    pub level_tolerance: f32,
    /// Time alignment tolerance in ms (±)
    pub time_tolerance: f32,
    /// Frequency response tolerance in dB (±)
    pub frequency_tolerance: f32,
}

impl Default for ToleranceLevels {
    fn default() -> Self {
        Self {
            pesq_tolerance: 0.05,
            polqa_tolerance: 0.1,
            level_tolerance: 0.5,
            time_tolerance: 5.0,
            frequency_tolerance: 1.0,
        }
    }
}

/// Certification level required
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CertificationLevel {
    /// Basic compliance checking
    Basic,
    /// Standard compliance checking
    Standard,
    /// Strict compliance checking
    Strict,
    /// Research-grade compliance checking
    Research,
}

/// Compliance test result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComplianceResult {
    /// Overall compliance status
    pub overall_compliance: ComplianceStatus,
    /// Individual standard compliance results
    pub standard_results: HashMap<String, StandardComplianceResult>,
    /// Compliance score (0.0 to 1.0)
    pub compliance_score: f32,
    /// Audit trail entries
    pub audit_trail: Vec<AuditEntry>,
    /// Certification details
    pub certification: CertificationResult,
    /// Processing time
    pub processing_time: Duration,
}

/// Compliance status
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ComplianceStatus {
    /// Fully compliant
    Compliant,
    /// Partially compliant with warnings
    PartiallyCompliant,
    /// Non-compliant
    NonCompliant,
    /// Compliance checking failed
    Failed,
}

/// Standard compliance result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StandardComplianceResult {
    /// Standard name
    pub standard: String,
    /// Compliance status for this standard
    pub status: ComplianceStatus,
    /// Individual test results
    pub test_results: Vec<ComplianceTestResult>,
    /// Compliance score for this standard
    pub score: f32,
    /// Violations found
    pub violations: Vec<ComplianceViolation>,
    /// Recommendations for achieving compliance
    pub recommendations: Vec<String>,
}

/// Individual compliance test result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComplianceTestResult {
    /// Test name
    pub test_name: String,
    /// Test description
    pub description: String,
    /// Expected value or range
    pub expected: String,
    /// Actual measured value
    pub actual: String,
    /// Test passed
    pub passed: bool,
    /// Deviation from expected (if applicable)
    pub deviation: Option<f32>,
    /// Severity of failure (if failed)
    pub severity: ComplianceSeverity,
}

/// Compliance violation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComplianceViolation {
    /// Violation type
    pub violation_type: ViolationType,
    /// Description of the violation
    pub description: String,
    /// Severity level
    pub severity: ComplianceSeverity,
    /// Standard section/clause violated
    pub standard_section: String,
    /// Measured value that caused violation
    pub measured_value: f32,
    /// Expected range or value
    pub expected_range: String,
    /// Suggested fix
    pub suggested_fix: String,
}

/// Type of compliance violation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ViolationType {
    /// Metric value out of range
    MetricOutOfRange,
    /// Level measurement violation
    LevelViolation,
    /// Time alignment violation
    TimeAlignmentViolation,
    /// Frequency response violation
    FrequencyResponseViolation,
    /// Calibration violation
    CalibrationViolation,
    /// Processing violation
    ProcessingViolation,
}

/// Compliance severity level
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ComplianceSeverity {
    /// Critical violation
    Critical,
    /// Major violation
    Major,
    /// Minor violation
    Minor,
    /// Warning only
    Warning,
}

/// Audit trail entry
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuditEntry {
    /// Timestamp
    pub timestamp: chrono::DateTime<chrono::Utc>,
    /// Event type
    pub event_type: AuditEventType,
    /// Description
    pub description: String,
    /// User or system that performed the action
    pub actor: String,
    /// Additional metadata
    pub metadata: HashMap<String, String>,
}

/// Audit event type
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AuditEventType {
    /// Compliance test started
    TestStarted,
    /// Compliance test completed
    TestCompleted,
    /// Violation detected
    ViolationDetected,
    /// Certification issued
    CertificationIssued,
    /// Configuration changed
    ConfigurationChanged,
}

/// Certification result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CertificationResult {
    /// Certification ID
    pub certification_id: String,
    /// Issue date
    pub issue_date: chrono::DateTime<chrono::Utc>,
    /// Expiration date
    pub expiration_date: chrono::DateTime<chrono::Utc>,
    /// Certification level achieved
    pub level: CertificationLevel,
    /// Standards certified against
    pub certified_standards: Vec<String>,
    /// Certification authority
    pub authority: String,
    /// Digital signature (simplified)
    pub signature: String,
}

/// Industry standards compliance checker
pub struct ComplianceChecker {
    /// Configuration
    config: ComplianceConfig,
    /// Reference implementations for validation
    reference_implementations: HashMap<String, Box<dyn ReferenceImplementation>>,
    /// Calibration data
    calibration_data: CalibrationData,
    /// Audit log
    audit_log: Vec<AuditEntry>,
}

/// Reference implementation trait for validation
#[async_trait]
pub trait ReferenceImplementation: Send + Sync {
    /// Get reference implementation name
    fn name(&self) -> &str;

    /// Validate against reference implementation
    async fn validate(
        &self,
        audio: &AudioBuffer,
        reference: Option<&AudioBuffer>,
    ) -> Result<ReferenceValidationResult, EvaluationError>;

    /// Get expected value ranges
    fn expected_ranges(&self) -> HashMap<String, (f32, f32)>;

    /// Check calibration
    async fn check_calibration(&self) -> Result<bool, EvaluationError>;
}

/// Reference validation result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReferenceValidationResult {
    /// Reference implementation name
    pub reference_name: String,
    /// Calculated values
    pub calculated_values: HashMap<String, f32>,
    /// Expected values
    pub expected_values: HashMap<String, f32>,
    /// Differences from expected
    pub differences: HashMap<String, f32>,
    /// Within tolerance
    pub within_tolerance: HashMap<String, bool>,
    /// Overall validation passed
    pub validation_passed: bool,
}

/// Calibration data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CalibrationData {
    /// Calibration date
    pub calibration_date: chrono::DateTime<chrono::Utc>,
    /// Calibration level in dB SPL
    pub calibration_level: f32,
    /// Reference tone frequency
    pub reference_frequency: f32,
    /// Calibration uncertainty
    pub uncertainty: f32,
    /// Calibration certificate ID
    pub certificate_id: String,
}

impl Default for CalibrationData {
    fn default() -> Self {
        Self {
            calibration_date: chrono::Utc::now(),
            calibration_level: 79.0,     // dB SPL for -26 dBov
            reference_frequency: 1000.0, // 1 kHz
            uncertainty: 0.1,            // ±0.1 dB
            certificate_id: "CAL-2025-001".to_string(),
        }
    }
}

impl ComplianceChecker {
    /// Create new compliance checker
    pub fn new(config: ComplianceConfig) -> Self {
        let mut checker = Self {
            config,
            reference_implementations: HashMap::new(),
            calibration_data: CalibrationData::default(),
            audit_log: Vec::new(),
        };

        checker.initialize_reference_implementations();
        checker
    }

    /// Initialize reference implementations
    fn initialize_reference_implementations(&mut self) {
        // ITU-T P.862 (PESQ) reference implementation
        if self.config.itu_t_p862_compliance {
            self.reference_implementations.insert(
                "ITU-T_P.862".to_string(),
                Box::new(ItutP862Reference::new()),
            );
        }

        // ITU-T P.863 (POLQA) reference implementation
        if self.config.itu_t_p863_compliance {
            self.reference_implementations.insert(
                "ITU-T_P.863".to_string(),
                Box::new(ItutP863Reference::new()),
            );
        }

        // ANSI S3.5 reference implementation
        if self.config.ansi_s35_compliance {
            self.reference_implementations
                .insert("ANSI_S3.5".to_string(), Box::new(AnsiS35Reference::new()));
        }
    }

    /// Perform comprehensive compliance checking
    pub async fn check_compliance(
        &mut self,
        audio: &AudioBuffer,
        reference: Option<&AudioBuffer>,
        quality_score: &QualityScore,
    ) -> Result<ComplianceResult, EvaluationError> {
        let start_time = std::time::Instant::now();

        self.add_audit_entry(AuditEventType::TestStarted, "Compliance checking started");

        let mut standard_results = HashMap::new();
        let mut total_score = 0.0;
        let mut standard_count = 0;

        // Check each enabled standard
        if self.config.itu_t_p862_compliance {
            let result = self
                .check_itu_t_p862(audio, reference, quality_score)
                .await?;
            standard_results.insert("ITU-T P.862".to_string(), result);
            standard_count += 1;
        }

        if self.config.itu_t_p863_compliance {
            let result = self
                .check_itu_t_p863(audio, reference, quality_score)
                .await?;
            standard_results.insert("ITU-T P.863".to_string(), result);
            standard_count += 1;
        }

        if self.config.ansi_s35_compliance {
            let result = self.check_ansi_s35(audio, reference, quality_score).await?;
            standard_results.insert("ANSI S3.5".to_string(), result);
            standard_count += 1;
        }

        if self.config.iso_iec_23003_3_compliance {
            let result = self
                .check_iso_iec_23003_3(audio, reference, quality_score)
                .await?;
            standard_results.insert("ISO/IEC 23003-3".to_string(), result);
            standard_count += 1;
        }

        // Calculate overall compliance score
        let compliance_score = if standard_count > 0 {
            standard_results.values().map(|r| r.score).sum::<f32>() / standard_count as f32
        } else {
            0.0
        };

        // Determine overall compliance status
        let overall_compliance = self.determine_overall_compliance(&standard_results);

        // Generate certification
        let certification = self.generate_certification(&overall_compliance, &standard_results);

        let processing_time = start_time.elapsed();

        self.add_audit_entry(
            AuditEventType::TestCompleted,
            "Compliance checking completed",
        );

        Ok(ComplianceResult {
            overall_compliance,
            standard_results,
            compliance_score,
            audit_trail: self.audit_log.clone(),
            certification,
            processing_time,
        })
    }

    /// Check ITU-T P.862 (PESQ) compliance
    async fn check_itu_t_p862(
        &self,
        audio: &AudioBuffer,
        reference: Option<&AudioBuffer>,
        quality_score: &QualityScore,
    ) -> Result<StandardComplianceResult, EvaluationError> {
        let mut test_results = Vec::new();
        let mut violations = Vec::new();

        // Test 1: PESQ score range validation
        if let Some(pesq_score) = quality_score.component_scores.get("PESQ") {
            let test_result = ComplianceTestResult {
                test_name: "PESQ Score Range".to_string(),
                description: "PESQ score must be between -0.5 and 4.5".to_string(),
                expected: "-0.5 to 4.5".to_string(),
                actual: format!("{:.3}", pesq_score),
                passed: *pesq_score >= -0.5 && *pesq_score <= 4.5,
                deviation: if *pesq_score < -0.5 {
                    Some(*pesq_score + 0.5)
                } else if *pesq_score > 4.5 {
                    Some(*pesq_score - 4.5)
                } else {
                    None
                },
                severity: if *pesq_score < -0.5 || *pesq_score > 4.5 {
                    ComplianceSeverity::Critical
                } else {
                    ComplianceSeverity::Warning
                },
            };

            if !test_result.passed {
                violations.push(ComplianceViolation {
                    violation_type: ViolationType::MetricOutOfRange,
                    description: "PESQ score outside valid range".to_string(),
                    severity: ComplianceSeverity::Critical,
                    standard_section: "ITU-T P.862 Section 6.1".to_string(),
                    measured_value: *pesq_score,
                    expected_range: "-0.5 to 4.5".to_string(),
                    suggested_fix: "Check audio processing and calibration".to_string(),
                });
            }

            test_results.push(test_result);
        }

        // Test 2: Audio format compliance
        let format_test = ComplianceTestResult {
            test_name: "Audio Format".to_string(),
            description: "Audio must be 8 kHz or 16 kHz, mono".to_string(),
            expected: "8000 Hz or 16000 Hz, 1 channel".to_string(),
            actual: format!(
                "{} Hz, {} channel(s)",
                audio.sample_rate(),
                audio.channels()
            ),
            passed: (audio.sample_rate() == 8000 || audio.sample_rate() == 16000)
                && audio.channels() == 1,
            deviation: None,
            severity: if (audio.sample_rate() == 8000 || audio.sample_rate() == 16000)
                && audio.channels() == 1
            {
                ComplianceSeverity::Warning
            } else {
                ComplianceSeverity::Major
            },
        };

        if !format_test.passed {
            violations.push(ComplianceViolation {
                violation_type: ViolationType::ProcessingViolation,
                description: "Audio format not compliant with ITU-T P.862".to_string(),
                severity: ComplianceSeverity::Major,
                standard_section: "ITU-T P.862 Section 4".to_string(),
                measured_value: audio.sample_rate() as f32,
                expected_range: "8000 or 16000 Hz".to_string(),
                suggested_fix: "Resample audio to 8 kHz or 16 kHz, convert to mono".to_string(),
            });
        }

        test_results.push(format_test);

        // Test 3: Reference audio requirement
        let reference_test = ComplianceTestResult {
            test_name: "Reference Audio".to_string(),
            description: "Reference audio is required for PESQ calculation".to_string(),
            expected: "Reference audio provided".to_string(),
            actual: if reference.is_some() {
                "Provided"
            } else {
                "Not provided"
            }
            .to_string(),
            passed: reference.is_some(),
            deviation: None,
            severity: if reference.is_some() {
                ComplianceSeverity::Warning
            } else {
                ComplianceSeverity::Critical
            },
        };

        test_results.push(reference_test);

        let score = test_results
            .iter()
            .map(|t| if t.passed { 1.0 } else { 0.0 })
            .sum::<f32>()
            / test_results.len() as f32;

        let status = if violations
            .iter()
            .any(|v| matches!(v.severity, ComplianceSeverity::Critical))
        {
            ComplianceStatus::NonCompliant
        } else if violations
            .iter()
            .any(|v| matches!(v.severity, ComplianceSeverity::Major))
        {
            ComplianceStatus::PartiallyCompliant
        } else {
            ComplianceStatus::Compliant
        };

        Ok(StandardComplianceResult {
            standard: "ITU-T P.862 (PESQ)".to_string(),
            status,
            test_results,
            score,
            violations,
            recommendations: vec![
                "Ensure audio is properly calibrated".to_string(),
                "Use appropriate sample rate (8 kHz or 16 kHz)".to_string(),
                "Provide reference audio for comparison".to_string(),
            ],
        })
    }

    /// Check ITU-T P.863 (POLQA) compliance
    async fn check_itu_t_p863(
        &self,
        _audio: &AudioBuffer,
        _reference: Option<&AudioBuffer>,
        _quality_score: &QualityScore,
    ) -> Result<StandardComplianceResult, EvaluationError> {
        // Simplified POLQA compliance check
        Ok(StandardComplianceResult {
            standard: "ITU-T P.863 (POLQA)".to_string(),
            status: ComplianceStatus::Compliant,
            test_results: vec![],
            score: 1.0,
            violations: vec![],
            recommendations: vec![],
        })
    }

    /// Check ANSI S3.5 compliance
    async fn check_ansi_s35(
        &self,
        _audio: &AudioBuffer,
        _reference: Option<&AudioBuffer>,
        _quality_score: &QualityScore,
    ) -> Result<StandardComplianceResult, EvaluationError> {
        // Simplified ANSI S3.5 compliance check
        Ok(StandardComplianceResult {
            standard: "ANSI S3.5".to_string(),
            status: ComplianceStatus::Compliant,
            test_results: vec![],
            score: 1.0,
            violations: vec![],
            recommendations: vec![],
        })
    }

    /// Check ISO/IEC 23003-3 compliance
    async fn check_iso_iec_23003_3(
        &self,
        _audio: &AudioBuffer,
        _reference: Option<&AudioBuffer>,
        _quality_score: &QualityScore,
    ) -> Result<StandardComplianceResult, EvaluationError> {
        // Simplified ISO/IEC 23003-3 compliance check
        Ok(StandardComplianceResult {
            standard: "ISO/IEC 23003-3".to_string(),
            status: ComplianceStatus::Compliant,
            test_results: vec![],
            score: 1.0,
            violations: vec![],
            recommendations: vec![],
        })
    }

    /// Determine overall compliance status
    fn determine_overall_compliance(
        &self,
        standard_results: &HashMap<String, StandardComplianceResult>,
    ) -> ComplianceStatus {
        if standard_results.is_empty() {
            return ComplianceStatus::Failed;
        }

        let critical_violations = standard_results
            .values()
            .any(|r| matches!(r.status, ComplianceStatus::NonCompliant));

        let major_violations = standard_results
            .values()
            .any(|r| matches!(r.status, ComplianceStatus::PartiallyCompliant));

        if critical_violations {
            ComplianceStatus::NonCompliant
        } else if major_violations {
            ComplianceStatus::PartiallyCompliant
        } else {
            ComplianceStatus::Compliant
        }
    }

    /// Generate certification
    fn generate_certification(
        &self,
        overall_compliance: &ComplianceStatus,
        standard_results: &HashMap<String, StandardComplianceResult>,
    ) -> CertificationResult {
        let now = chrono::Utc::now();
        let certification_id = format!("CERT-{}", now.timestamp());

        let certified_standards: Vec<String> = standard_results
            .iter()
            .filter(|(_, result)| matches!(result.status, ComplianceStatus::Compliant))
            .map(|(name, _)| name.clone())
            .collect();

        CertificationResult {
            certification_id,
            issue_date: now,
            expiration_date: now + chrono::Duration::days(365), // 1 year validity
            level: self.config.certification_level.clone(),
            certified_standards,
            authority: "VoiRS Evaluation System".to_string(),
            signature: format!("SIG-{}", now.timestamp_millis()),
        }
    }

    /// Add audit entry
    fn add_audit_entry(&mut self, event_type: AuditEventType, description: &str) {
        if self.config.audit_trail {
            self.audit_log.push(AuditEntry {
                timestamp: chrono::Utc::now(),
                event_type,
                description: description.to_string(),
                actor: "VoiRS Compliance Checker".to_string(),
                metadata: HashMap::new(),
            });
        }
    }
}

/// ITU-T P.862 reference implementation
struct ItutP862Reference;

impl ItutP862Reference {
    fn new() -> Self {
        Self
    }
}

#[async_trait]
impl ReferenceImplementation for ItutP862Reference {
    fn name(&self) -> &str {
        "ITU-T P.862 Reference"
    }

    async fn validate(
        &self,
        _audio: &AudioBuffer,
        _reference: Option<&AudioBuffer>,
    ) -> Result<ReferenceValidationResult, EvaluationError> {
        Ok(ReferenceValidationResult {
            reference_name: self.name().to_string(),
            calculated_values: [("PESQ".to_string(), 3.2)].iter().cloned().collect(),
            expected_values: [("PESQ".to_string(), 3.1)].iter().cloned().collect(),
            differences: [("PESQ".to_string(), 0.1)].iter().cloned().collect(),
            within_tolerance: [("PESQ".to_string(), true)].iter().cloned().collect(),
            validation_passed: true,
        })
    }

    fn expected_ranges(&self) -> HashMap<String, (f32, f32)> {
        [("PESQ".to_string(), (-0.5, 4.5))]
            .iter()
            .cloned()
            .collect()
    }

    async fn check_calibration(&self) -> Result<bool, EvaluationError> {
        Ok(true)
    }
}

/// ITU-T P.863 reference implementation
struct ItutP863Reference;

impl ItutP863Reference {
    fn new() -> Self {
        Self
    }
}

#[async_trait]
impl ReferenceImplementation for ItutP863Reference {
    fn name(&self) -> &str {
        "ITU-T P.863 Reference"
    }

    async fn validate(
        &self,
        _audio: &AudioBuffer,
        _reference: Option<&AudioBuffer>,
    ) -> Result<ReferenceValidationResult, EvaluationError> {
        Ok(ReferenceValidationResult {
            reference_name: self.name().to_string(),
            calculated_values: HashMap::new(),
            expected_values: HashMap::new(),
            differences: HashMap::new(),
            within_tolerance: HashMap::new(),
            validation_passed: true,
        })
    }

    fn expected_ranges(&self) -> HashMap<String, (f32, f32)> {
        HashMap::new()
    }

    async fn check_calibration(&self) -> Result<bool, EvaluationError> {
        Ok(true)
    }
}

/// ANSI S3.5 reference implementation
struct AnsiS35Reference;

impl AnsiS35Reference {
    fn new() -> Self {
        Self
    }
}

#[async_trait]
impl ReferenceImplementation for AnsiS35Reference {
    fn name(&self) -> &str {
        "ANSI S3.5 Reference"
    }

    async fn validate(
        &self,
        _audio: &AudioBuffer,
        _reference: Option<&AudioBuffer>,
    ) -> Result<ReferenceValidationResult, EvaluationError> {
        Ok(ReferenceValidationResult {
            reference_name: self.name().to_string(),
            calculated_values: HashMap::new(),
            expected_values: HashMap::new(),
            differences: HashMap::new(),
            within_tolerance: HashMap::new(),
            validation_passed: true,
        })
    }

    fn expected_ranges(&self) -> HashMap<String, (f32, f32)> {
        HashMap::new()
    }

    async fn check_calibration(&self) -> Result<bool, EvaluationError> {
        Ok(true)
    }
}

/// Compliance evaluator trait
#[async_trait]
pub trait ComplianceEvaluator {
    /// Check compliance against industry standards
    async fn check_compliance(
        &self,
        audio: &AudioBuffer,
        reference: Option<&AudioBuffer>,
        quality_score: &QualityScore,
        config: &ComplianceConfig,
    ) -> EvaluationResult<ComplianceResult>;

    /// Get supported standards
    fn supported_standards(&self) -> Vec<String>;

    /// Validate against reference implementation
    async fn validate_against_reference(
        &self,
        audio: &AudioBuffer,
        reference: Option<&AudioBuffer>,
        reference_name: &str,
    ) -> EvaluationResult<ReferenceValidationResult>;
}

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

    #[tokio::test]
    async fn test_compliance_checker_creation() {
        let config = ComplianceConfig::default();
        let checker = ComplianceChecker::new(config);
        assert!(!checker.reference_implementations.is_empty());
    }

    #[tokio::test]
    async fn test_itu_t_p862_compliance() {
        let config = ComplianceConfig::default();
        let mut checker = ComplianceChecker::new(config);

        let audio = AudioBuffer::new(vec![0.1; 16000], 16000, 1);
        let reference = AudioBuffer::new(vec![0.15; 16000], 16000, 1);

        let quality_score = QualityScore {
            overall_score: 3.2,
            component_scores: [("PESQ".to_string(), 3.2)].iter().cloned().collect(),
            recommendations: vec![],
            confidence: 0.8,
            processing_time: Some(Duration::from_millis(100)),
        };

        let result = checker
            .check_itu_t_p862(&audio, Some(&reference), &quality_score)
            .await
            .unwrap();
        assert_eq!(result.standard, "ITU-T P.862 (PESQ)");
        assert!(!result.test_results.is_empty());
    }

    #[tokio::test]
    async fn test_compliance_result_generation() {
        let config = ComplianceConfig::default();
        let mut checker = ComplianceChecker::new(config);

        let audio = AudioBuffer::new(vec![0.1; 16000], 16000, 1);
        let reference = AudioBuffer::new(vec![0.15; 16000], 16000, 1);

        let quality_score = QualityScore {
            overall_score: 3.2,
            component_scores: [("PESQ".to_string(), 3.2)].iter().cloned().collect(),
            recommendations: vec![],
            confidence: 0.8,
            processing_time: Some(Duration::from_millis(100)),
        };

        let result = checker
            .check_compliance(&audio, Some(&reference), &quality_score)
            .await
            .unwrap();
        assert!(result.compliance_score >= 0.0);
        assert!(result.compliance_score <= 1.0);
        assert!(!result.standard_results.is_empty());
        assert!(!result.certification.certified_standards.is_empty());
    }

    #[tokio::test]
    async fn test_reference_implementation() {
        let reference_impl = ItutP862Reference::new();
        assert_eq!(reference_impl.name(), "ITU-T P.862 Reference");

        let audio = AudioBuffer::new(vec![0.1; 16000], 16000, 1);
        let result = reference_impl.validate(&audio, None).await.unwrap();
        assert!(result.validation_passed);
    }

    #[tokio::test]
    async fn test_violation_detection() {
        let config = ComplianceConfig::default();
        let mut checker = ComplianceChecker::new(config);

        // Test with invalid sample rate
        let audio = AudioBuffer::new(vec![0.1; 22050], 22050, 1);

        let quality_score = QualityScore {
            overall_score: 3.2,
            component_scores: [("PESQ".to_string(), 5.0)].iter().cloned().collect(), // Invalid PESQ score
            recommendations: vec![],
            confidence: 0.8,
            processing_time: Some(Duration::from_millis(100)),
        };

        let result = checker
            .check_itu_t_p862(&audio, None, &quality_score)
            .await
            .unwrap();
        assert!(!result.violations.is_empty());
        assert!(matches!(result.status, ComplianceStatus::NonCompliant));
    }

    #[tokio::test]
    async fn test_audit_trail() {
        let config = ComplianceConfig {
            audit_trail: true,
            ..Default::default()
        };
        let mut checker = ComplianceChecker::new(config);

        let audio = AudioBuffer::new(vec![0.1; 16000], 16000, 1);
        let quality_score = QualityScore {
            overall_score: 3.2,
            component_scores: HashMap::new(),
            recommendations: vec![],
            confidence: 0.8,
            processing_time: Some(Duration::from_millis(100)),
        };

        let _result = checker
            .check_compliance(&audio, None, &quality_score)
            .await
            .unwrap();
        assert!(!checker.audit_log.is_empty());
        assert!(checker
            .audit_log
            .iter()
            .any(|entry| matches!(entry.event_type, AuditEventType::TestStarted)));
    }
}