quantrs2-device 0.1.3

//! Security configuration types

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, SystemTime};

use super::types::*;

/// Configuration for Comprehensive Quantum System Security Framework
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumSecurityConfig {
    /// Core security policy configuration
    pub security_policy: SecurityPolicyConfig,
    /// Quantum-safe cryptography configuration
    pub quantum_safe_crypto: QuantumSafeCryptographyConfig,
    /// Access control and authentication configuration
    pub access_control: AccessControlConfig,
    /// Threat detection and response configuration
    pub threat_detection: ThreatDetectionConfig,
    /// Security analytics and monitoring configuration
    pub security_analytics: SecurityAnalyticsConfig,
    /// Compliance and audit configuration
    pub compliance_config: ComplianceConfig,
    /// Secure communication configuration
    pub secure_communication: SecureCommunicationConfig,
    /// Hardware security configuration
    pub hardware_security: HardwareSecurityConfig,
    /// Data protection and privacy configuration
    pub data_protection: DataProtectionConfig,
    /// Incident response configuration
    pub incident_response: IncidentResponseConfig,
    /// Security orchestration configuration
    pub security_orchestration: SecurityOrchestrationConfig,
    /// AI/ML security configuration
    pub ai_security: AISecurityConfig,
}

/// Security policy configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityPolicyConfig {
    /// Enable comprehensive security framework
    pub enable_security_framework: bool,
    /// Security classification levels
    pub classification_levels: Vec<SecurityClassification>,
    /// Security objectives
    pub security_objectives: Vec<SecurityObjective>,
    /// Risk tolerance levels
    pub risk_tolerance: RiskToleranceConfig,
    /// Security standards compliance
    pub standards_compliance: Vec<SecurityStandard>,
    /// Policy enforcement settings
    pub policy_enforcement: PolicyEnforcementConfig,
    /// Security governance settings
    pub governance_config: SecurityGovernanceConfig,
}

/// Configuration types with Default implementations
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct RiskToleranceConfig {
    pub risk_threshold: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PolicyEnforcementConfig {
    pub enforcement_mode: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityGovernanceConfig {
    pub governance_level: String,
}

/// Quantum-safe cryptography configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumSafeCryptographyConfig {
    /// Enable quantum-safe cryptography
    pub enable_quantum_safe_crypto: bool,
    /// Post-quantum cryptographic algorithms
    pub post_quantum_algorithms: Vec<PostQuantumAlgorithm>,
    /// Key management configuration
    pub key_management: QuantumKeyManagementConfig,
    /// Digital signature configuration
    pub digital_signatures: QuantumDigitalSignatureConfig,
    /// Encryption configuration
    pub encryption_config: QuantumEncryptionConfig,
    /// Key exchange configuration
    pub key_exchange: QuantumKeyExchangeConfig,
    /// Cryptographic agility settings
    pub crypto_agility: CryptographicAgilityConfig,
    /// Quantum random number generation
    pub quantum_rng: QuantumRNGConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuantumKeyManagementConfig {
    pub key_rotation_interval: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuantumDigitalSignatureConfig {
    pub signature_algorithm: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuantumEncryptionConfig {
    pub encryption_algorithm: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuantumKeyExchangeConfig {
    pub key_exchange_protocol: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct CryptographicAgilityConfig {
    pub agility_level: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuantumRNGConfig {
    pub entropy_source: String,
}

/// Access control configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessControlConfig {
    /// Authentication methods
    pub authentication_methods: Vec<AuthenticationMethod>,
    /// Authorization models
    pub authorization_models: Vec<AuthorizationModel>,
    /// Multi-factor authentication
    pub mfa_config: MFAConfig,
    /// Zero-trust architecture
    pub zero_trust: ZeroTrustConfig,
    /// Privileged access management
    pub privileged_access: PrivilegedAccessConfig,
    /// Session management
    pub session_management: SessionManagementConfig,
    /// Device and endpoint security
    pub endpoint_security: EndpointSecurityConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct MFAConfig {
    pub required_factors: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZeroTrustConfig {
    pub enable_zero_trust: bool,
    pub trust_verification_level: String,
    pub continuous_verification: bool,
    pub implicit_trust_timeout: Duration,
    pub trust_scores: HashMap<String, f64>,
}

impl Default for ZeroTrustConfig {
    fn default() -> Self {
        Self {
            enable_zero_trust: true,
            trust_verification_level: "high".to_string(),
            continuous_verification: true,
            implicit_trust_timeout: Duration::from_secs(300),
            trust_scores: HashMap::new(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrivilegedAccessConfig {
    pub enable_pam: bool,
    pub session_recording: bool,
    pub approval_workflow: bool,
    pub just_in_time_access: bool,
    pub access_timeout: Duration,
    pub approval_threshold: i32,
}

impl Default for PrivilegedAccessConfig {
    fn default() -> Self {
        Self {
            enable_pam: true,
            session_recording: true,
            approval_workflow: true,
            just_in_time_access: true,
            access_timeout: Duration::from_secs(3600),
            approval_threshold: 2,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionManagementConfig {
    pub session_timeout: Duration,
    pub max_concurrent_sessions: usize,
    pub session_tracking: bool,
    pub idle_timeout: Duration,
    pub forced_logout_conditions: Vec<String>,
}

impl Default for SessionManagementConfig {
    fn default() -> Self {
        Self {
            session_timeout: Duration::from_secs(7200),
            max_concurrent_sessions: 5,
            session_tracking: true,
            idle_timeout: Duration::from_secs(900),
            forced_logout_conditions: Vec::new(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EndpointSecurityConfig {
    pub endpoint_protection: bool,
    pub device_registration: bool,
    pub compliance_checking: bool,
    pub threat_detection: bool,
    pub patch_management: bool,
    pub data_loss_prevention: bool,
}

impl Default for EndpointSecurityConfig {
    fn default() -> Self {
        Self {
            endpoint_protection: true,
            device_registration: true,
            compliance_checking: true,
            threat_detection: true,
            patch_management: true,
            data_loss_prevention: true,
        }
    }
}

/// Threat detection configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreatDetectionConfig {
    /// Enable advanced threat detection
    pub enable_threat_detection: bool,
    /// Detection algorithms
    pub detection_algorithms: Vec<ThreatDetectionAlgorithm>,
    /// Anomaly detection configuration
    pub anomaly_detection: AnomalyDetectionConfig,
    /// Behavioral analysis configuration
    pub behavioral_analysis: BehavioralAnalysisConfig,
    /// Threat intelligence integration
    pub threat_intelligence: ThreatIntelligenceConfig,
    /// Machine learning detection
    pub ml_detection: MLThreatDetectionConfig,
    /// Real-time monitoring
    pub realtime_monitoring: RealtimeMonitoringConfig,
    /// Quantum-specific threat detection
    pub quantum_threat_detection: QuantumThreatDetectionConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnomalyDetectionConfig {
    pub enable_detection: bool,
    pub detection_algorithms: Vec<String>,
    pub baseline_learning_period: Duration,
    pub anomaly_threshold: f64,
    pub alert_threshold: f64,
    pub auto_response: bool,
}

impl Default for AnomalyDetectionConfig {
    fn default() -> Self {
        Self {
            enable_detection: true,
            detection_algorithms: vec!["isolation_forest".to_string(), "one_class_svm".to_string()],
            baseline_learning_period: Duration::from_secs(86400 * 7), // 1 week
            anomaly_threshold: 0.1,
            alert_threshold: 0.05,
            auto_response: true,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BehavioralAnalysisConfig {
    pub enable_analysis: bool,
    pub user_profiling: bool,
    pub pattern_recognition: bool,
    pub risk_scoring: bool,
    pub learning_period: Duration,
    pub update_frequency: Duration,
}

impl Default for BehavioralAnalysisConfig {
    fn default() -> Self {
        Self {
            enable_analysis: true,
            user_profiling: true,
            pattern_recognition: true,
            risk_scoring: true,
            learning_period: Duration::from_secs(86400 * 30), // 30 days
            update_frequency: Duration::from_secs(3600),      // 1 hour
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreatIntelligenceConfig {
    pub enable_threat_intel: bool,
    pub feed_sources: Vec<String>,
    pub update_frequency: Duration,
    pub threat_correlation: bool,
    pub ioc_matching: bool,
    pub threat_hunting: bool,
}

impl Default for ThreatIntelligenceConfig {
    fn default() -> Self {
        Self {
            enable_threat_intel: true,
            feed_sources: vec!["mitre".to_string(), "nist".to_string()],
            update_frequency: Duration::from_secs(3600),
            threat_correlation: true,
            ioc_matching: true,
            threat_hunting: true,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MLThreatDetectionConfig {
    pub enable_ml_detection: bool,
    pub model_types: Vec<String>,
    pub training_frequency: Duration,
    pub prediction_threshold: f64,
    pub feature_engineering: bool,
    pub ensemble_methods: bool,
}

impl Default for MLThreatDetectionConfig {
    fn default() -> Self {
        Self {
            enable_ml_detection: true,
            model_types: vec!["random_forest".to_string(), "neural_network".to_string()],
            training_frequency: Duration::from_secs(86400), // Daily
            prediction_threshold: 0.8,
            feature_engineering: true,
            ensemble_methods: true,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RealtimeMonitoringConfig {
    pub enable_realtime: bool,
    pub monitoring_interval: Duration,
    pub alert_latency_target: Duration,
    pub stream_processing: bool,
    pub data_retention_period: Duration,
    pub dashboards: Vec<String>,
}

impl Default for RealtimeMonitoringConfig {
    fn default() -> Self {
        Self {
            enable_realtime: true,
            monitoring_interval: Duration::from_millis(100),
            alert_latency_target: Duration::from_secs(1),
            stream_processing: true,
            data_retention_period: Duration::from_secs(86400 * 90), // 90 days
            dashboards: vec![
                "security_overview".to_string(),
                "threat_dashboard".to_string(),
            ],
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumThreatDetectionConfig {
    pub enable_quantum_threats: bool,
    pub quantum_attack_patterns: Vec<String>,
    pub quantum_vulnerability_scanning: bool,
    pub post_quantum_readiness: bool,
    pub quantum_safe_algorithms: Vec<String>,
    pub quantum_key_compromise_detection: bool,
}

impl Default for QuantumThreatDetectionConfig {
    fn default() -> Self {
        Self {
            enable_quantum_threats: true,
            quantum_attack_patterns: vec!["shor".to_string(), "grover".to_string()],
            quantum_vulnerability_scanning: true,
            post_quantum_readiness: true,
            quantum_safe_algorithms: vec!["kyber".to_string(), "dilithium".to_string()],
            quantum_key_compromise_detection: true,
        }
    }
}

/// Security analytics configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityAnalyticsConfig {
    /// Enable security analytics
    pub enable_security_analytics: bool,
    /// Analytics engines
    pub analytics_engines: Vec<SecurityAnalyticsEngine>,
    /// Security metrics collection
    pub metrics_collection: SecurityMetricsConfig,
    /// Risk assessment configuration
    pub risk_assessment: RiskAssessmentConfig,
    /// Security dashboards
    pub dashboard_config: SecurityDashboardConfig,
    /// Predictive security analytics
    pub predictive_analytics: PredictiveSecurityConfig,
    /// Security reporting
    pub reporting_config: SecurityReportingConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityMetricsConfig {
    pub collection_interval: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct RiskAssessmentConfig {
    pub assessment_frequency: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityDashboardConfig {
    pub dashboard_refresh_rate: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PredictiveSecurityConfig {
    pub prediction_window: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityReportingConfig {
    pub report_frequency: Duration,
}

/// Compliance configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComplianceConfig {
    /// Enable compliance monitoring
    pub enable_compliance_monitoring: bool,
    /// Regulatory frameworks
    pub regulatory_frameworks: Vec<RegulatoryFramework>,
    /// Compliance standards
    pub compliance_standards: Vec<ComplianceStandard>,
    /// Audit configuration
    pub audit_config: AuditConfig,
    /// Continuous compliance monitoring
    pub continuous_monitoring: ContinuousComplianceConfig,
    /// Compliance reporting
    pub compliance_reporting: ComplianceReportingConfig,
    /// Data governance
    pub data_governance: DataGovernanceConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AuditConfig {
    pub audit_retention_period: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ContinuousComplianceConfig {
    pub monitoring_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ComplianceReportingConfig {
    pub reporting_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DataGovernanceConfig {
    pub governance_framework: String,
}

/// Secure communication configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecureCommunicationConfig {
    /// Encryption protocols
    pub encryption_protocols: Vec<EncryptionProtocol>,
    /// Network security
    pub network_security: NetworkSecurityConfig,
    /// Secure channels
    pub secure_channels: SecureChannelConfig,
    /// End-to-end encryption
    pub e2e_encryption: E2EEncryptionConfig,
    /// Communication authentication
    pub communication_auth: CommunicationAuthConfig,
    /// Data integrity protection
    pub data_integrity: DataIntegrityConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct NetworkSecurityConfig {
    pub security_protocols: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecureChannelConfig {
    pub channel_encryption: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct E2EEncryptionConfig {
    pub encryption_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct CommunicationAuthConfig {
    pub auth_required: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DataIntegrityConfig {
    pub integrity_checks: bool,
}

/// Hardware security configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HardwareSecurityConfig {
    /// Hardware security modules
    pub hsm_config: HSMConfig,
    /// Trusted execution environments
    pub tee_config: TEEConfig,
    /// Hardware attestation
    pub attestation_config: AttestationConfig,
    /// Secure boot configuration
    pub secure_boot: SecureBootConfig,
    /// Hardware monitoring
    pub hardware_monitoring: HardwareMonitoringConfig,
    /// Physical security
    pub physical_security: PhysicalSecurityConfig,
    /// Quantum hardware security
    pub quantum_hardware_security: QuantumHardwareSecurityConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct HSMConfig {
    pub hsm_provider: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct TEEConfig {
    pub tee_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AttestationConfig {
    pub attestation_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecureBootConfig {
    pub secure_boot_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct HardwareMonitoringConfig {
    pub monitoring_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PhysicalSecurityConfig {
    pub physical_security_level: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuantumHardwareSecurityConfig {
    pub quantum_security_level: String,
}

/// Data protection configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataProtectionConfig {
    /// Data classification
    pub data_classification: DataClassificationConfig,
    /// Data loss prevention
    pub dlp_config: DLPConfig,
    /// Privacy protection
    pub privacy_protection: PrivacyProtectionConfig,
    /// Data encryption at rest
    pub encryption_at_rest: EncryptionAtRestConfig,
    /// Data masking and anonymization
    pub data_masking: DataMaskingConfig,
    /// Backup security
    pub backup_security: BackupSecurityConfig,
    /// Data lifecycle management
    pub lifecycle_management: DataLifecycleConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DataClassificationConfig {
    pub classification_levels: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DLPConfig {
    pub dlp_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PrivacyProtectionConfig {
    pub privacy_level: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct EncryptionAtRestConfig {
    pub encryption_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DataMaskingConfig {
    pub masking_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct BackupSecurityConfig {
    pub backup_encryption: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DataLifecycleConfig {
    pub retention_policy: String,
}

/// Incident response configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IncidentResponseConfig {
    /// Enable incident response
    pub enable_incident_response: bool,
    /// Response team configuration
    pub response_team: ResponseTeamConfig,
    /// Incident classification
    pub incident_classification: IncidentClassificationConfig,
    /// Response procedures
    pub response_procedures: ResponseProceduresConfig,
    /// Automated response
    pub automated_response: AutomatedResponseConfig,
    /// Communication protocols
    pub communication_protocols: IncidentCommunicationConfig,
    /// Recovery procedures
    pub recovery_procedures: RecoveryProceduresConfig,
    /// Post-incident analysis
    pub post_incident_analysis: PostIncidentAnalysisConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ResponseTeamConfig {
    pub team_size: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct IncidentClassificationConfig {
    pub classification_levels: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ResponseProceduresConfig {
    pub procedures: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AutomatedResponseConfig {
    pub automation_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct IncidentCommunicationConfig {
    pub communication_channels: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct RecoveryProceduresConfig {
    pub recovery_time_objective: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PostIncidentAnalysisConfig {
    pub analysis_enabled: bool,
}

/// Security orchestration configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityOrchestrationConfig {
    /// Enable security orchestration
    pub enable_security_orchestration: bool,
    /// Orchestration workflows
    pub orchestration_workflows: Vec<SecurityWorkflow>,
    /// Automation rules
    pub automation_rules: Vec<SecurityAutomationRule>,
    /// Integration configurations
    pub integrations: Vec<SecurityIntegration>,
    /// Playbook management
    pub playbook_management: PlaybookManagementConfig,
    /// Workflow orchestration
    pub workflow_orchestration: WorkflowOrchestrationConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityWorkflow {
    pub workflow_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityAutomationRule {
    pub rule_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SecurityIntegration {
    pub integration_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PlaybookManagementConfig {
    pub playbook_version: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkflowOrchestrationConfig {
    pub orchestration_enabled: bool,
}

/// AI/ML security configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AISecurityConfig {
    /// Enable AI-powered security
    pub enable_ai_security: bool,
    /// ML models for security
    pub ml_models: Vec<SecurityMLModel>,
    /// AI threat detection
    pub ai_threat_detection: AIThreatDetectionConfig,
    /// Adversarial attack protection
    pub adversarial_protection: AdversarialProtectionConfig,
    /// Model security
    pub model_security: ModelSecurityConfig,
    /// AI governance
    pub ai_governance: AIGovernanceConfig,
    /// Explainable AI for security
    pub explainable_ai: ExplainableAIConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AIThreatDetectionConfig {
    pub ai_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AdversarialProtectionConfig {
    pub protection_level: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ModelSecurityConfig {
    pub security_checks: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AIGovernanceConfig {
    pub governance_framework: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ExplainableAIConfig {
    pub explainability_enabled: bool,
}

impl Default for QuantumSecurityConfig {
    fn default() -> Self {
        Self {
            security_policy: SecurityPolicyConfig {
                enable_security_framework: true,
                classification_levels: vec![
                    SecurityClassification::Public,
                    SecurityClassification::Internal,
                    SecurityClassification::Confidential,
                    SecurityClassification::QuantumProtected,
                ],
                security_objectives: vec![
                    SecurityObjective::Confidentiality,
                    SecurityObjective::Integrity,
                    SecurityObjective::Availability,
                    SecurityObjective::Authentication,
                    SecurityObjective::QuantumSafety,
                ],
                risk_tolerance: RiskToleranceConfig::default(),
                standards_compliance: vec![
                    SecurityStandard::ISO27001,
                    SecurityStandard::NistCsf,
                    SecurityStandard::QuantumSafeNist,
                ],
                policy_enforcement: PolicyEnforcementConfig::default(),
                governance_config: SecurityGovernanceConfig::default(),
            },
            quantum_safe_crypto: QuantumSafeCryptographyConfig {
                enable_quantum_safe_crypto: true,
                post_quantum_algorithms: vec![
                    PostQuantumAlgorithm::Kyber,
                    PostQuantumAlgorithm::Dilithium,
                    PostQuantumAlgorithm::Falcon,
                    PostQuantumAlgorithm::SphincsPlus,
                ],
                key_management: QuantumKeyManagementConfig::default(),
                digital_signatures: QuantumDigitalSignatureConfig::default(),
                encryption_config: QuantumEncryptionConfig::default(),
                key_exchange: QuantumKeyExchangeConfig::default(),
                crypto_agility: CryptographicAgilityConfig::default(),
                quantum_rng: QuantumRNGConfig::default(),
            },
            access_control: AccessControlConfig {
                authentication_methods: vec![
                    AuthenticationMethod::QuantumKey,
                    AuthenticationMethod::CertificateBased,
                    AuthenticationMethod::Biometric,
                    AuthenticationMethod::ZeroKnowledgeProof,
                ],
                authorization_models: vec![
                    AuthorizationModel::ABAC,
                    AuthorizationModel::QuantumACL,
                    AuthorizationModel::ZeroTrust,
                ],
                mfa_config: MFAConfig::default(),
                zero_trust: ZeroTrustConfig::default(),
                privileged_access: PrivilegedAccessConfig::default(),
                session_management: SessionManagementConfig::default(),
                endpoint_security: EndpointSecurityConfig::default(),
            },
            threat_detection: ThreatDetectionConfig {
                enable_threat_detection: true,
                detection_algorithms: vec![
                    ThreatDetectionAlgorithm::MachineLearning,
                    ThreatDetectionAlgorithm::AnomalyDetection,
                    ThreatDetectionAlgorithm::QuantumStateAnalysis,
                    ThreatDetectionAlgorithm::QuantumNoiseAnalysis,
                ],
                anomaly_detection: AnomalyDetectionConfig::default(),
                behavioral_analysis: BehavioralAnalysisConfig::default(),
                threat_intelligence: ThreatIntelligenceConfig::default(),
                ml_detection: MLThreatDetectionConfig::default(),
                realtime_monitoring: RealtimeMonitoringConfig::default(),
                quantum_threat_detection: QuantumThreatDetectionConfig::default(),
            },
            security_analytics: SecurityAnalyticsConfig {
                enable_security_analytics: true,
                analytics_engines: vec![
                    SecurityAnalyticsEngine::SIEM,
                    SecurityAnalyticsEngine::SOAR,
                    SecurityAnalyticsEngine::QuantumSecurityAnalytics,
                    SecurityAnalyticsEngine::MLSecurityAnalytics,
                ],
                metrics_collection: SecurityMetricsConfig::default(),
                risk_assessment: RiskAssessmentConfig::default(),
                dashboard_config: SecurityDashboardConfig::default(),
                predictive_analytics: PredictiveSecurityConfig::default(),
                reporting_config: SecurityReportingConfig::default(),
            },
            compliance_config: ComplianceConfig {
                enable_compliance_monitoring: true,
                regulatory_frameworks: vec![
                    RegulatoryFramework::GDPR,
                    RegulatoryFramework::FISMA,
                    RegulatoryFramework::QuantumRegulations,
                ],
                compliance_standards: vec![
                    ComplianceStandard::ISO27001,
                    ComplianceStandard::Nist800_53,
                    ComplianceStandard::QuantumCompliance,
                ],
                audit_config: AuditConfig::default(),
                continuous_monitoring: ContinuousComplianceConfig::default(),
                compliance_reporting: ComplianceReportingConfig::default(),
                data_governance: DataGovernanceConfig::default(),
            },
            secure_communication: SecureCommunicationConfig {
                encryption_protocols: vec![
                    EncryptionProtocol::QuantumSafeTLS,
                    EncryptionProtocol::QuantumKeyDistribution,
                    EncryptionProtocol::Tls1_3,
                ],
                network_security: NetworkSecurityConfig::default(),
                secure_channels: SecureChannelConfig::default(),
                e2e_encryption: E2EEncryptionConfig::default(),
                communication_auth: CommunicationAuthConfig::default(),
                data_integrity: DataIntegrityConfig::default(),
            },
            hardware_security: HardwareSecurityConfig {
                hsm_config: HSMConfig::default(),
                tee_config: TEEConfig::default(),
                attestation_config: AttestationConfig::default(),
                secure_boot: SecureBootConfig::default(),
                hardware_monitoring: HardwareMonitoringConfig::default(),
                physical_security: PhysicalSecurityConfig::default(),
                quantum_hardware_security: QuantumHardwareSecurityConfig::default(),
            },
            data_protection: DataProtectionConfig {
                data_classification: DataClassificationConfig::default(),
                dlp_config: DLPConfig::default(),
                privacy_protection: PrivacyProtectionConfig::default(),
                encryption_at_rest: EncryptionAtRestConfig::default(),
                data_masking: DataMaskingConfig::default(),
                backup_security: BackupSecurityConfig::default(),
                lifecycle_management: DataLifecycleConfig::default(),
            },
            incident_response: IncidentResponseConfig {
                enable_incident_response: true,
                response_team: ResponseTeamConfig::default(),
                incident_classification: IncidentClassificationConfig::default(),
                response_procedures: ResponseProceduresConfig::default(),
                automated_response: AutomatedResponseConfig::default(),
                communication_protocols: IncidentCommunicationConfig::default(),
                recovery_procedures: RecoveryProceduresConfig::default(),
                post_incident_analysis: PostIncidentAnalysisConfig::default(),
            },
            security_orchestration: SecurityOrchestrationConfig {
                enable_security_orchestration: true,
                orchestration_workflows: vec![SecurityWorkflow::default()],
                automation_rules: vec![SecurityAutomationRule::default()],
                integrations: vec![SecurityIntegration::default()],
                playbook_management: PlaybookManagementConfig::default(),
                workflow_orchestration: WorkflowOrchestrationConfig::default(),
            },
            ai_security: AISecurityConfig {
                enable_ai_security: true,
                ml_models: vec![
                    SecurityMLModel::AnomalyDetection,
                    SecurityMLModel::ThreatClassification,
                    SecurityMLModel::QuantumAnomalyDetection,
                    SecurityMLModel::QuantumThreatClassification,
                ],
                ai_threat_detection: AIThreatDetectionConfig::default(),
                adversarial_protection: AdversarialProtectionConfig::default(),
                model_security: ModelSecurityConfig::default(),
                ai_governance: AIGovernanceConfig::default(),
                explainable_ai: ExplainableAIConfig::default(),
            },
        }
    }
}