quantrs2-anneal 0.1.3

//! Test scenarios and test case definitions

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

/// Test case registry
pub struct TestRegistry {
    /// Registered test cases
    pub test_cases: HashMap<String, IntegrationTestCase>,
    /// Test suites
    pub test_suites: HashMap<String, TestSuite>,
    /// Test dependencies
    pub dependencies: HashMap<String, Vec<String>>,
    /// Test categories
    pub categories: HashMap<TestCategory, Vec<String>>,
}

impl TestRegistry {
    #[must_use]
    pub fn new() -> Self {
        Self {
            test_cases: HashMap::new(),
            test_suites: HashMap::new(),
            dependencies: HashMap::new(),
            categories: HashMap::new(),
        }
    }

    pub fn register_test_case(&mut self, test_case: IntegrationTestCase) -> Result<(), String> {
        let id = test_case.id.clone();
        let category = test_case.category.clone();

        self.test_cases.insert(id.clone(), test_case);

        // Add to category index
        self.categories
            .entry(category)
            .or_insert_with(Vec::new)
            .push(id);

        Ok(())
    }

    /// Register a test suite
    pub fn register_test_suite(&mut self, test_suite: TestSuite) -> Result<(), String> {
        let id = test_suite.id.clone();
        self.test_suites.insert(id, test_suite);
        Ok(())
    }

    /// Unregister a test case
    pub fn unregister_test_case(&mut self, test_case_id: &str) -> Result<(), String> {
        self.test_cases
            .remove(test_case_id)
            .ok_or_else(|| format!("Test case {test_case_id} not found"))?;

        // Remove from dependencies
        self.dependencies.remove(test_case_id);

        Ok(())
    }

    /// Get a test case by ID
    #[must_use]
    pub fn get_test_case(&self, test_case_id: &str) -> Option<&IntegrationTestCase> {
        self.test_cases.get(test_case_id)
    }

    /// Get a test suite by ID
    #[must_use]
    pub fn get_test_suite(&self, test_suite_id: &str) -> Option<&TestSuite> {
        self.test_suites.get(test_suite_id)
    }

    /// Get all test cases in a category
    #[must_use]
    pub fn get_test_cases_by_category(&self, category: &TestCategory) -> Vec<&IntegrationTestCase> {
        if let Some(ids) = self.categories.get(category) {
            ids.iter()
                .filter_map(|id| self.test_cases.get(id))
                .collect()
        } else {
            Vec::new()
        }
    }

    /// Add a dependency between test cases
    pub fn add_dependency(&mut self, test_case_id: String, dependency_id: String) {
        self.dependencies
            .entry(test_case_id)
            .or_insert_with(Vec::new)
            .push(dependency_id);
    }

    /// Get dependencies for a test case
    #[must_use]
    pub fn get_dependencies(&self, test_case_id: &str) -> Vec<&str> {
        self.dependencies
            .get(test_case_id)
            .map(|deps| deps.iter().map(std::string::String::as_str).collect())
            .unwrap_or_default()
    }

    /// List all test cases
    #[must_use]
    pub fn list_test_cases(&self) -> Vec<&IntegrationTestCase> {
        self.test_cases.values().collect()
    }

    /// List all test suites
    #[must_use]
    pub fn list_test_suites(&self) -> Vec<&TestSuite> {
        self.test_suites.values().collect()
    }

    /// Get test case count
    #[must_use]
    pub fn test_case_count(&self) -> usize {
        self.test_cases.len()
    }

    /// Get test suite count
    #[must_use]
    pub fn test_suite_count(&self) -> usize {
        self.test_suites.len()
    }

    /// Clear all test cases and suites
    pub fn clear_all(&mut self) {
        self.test_cases.clear();
        self.test_suites.clear();
        self.dependencies.clear();
        self.categories.clear();
    }

    /// Find test cases by name pattern
    #[must_use]
    pub fn find_test_cases(&self, pattern: &str) -> Vec<&IntegrationTestCase> {
        self.test_cases
            .values()
            .filter(|tc| tc.name.contains(pattern) || tc.description.contains(pattern))
            .collect()
    }
}

/// Integration test case definition
#[derive(Debug, Clone)]
pub struct IntegrationTestCase {
    /// Test case identifier
    pub id: String,
    /// Test case name
    pub name: String,
    /// Test description
    pub description: String,
    /// Test category
    pub category: TestCategory,
    /// Test priority
    pub priority: TestPriority,
    /// Test timeout
    pub timeout: Duration,
    /// Test prerequisites
    pub prerequisites: Vec<String>,
    /// Test parameters
    pub parameters: HashMap<String, TestParameter>,
    /// Expected results
    pub expected_results: ExpectedResults,
    /// Test steps
    pub test_steps: Vec<TestStep>,
    /// Test metadata
    pub metadata: TestMetadata,
}

/// Test suite definition
#[derive(Debug, Clone)]
pub struct TestSuite {
    /// Suite identifier
    pub id: String,
    /// Suite name
    pub name: String,
    /// Suite description
    pub description: String,
    /// Test cases in the suite
    pub test_cases: Vec<String>,
    /// Suite configuration
    pub configuration: TestSuiteConfig,
    /// Suite metadata
    pub metadata: TestMetadata,
}

/// Test categories
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TestCategory {
    /// Unit integration tests
    Unit,
    /// Component integration tests
    Component,
    /// System integration tests
    System,
    /// End-to-end tests
    EndToEnd,
    /// Performance tests
    Performance,
    /// Stress tests
    Stress,
    /// Security tests
    Security,
    /// Compatibility tests
    Compatibility,
    /// Custom category
    Custom(String),
}

/// Test priorities
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
pub enum TestPriority {
    Low = 1,
    Normal = 2,
    High = 3,
    Critical = 4,
}

/// Test parameter definition
#[derive(Debug, Clone)]
pub struct TestParameter {
    /// Parameter name
    pub name: String,
    /// Parameter type
    pub parameter_type: ParameterType,
    /// Default value
    pub default_value: Option<ParameterValue>,
    /// Parameter description
    pub description: String,
    /// Validation rules
    pub validation: ParameterValidation,
}

/// Parameter types
#[derive(Debug, Clone, PartialEq)]
pub enum ParameterType {
    /// Boolean parameter
    Boolean,
    /// Integer parameter
    Integer,
    /// Float parameter
    Float,
    /// String parameter
    String,
    /// Array parameter
    Array(Box<Self>),
    /// Object parameter
    Object(HashMap<String, Self>),
}

/// Parameter values
#[derive(Debug, Clone)]
pub enum ParameterValue {
    /// Boolean value
    Boolean(bool),
    /// Integer value
    Integer(i64),
    /// Float value
    Float(f64),
    /// String value
    String(String),
    /// Array value
    Array(Vec<Self>),
    /// Object value
    Object(HashMap<String, Self>),
}

/// Parameter validation rules
#[derive(Debug, Clone)]
pub struct ParameterValidation {
    /// Required parameter
    pub required: bool,
    /// Minimum value
    pub min_value: Option<f64>,
    /// Maximum value
    pub max_value: Option<f64>,
    /// Allowed values
    pub allowed_values: Option<Vec<ParameterValue>>,
    /// Custom validation function
    pub custom_validator: Option<String>,
}

/// Expected test results
#[derive(Debug, Clone)]
pub struct ExpectedResults {
    /// Expected outcome
    pub outcome: ExpectedOutcome,
    /// Result validation
    pub validation: ResultValidation,
    /// Expected performance metrics
    pub performance_metrics: Option<ExpectedPerformanceMetrics>,
    /// Expected side effects
    pub side_effects: Vec<ExpectedSideEffect>,
}

/// Expected test outcomes
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExpectedOutcome {
    /// Test should pass
    Pass,
    /// Test should fail
    Fail,
    /// Test should be skipped
    Skip,
    /// Custom outcome
    Custom(String),
}

/// Result validation specification
#[derive(Debug, Clone)]
pub struct ResultValidation {
    /// Validation method
    pub method: ValidationMethod,
    /// Tolerance for numeric results
    pub tolerance: Option<f64>,
    /// Confidence level required
    pub confidence_level: f64,
}

/// Validation methods for results
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ValidationMethod {
    /// Exact match
    Exact,
    /// Approximate match
    Approximate,
    /// Range check
    Range,
    /// Statistical validation
    Statistical,
    /// Custom validation
    Custom(String),
}

/// Expected performance metrics
#[derive(Debug, Clone)]
pub struct ExpectedPerformanceMetrics {
    /// Expected execution time
    pub execution_time: Option<Duration>,
    /// Expected memory usage
    pub memory_usage: Option<usize>,
    /// Expected throughput
    pub throughput: Option<f64>,
    /// Expected error rate
    pub error_rate: Option<f64>,
    /// Custom metrics
    pub custom_metrics: HashMap<String, f64>,
}

/// Expected side effects
#[derive(Debug, Clone)]
pub struct ExpectedSideEffect {
    /// Side effect name
    pub name: String,
    /// Side effect type
    pub effect_type: SideEffectType,
    /// Effect description
    pub description: String,
    /// Acceptance criteria
    pub acceptance_criteria: AcceptanceCriteria,
}

/// Types of side effects
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SideEffectType {
    /// State change
    StateChange,
    /// Resource consumption
    ResourceConsumption,
    /// Performance impact
    PerformanceImpact,
    /// Data modification
    DataModification,
    /// Custom side effect
    Custom(String),
}

/// Acceptance criteria for side effects
#[derive(Debug, Clone)]
pub struct AcceptanceCriteria {
    /// Acceptable impact level
    pub acceptable_impact: ImpactLevel,
    /// Maximum duration
    pub max_duration: Option<Duration>,
    /// Recovery requirements
    pub recovery_requirements: Vec<String>,
}

/// Impact levels for side effects
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
pub enum ImpactLevel {
    None = 0,
    Minimal = 1,
    Low = 2,
    Medium = 3,
    High = 4,
    Critical = 5,
}

/// Individual test step
#[derive(Debug, Clone)]
pub struct TestStep {
    /// Step identifier
    pub id: String,
    /// Step name
    pub name: String,
    /// Step description
    pub description: String,
    /// Step type
    pub step_type: StepType,
    /// Step parameters
    pub parameters: HashMap<String, ParameterValue>,
    /// Step timeout
    pub timeout: Option<Duration>,
    /// Retry configuration
    pub retry_config: Option<RetryConfig>,
}

/// Test step types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StepType {
    /// Setup step
    Setup,
    /// Execution step
    Execution,
    /// Validation step
    Validation,
    /// Cleanup step
    Cleanup,
    /// Custom step
    Custom(String),
}

/// Retry configuration for test steps
#[derive(Debug, Clone)]
pub struct RetryConfig {
    /// Maximum retry attempts
    pub max_attempts: usize,
    /// Retry delay
    pub retry_delay: Duration,
    /// Exponential backoff
    pub exponential_backoff: bool,
    /// Retry conditions
    pub retry_conditions: Vec<String>,
}

/// Test suite configuration
#[derive(Debug, Clone)]
pub struct TestSuiteConfig {
    /// Execution order
    pub execution_order: ExecutionOrder,
    /// Parallel execution settings
    pub parallel_execution: ParallelExecutionConfig,
    /// Suite timeout
    pub timeout: Duration,
    /// Failure handling
    pub failure_handling: FailureHandling,
}

/// Test execution order
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExecutionOrder {
    /// Sequential execution
    Sequential,
    /// Parallel execution
    Parallel,
    /// Dependency-based order
    DependencyBased,
    /// Priority-based order
    PriorityBased,
    /// Custom order
    Custom(Vec<String>),
}

/// Parallel execution configuration
#[derive(Debug, Clone)]
pub struct ParallelExecutionConfig {
    /// Enable parallel execution
    pub enable_parallel: bool,
    /// Maximum parallel threads
    pub max_threads: usize,
    /// Thread pool configuration
    pub thread_pool_config: ThreadPoolConfig,
}

/// Thread pool configuration
#[derive(Debug, Clone)]
pub struct ThreadPoolConfig {
    /// Core pool size
    pub core_size: usize,
    /// Maximum pool size
    pub max_size: usize,
    /// Thread keepalive time
    pub keepalive_time: Duration,
    /// Queue capacity
    pub queue_capacity: usize,
}

/// Failure handling strategies
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FailureHandling {
    /// Stop on first failure
    StopOnFirstFailure,
    /// Continue on failure
    ContinueOnFailure,
    /// Retry failed tests
    RetryFailedTests,
    /// Custom handling
    Custom(String),
}

/// Test metadata
#[derive(Debug, Clone)]
pub struct TestMetadata {
    /// Test author
    pub author: String,
    /// Creation timestamp
    pub created: SystemTime,
    /// Last modified timestamp
    pub modified: SystemTime,
    /// Test version
    pub version: String,
    /// Tags
    pub tags: Vec<String>,
    /// Custom metadata
    pub custom: HashMap<String, String>,
}