reasonkit-core 0.1.8

//! Edge Case Generator for ThinkTool Protocols
//!
//! This module generates boundary condition test cases for ThinkTool protocols,
//! focusing on infinite recursion, circular logic, and stack overflow scenarios.
//!
//! ## Boundary Conditions Identified:
//!
//! ### Infinite Recursion Scenarios:
//! - Self-refine loops that never converge (max_iterations reached)
//! - Circular dependencies in BedRock principle reconstruction
//! - Protocol steps that reference each other cyclically
//! - Oscillation cycles that don't terminate
//!
//! ### Circular Logic Scenarios:
//! - LaserLogic circular reasoning detection
//! - Arguments where premises restate the conclusion
//! - Validation loops where output validates itself
//!
//! ### Stack Overflow Scenarios:
//! - Deep recursion in principle chains
//! - Very long reasoning chains in protocols
//! - Nested protocol execution
//! - Deep synthesis of many perspectives
//!
//! ### Other Boundary Conditions:
//! - Query too short/long limits
//! - Insufficient perspectives generated
//! - Confidence thresholds not met
//! - Cross-validation failures
//! - Memory exhaustion from large datasets

use super::modules::ThinkToolContext;
use crate::error::{Error, Result};
use serde::{Deserialize, Serialize};

/// Types of edge cases that can occur in ThinkTool protocols
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EdgeCaseType {
    /// Infinite recursion in self-refinement loops
    InfiniteRecursion,
    /// Circular dependencies between reasoning steps
    CircularDependency,
    /// Deep recursion causing stack overflow
    StackOverflow,
    /// Circular reasoning in logical arguments
    CircularReasoning,
    /// Query input too short for processing
    QueryTooShort,
    /// Query input too long for processing
    QueryTooLong,
    /// Insufficient perspectives generated
    InsufficientPerspectives,
    /// Confidence below acceptable threshold
    LowConfidence,
    /// Cross-validation failure between perspectives
    CrossValidationFailure,
    /// Memory exhaustion from large datasets
    MemoryExhaustion,
    /// Timeout during execution
    ExecutionTimeout,
}

/// Configuration for edge case generation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdgeCaseGeneratorConfig {
    /// Maximum depth for recursive structures
    pub max_recursion_depth: usize,
    /// Maximum length for generated queries
    pub max_query_length: usize,
    /// Minimum perspectives to consider "insufficient"
    pub min_perspectives_threshold: usize,
    /// Confidence threshold for low confidence cases
    pub low_confidence_threshold: f64,
    /// Whether to include memory-intensive test cases
    pub include_memory_tests: bool,
    /// Whether to include timeout test cases
    pub include_timeout_tests: bool,
}

impl Default for EdgeCaseGeneratorConfig {
    fn default() -> Self {
        Self {
            max_recursion_depth: 100,
            max_query_length: 10000,
            min_perspectives_threshold: 3,
            low_confidence_threshold: 0.3,
            include_memory_tests: false,
            include_timeout_tests: false,
        }
    }
}

/// Generated edge case test case
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdgeCaseTest {
    /// Type of edge case
    pub case_type: EdgeCaseType,
    /// Human-readable description
    pub description: String,
    /// Input context that triggers the edge case
    pub input: ThinkToolContext,
    /// Expected behavior (what should happen)
    pub expected_behavior: ExpectedBehavior,
    /// Risk level (how dangerous this edge case is)
    pub risk_level: RiskLevel,
    /// Module this test case is designed for
    pub target_module: String,
}

/// Expected behavior when encountering the edge case
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ExpectedBehavior {
    /// Should return an error with specific message
    Error { message_contains: String },
    /// Should timeout after specified duration
    Timeout { max_duration_ms: u64 },
    /// Should succeed but with degraded performance
    DegradedPerformance { acceptable_confidence: f64 },
    /// Should detect and handle the circular logic
    CircularLogicDetected,
    /// Should prevent infinite recursion
    RecursionPrevented,
}

/// Risk level of the edge case
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub enum RiskLevel {
    /// Low risk - may cause minor performance issues
    Low,
    /// Medium risk - may cause significant slowdowns or memory usage
    Medium,
    /// High risk - may cause crashes or infinite loops
    High,
    /// Critical risk - may cause system instability or data corruption
    Critical,
}

/// Edge case generator for ThinkTool protocols
#[derive(Default)]
pub struct EdgeCaseGenerator {
    config: EdgeCaseGeneratorConfig,
    generated_cases: Vec<EdgeCaseTest>,
}

impl EdgeCaseGenerator {
    /// Create a new edge case generator with default configuration
    pub fn new() -> Self {
        Self::default()
    }

    /// Create generator with custom configuration
    pub fn with_config(config: EdgeCaseGeneratorConfig) -> Self {
        Self {
            config,
            generated_cases: Vec::new(),
        }
    }

    /// Generate all edge case test cases
    pub fn generate_all_cases(&mut self) -> Result<&[EdgeCaseTest]> {
        self.generated_cases.clear();

        // Generate cases for each module
        self.generate_gigathink_cases()?;
        self.generate_laserlogic_cases()?;
        self.generate_bedrock_cases()?;
        self.generate_brutalhonesty_cases()?;
        self.generate_proofguard_cases()?;

        // Generate cross-protocol cases
        self.generate_protocol_edge_cases()?;

        Ok(&self.generated_cases)
    }

    /// Generate edge cases specific to GigaThink module
    fn generate_gigathink_cases(&mut self) -> Result<()> {
        // Query too short
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::QueryTooShort,
            description: "Query too short for meaningful GigaThink analysis".to_string(),
            input: ThinkToolContext::new("X"),
            expected_behavior: ExpectedBehavior::Error {
                message_contains: "Query too short".to_string(),
            },
            risk_level: RiskLevel::Low,
            target_module: "GigaThink".to_string(),
        });

        // Query too long
        let long_query = "What are the implications?".repeat(1000);
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::QueryTooLong,
            description: "Extremely long query that may cause processing issues".to_string(),
            input: ThinkToolContext::new(long_query),
            expected_behavior: ExpectedBehavior::DegradedPerformance {
                acceptable_confidence: 0.5,
            },
            risk_level: RiskLevel::Medium,
            target_module: "GigaThink".to_string(),
        });

        // Insufficient perspectives scenario (mock this by providing context that should generate few perspectives)
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::InsufficientPerspectives,
            description: "Query that should generate very few diverse perspectives".to_string(),
            input: ThinkToolContext::new("Yes or no?"),
            expected_behavior: ExpectedBehavior::DegradedPerformance {
                acceptable_confidence: 0.3,
            },
            risk_level: RiskLevel::Low,
            target_module: "GigaThink".to_string(),
        });

        Ok(())
    }

    /// Generate edge cases specific to LaserLogic module
    fn generate_laserlogic_cases(&mut self) -> Result<()> {
        // Circular reasoning case
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::CircularReasoning,
            description: "Argument with circular reasoning (conclusion restates premise)".to_string(),
            input: ThinkToolContext::new("The Bible is true because it is the word of God. Therefore, the Bible is the word of God."),
            expected_behavior: ExpectedBehavior::CircularLogicDetected,
            risk_level: RiskLevel::Low,
            target_module: "LaserLogic".to_string(),
        });

        // Deep nested logical structure that might cause stack issues
        let deep_logic = self.generate_deep_logical_structure(50);
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::StackOverflow,
            description: "Deeply nested logical argument structure".to_string(),
            input: ThinkToolContext::new(deep_logic),
            expected_behavior: ExpectedBehavior::DegradedPerformance {
                acceptable_confidence: 0.6,
            },
            risk_level: RiskLevel::High,
            target_module: "LaserLogic".to_string(),
        });

        Ok(())
    }

    /// Generate edge cases specific to BedRock module
    fn generate_bedrock_cases(&mut self) -> Result<()> {
        // Circular dependency in principle reconstruction
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::CircularDependency,
            description: "Principles with circular dependencies that could cause infinite loops"
                .to_string(),
            input: ThinkToolContext::new("A depends on B, B depends on C, C depends on A"),
            expected_behavior: ExpectedBehavior::RecursionPrevented,
            risk_level: RiskLevel::High,
            target_module: "BedRock".to_string(),
        });

        // Very deep principle chain
        let deep_chain = self.generate_deep_principle_chain(100);
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::StackOverflow,
            description: "Extremely deep principle decomposition chain".to_string(),
            input: ThinkToolContext::new(deep_chain),
            expected_behavior: ExpectedBehavior::RecursionPrevented,
            risk_level: RiskLevel::Critical,
            target_module: "BedRock".to_string(),
        });

        Ok(())
    }

    /// Generate edge cases specific to BrutalHonesty module
    fn generate_brutalhonesty_cases(&mut self) -> Result<()> {
        // Self-contradictory statement that might cause oscillation
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::CircularDependency,
            description: "Self-contradictory claim that challenges critique consistency"
                .to_string(),
            input: ThinkToolContext::new(
                "This statement is false, and I am completely honest about it.",
            ),
            expected_behavior: ExpectedBehavior::DegradedPerformance {
                acceptable_confidence: 0.4,
            },
            risk_level: RiskLevel::Medium,
            target_module: "BrutalHonesty".to_string(),
        });

        Ok(())
    }

    /// Generate edge cases specific to ProofGuard module
    fn generate_proofguard_cases(&mut self) -> Result<()> {
        // Claim requiring impossible number of sources
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::MemoryExhaustion,
            description: "Claim requiring validation against 1000+ sources".to_string(),
            input: ThinkToolContext::new(
                "This claim requires validation from every scientific paper ever written.",
            ),
            expected_behavior: ExpectedBehavior::DegradedPerformance {
                acceptable_confidence: 0.2,
            },
            risk_level: RiskLevel::Medium,
            target_module: "ProofGuard".to_string(),
        });

        Ok(())
    }

    /// Generate cross-protocol edge cases
    fn generate_protocol_edge_cases(&mut self) -> Result<()> {
        // Self-refine loop that never converges
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::InfiniteRecursion,
            description: "Self-refinement that oscillates without convergence".to_string(),
            input: ThinkToolContext::new("Improve this answer forever without stopping."),
            expected_behavior: ExpectedBehavior::RecursionPrevented,
            risk_level: RiskLevel::Critical,
            target_module: "SelfRefine".to_string(),
        });

        // Oscillation that doesn't terminate
        self.generated_cases.push(EdgeCaseTest {
            case_type: EdgeCaseType::InfiniteRecursion,
            description: "Oscillation pattern that generates infinite divergent-convergent cycles"
                .to_string(),
            input: ThinkToolContext::new("Generate ideas that keep branching forever."),
            expected_behavior: ExpectedBehavior::RecursionPrevented,
            risk_level: RiskLevel::Critical,
            target_module: "Oscillation".to_string(),
        });

        if self.config.include_timeout_tests {
            // Timeout case
            self.generated_cases.push(EdgeCaseTest {
                case_type: EdgeCaseType::ExecutionTimeout,
                description: "Query designed to cause excessive processing time".to_string(),
                input: ThinkToolContext::new(
                    "Solve every unsolved mathematical problem in the world simultaneously.",
                ),
                expected_behavior: ExpectedBehavior::Timeout {
                    max_duration_ms: 30000,
                },
                risk_level: RiskLevel::High,
                target_module: "Any".to_string(),
            });
        }

        if self.config.include_memory_tests {
            // Memory exhaustion case
            let memory_hog = "Consider all possible combinations of: ".repeat(1000)
                + "every word in every language.";
            self.generated_cases.push(EdgeCaseTest {
                case_type: EdgeCaseType::MemoryExhaustion,
                description: "Query designed to exhaust available memory".to_string(),
                input: ThinkToolContext::new(memory_hog),
                expected_behavior: ExpectedBehavior::Error {
                    message_contains: "memory".to_string(),
                },
                risk_level: RiskLevel::Critical,
                target_module: "Any".to_string(),
            });
        }

        Ok(())
    }

    /// Generate a deeply nested logical structure
    fn generate_deep_logical_structure(&self, depth: usize) -> String {
        let mut structure = "If A then B.".to_string();

        for i in 0..depth {
            structure = format!("If {} then C{}, and C{} implies D{}.", structure, i, i, i);
        }

        format!("{} Therefore, Z follows.", structure)
    }

    /// Generate a deep principle dependency chain
    fn generate_deep_principle_chain(&self, depth: usize) -> String {
        let mut chain = Vec::new();

        for i in 0..depth {
            chain.push(format!("Principle {} depends on principle {}", i, i + 1));
        }

        chain.push(format!("Principle {} depends on principle 0", depth));
        chain.join(". ")
    }

    /// Get all generated test cases
    pub fn test_cases(&self) -> &[EdgeCaseTest] {
        &self.generated_cases
    }

    /// Filter test cases by risk level
    pub fn filter_by_risk_level(&self, min_risk: RiskLevel) -> Vec<&EdgeCaseTest> {
        self.generated_cases
            .iter()
            .filter(|case| case.risk_level >= min_risk)
            .collect()
    }

    /// Filter test cases by type
    pub fn filter_by_type(&self, case_type: EdgeCaseType) -> Vec<&EdgeCaseTest> {
        self.generated_cases
            .iter()
            .filter(|case| case.case_type == case_type)
            .collect()
    }

    /// Export test cases to JSON
    pub fn export_to_json(&self) -> Result<String> {
        serde_json::to_string_pretty(&self.generated_cases).map_err(Error::Json)
    }

    /// Import test cases from JSON
    pub fn import_from_json(&mut self, json: &str) -> Result<()> {
        self.generated_cases = serde_json::from_str(json).map_err(Error::Json)?;
        Ok(())
    }
}

/// Test runner for edge cases
pub struct EdgeCaseRunner {
    generator: EdgeCaseGenerator,
}

impl EdgeCaseRunner {
    /// Create a new edge case runner
    pub fn new(config: EdgeCaseGeneratorConfig) -> Self {
        Self {
            generator: EdgeCaseGenerator::with_config(config),
        }
    }

    /// Run all generated edge case tests
    pub async fn run_all_tests(&mut self) -> Result<EdgeCaseReport> {
        self.generator.generate_all_cases()?;

        let mut report = EdgeCaseReport {
            total_tests: self.generator.test_cases().len(),
            passed: 0,
            failed: 0,
            skipped: 0,
            results: Vec::new(),
        };

        // Note: In a real implementation, this would execute each test case
        // against the actual ThinkTool modules. For now, we just report structure.

        for test_case in self.generator.test_cases() {
            // Simulate test execution (would be replaced with actual module calls)
            let result = EdgeCaseResult {
                test_case: test_case.clone(),
                success: true,          // Placeholder
                execution_time_ms: 100, // Placeholder
                error_message: None,
                actual_behavior: "Test executed successfully".to_string(),
            };

            if result.success {
                report.passed += 1;
            } else {
                report.failed += 1;
            }

            report.results.push(result);
        }

        Ok(report)
    }
}

/// Report from running edge case tests
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdgeCaseReport {
    /// Total number of tests run
    pub total_tests: usize,
    /// Number of tests that passed
    pub passed: usize,
    /// Number of tests that failed
    pub failed: usize,
    /// Number of tests that were skipped
    pub skipped: usize,
    /// Detailed results for each test
    pub results: Vec<EdgeCaseResult>,
}

/// Result of a single edge case test
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdgeCaseResult {
    /// The test case that was executed
    pub test_case: EdgeCaseTest,
    /// Whether the test passed
    pub success: bool,
    /// Execution time in milliseconds
    pub execution_time_ms: u64,
    /// Error message if the test failed
    pub error_message: Option<String>,
    /// Description of what actually happened
    pub actual_behavior: String,
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashSet;

    #[test]
    fn test_edge_case_generator_creation() {
        let generator = EdgeCaseGenerator::new();
        assert!(generator.test_cases().is_empty());
    }

    #[test]
    fn test_generate_gigathink_cases() {
        let mut generator = EdgeCaseGenerator::new();
        generator.generate_gigathink_cases().unwrap();

        let cases = generator.test_cases();
        assert!(!cases.is_empty());

        // Should have query too short, too long, and insufficient perspectives cases
        let types: HashSet<_> = cases.iter().map(|c| c.case_type).collect();
        assert!(types.contains(&EdgeCaseType::QueryTooShort));
        assert!(types.contains(&EdgeCaseType::QueryTooLong));
        assert!(types.contains(&EdgeCaseType::InsufficientPerspectives));
    }

    #[test]
    fn test_generate_laserlogic_cases() {
        let mut generator = EdgeCaseGenerator::new();
        generator.generate_laserlogic_cases().unwrap();

        let cases = generator.test_cases();
        assert!(!cases.is_empty());

        let types: HashSet<_> = cases.iter().map(|c| c.case_type).collect();
        assert!(types.contains(&EdgeCaseType::CircularReasoning));
        assert!(types.contains(&EdgeCaseType::StackOverflow));
    }

    #[test]
    fn test_deep_structure_generation() {
        let generator = EdgeCaseGenerator::new();
        let structure = generator.generate_deep_logical_structure(3);

        // Should contain nested if-then statements
        assert!(structure.contains("If"));
        assert!(structure.contains("then"));
        assert!(structure.contains("Therefore"));
    }

    #[test]
    fn test_filter_by_risk_level() {
        let mut generator = EdgeCaseGenerator::new();
        generator.generate_all_cases().unwrap();

        let high_risk_cases = generator.filter_by_risk_level(RiskLevel::High);
        assert!(!high_risk_cases.is_empty());

        // All returned cases should be high risk or higher
        for case in high_risk_cases {
            assert!(case.risk_level >= RiskLevel::High);
        }
    }

    #[test]
    fn test_json_export_import() {
        let mut generator = EdgeCaseGenerator::new();
        generator.generate_gigathink_cases().unwrap();

        let json = generator.export_to_json().unwrap();
        assert!(!json.is_empty());

        let mut new_generator = EdgeCaseGenerator::new();
        new_generator.import_from_json(&json).unwrap();

        assert_eq!(
            generator.test_cases().len(),
            new_generator.test_cases().len()
        );
    }

    #[test]
    fn test_edge_case_runner() {
        let config = EdgeCaseGeneratorConfig {
            include_memory_tests: false,
            include_timeout_tests: false,
            ..Default::default()
        };

        let mut runner = EdgeCaseRunner::new(config);

        // This would normally run actual tests, but for this test we just check structure
        let report = futures::executor::block_on(runner.run_all_tests()).unwrap();
        assert_eq!(
            report.total_tests,
            report.passed + report.failed + report.skipped
        );
    }
}