reasonkit-core 0.1.8

//! Enhanced GigaThink with MiniMax M2 Integration
//!
//! Implements M2's composite instruction constraints and Interleaved Thinking
//! for expansive creative thinking with 10+ perspectives.

use super::{
    execute_profile_based_thinktool, CompositeInstruction, ConstraintResult, InterleavedProtocol,
    M2ThinkTool, M2ThinkToolResult, ProfileType,
};
use crate::error::Result;
use std::time::Instant;

/// Enhanced GigaThink module with M2 capabilities
pub struct EnhancedGigaThink {
    pub module_id: String,
    pub version: String,
    pub composite_constraints: Vec<CompositeInstruction>,
    pub interleaved_protocol: InterleavedProtocol,
}

impl Default for EnhancedGigaThink {
    fn default() -> Self {
        Self::new()
    }
}

impl EnhancedGigaThink {
    pub fn new() -> Self {
        let module_id = "enhanced_gigathink".to_string();
        let version = "2.0.0-minimax".to_string();

        Self {
            module_id: module_id.clone(),
            version,
            composite_constraints: Self::create_composite_constraints(),
            interleaved_protocol: Self::create_interleaved_protocol(module_id),
        }
    }

    /// Create M2 composite instruction constraints
    fn create_composite_constraints() -> Vec<CompositeInstruction> {
        vec![
            CompositeInstruction::SystemPrompt(super::composite_constraints::SystemPrompt {
                template: r#"You are GigaThink, an expansive creative thinking engine powered by MiniMax M2.

Your task is to generate 10+ diverse perspectives on the given question or topic.

CONSTRAINTS:
- Generate exactly 10+ distinct perspectives
- Each perspective must be novel and substantial
- Use different analytical frameworks
- Provide supporting evidence or reasoning for each
- Maintain minimum confidence of 0.7 per perspective
- Total thinking time must not exceed 5 seconds
- Output must be in structured JSON format

PERSPECTIVE DIMENSIONS TO EXPLORE:
1. Economic/Financial
2. Technological/Innovation
3. Social/Cultural
4. Environmental/Sustainability
5. Political/Regulatory
6. Psychological/Behavioral
7. Ethical/Moral
8. Historical/Evolutionary
9. Competitive/Market
10. User Experience/Adoption
11. Risk/Opportunity
12. Long-term/Strategic

Question: {{query}}"#.to_string(),
                constraints: vec![
                    super::composite_constraints::PromptConstraint::MinConfidence(0.7),
                    super::composite_constraints::PromptConstraint::RequiredKeywords(vec!["perspective".to_string(), "analysis".to_string()]),
                    super::composite_constraints::PromptConstraint::ForbiddenKeywords(vec!["inconclusive".to_string(), "unclear".to_string()]),
                ],
                variables: {
                    let mut vars = std::collections::HashMap::new();
                    vars.insert("query".to_string(), "{{query}}".to_string());
                    vars
                },
                token_limit: Some(2000),
            }),
            CompositeInstruction::UserQuery(super::composite_constraints::UserQuery {
                raw_text: "{{query}}".to_string(),
                sanitized_text: "{{query}}".to_string(),
                intent: super::composite_constraints::QueryIntent::Creative,
                complexity_score: 0.6,
                required_tools: vec!["gigathink".to_string(), "cross_validation".to_string()],
            }),
            CompositeInstruction::MemoryContext(super::composite_constraints::MemoryContext {
                context_id: "gigathink_session".to_string(),
                content: "Creative thinking session context".to_string(),
                relevance_score: 0.8,
                retention_policy: super::composite_constraints::RetentionPolicy::Session,
                dependencies: vec![],
            }),
            CompositeInstruction::ToolSchema(super::composite_constraints::ToolSchema {
                tool_name: "gigathink".to_string(),
                input_schema: super::composite_constraints::SchemaDefinition {
                    format: super::composite_constraints::SchemaFormat::JSON,
                    fields: vec![
                        super::composite_constraints::SchemaField {
                            name: "query".to_string(),
                            field_type: super::composite_constraints::FieldType::String,
                            required: true,
                            constraints: vec![
                                super::composite_constraints::FieldConstraint::MinLength(10),
                                super::composite_constraints::FieldConstraint::MaxLength(1000),
                            ],
                        }
                    ],
                    validation_rules: vec![],
                },
                output_schema: super::composite_constraints::SchemaDefinition {
                    format: super::composite_constraints::SchemaFormat::JSON,
                    fields: vec![
                        super::composite_constraints::SchemaField {
                            name: "perspectives".to_string(),
                            field_type: super::composite_constraints::FieldType::Array(Box::new(super::composite_constraints::FieldType::Object)),
                            required: true,
                            constraints: vec![],
                        }
                    ],
                    validation_rules: vec![],
                },
                constraints: vec![],
            }),
        ]
    }

    /// Create M2 Interleaved Thinking Protocol
    fn create_interleaved_protocol(module_id: String) -> InterleavedProtocol {
        use super::interleaved_thinking::{
            CheckType, OptimizationParameters, PatternStep, PatternStepType, PatternType,
            ProtocolOptimization, ThinkingPattern, ValidationCriterion,
        };

        InterleavedProtocol {
            protocol_id: format!("{}_protocol", module_id),
            name: "Enhanced GigaThink Protocol".to_string(),
            version: "2.0.0-minimax".to_string(),
            description: "M2-enhanced expansive creative thinking with interleaved validation"
                .to_string(),
            patterns: vec![ThinkingPattern {
                pattern_id: "gigathink_creative_pattern".to_string(),
                name: "GigaThink Creative Expansion".to_string(),
                description: "Multi-dimensional perspective generation with cross-validation"
                    .to_string(),
                pattern_type: PatternType::Parallel,
                steps: vec![
                    PatternStep {
                        step_id: "dimension_identification".to_string(),
                        step_type: PatternStepType::InputProcessing,
                        description:
                            "Identify key analytical dimensions for perspective generation"
                                .to_string(),
                        prerequisites: vec![],
                        outputs: vec![],
                        validation_criteria: vec![ValidationCriterion {
                            criterion_id: "min_dimensions".to_string(),
                            check_type: CheckType::MinimumLength,
                            threshold: 10.0,
                            description: "Must identify at least 10 distinct dimensions"
                                .to_string(),
                        }],
                    },
                    PatternStep {
                        step_id: "perspective_generation".to_string(),
                        step_type: PatternStepType::Reasoning,
                        description: "Generate diverse perspectives using identified dimensions"
                            .to_string(),
                        prerequisites: vec!["dimension_identification".to_string()],
                        outputs: vec![],
                        validation_criteria: vec![
                            ValidationCriterion {
                                criterion_id: "perspective_count".to_string(),
                                check_type: CheckType::MinimumLength,
                                threshold: 10.0,
                                description: "Must generate at least 10 perspectives".to_string(),
                            },
                            ValidationCriterion {
                                criterion_id: "confidence_threshold".to_string(),
                                check_type: CheckType::ConfidenceThreshold,
                                threshold: 0.7,
                                description: "Each perspective must have minimum 0.7 confidence"
                                    .to_string(),
                            },
                        ],
                    },
                    PatternStep {
                        step_id: "cross_validation".to_string(),
                        step_type: PatternStepType::Validation,
                        description: "Cross-validate perspectives for coherence and coverage"
                            .to_string(),
                        prerequisites: vec!["perspective_generation".to_string()],
                        outputs: vec![],
                        validation_criteria: vec![ValidationCriterion {
                            criterion_id: "coherence_check".to_string(),
                            check_type: CheckType::LogicalConsistency,
                            threshold: 0.8,
                            description: "Perspectives must be logically coherent".to_string(),
                        }],
                    },
                    PatternStep {
                        step_id: "synthesis".to_string(),
                        step_type: PatternStepType::Synthesis,
                        description: "Synthesize perspectives into key themes and insights"
                            .to_string(),
                        prerequisites: vec!["cross_validation".to_string()],
                        outputs: vec![],
                        validation_criteria: vec![ValidationCriterion {
                            criterion_id: "synthesis_quality".to_string(),
                            check_type: CheckType::Completeness,
                            threshold: 0.8,
                            description: "Synthesis must be complete and actionable".to_string(),
                        }],
                    },
                ],
                validation_rules: vec![],
                optimization_params: OptimizationParameters {
                    max_iterations: Some(3),
                    confidence_threshold: 0.75,
                    time_limit_ms: Some(5000),
                    token_limit: Some(2500),
                    parallelization_level: 3,
                },
            }],
            default_pattern: "gigathink_creative_pattern".to_string(),
            optimization_config: ProtocolOptimization {
                auto_validation: true,
                cross_validation_enabled: true,
                parallel_processing: true,
                adaptive_patterns: false,
                performance_target: 0.92,
                cost_optimization: true,
            },
        }
    }

    /// Execute GigaThink with M2 methodology
    async fn execute_m2_methodology(
        &self,
        query: &str,
        profile: ProfileType,
    ) -> Result<M2ThinkToolResult> {
        let start_time = Instant::now();

        // Create constraint validation inputs
        use super::composite_constraints::ValidationInputs;

        let system_prompt = self
            .composite_constraints
            .iter()
            .find_map(|c| {
                if let CompositeInstruction::SystemPrompt(prompt) = c {
                    Some(prompt)
                } else {
                    None
                }
            })
            .unwrap();

        let user_query = self
            .composite_constraints
            .iter()
            .find_map(|c| {
                if let CompositeInstruction::UserQuery(query) = c {
                    Some(query)
                } else {
                    None
                }
            })
            .unwrap();

        let memory_context = self
            .composite_constraints
            .iter()
            .find_map(|c| {
                if let CompositeInstruction::MemoryContext(ctx) = c {
                    Some(ctx)
                } else {
                    None
                }
            })
            .unwrap();

        let tool_schema = self
            .composite_constraints
            .iter()
            .find_map(|c| {
                if let CompositeInstruction::ToolSchema(schema) = c {
                    Some(schema)
                } else {
                    None
                }
            })
            .unwrap();

        let validation_inputs = ValidationInputs::new()
            .with_system_prompt(system_prompt)
            .with_user_query(user_query)
            .with_memory_context(memory_context)
            .add_tool_schema("gigathink", tool_schema);

        // Validate constraints
        let constraint_engine = super::composite_constraints::ConstraintEngine::new();
        let constraint_result = constraint_engine.validate_all(&validation_inputs);

        // Create base output structure
        let mut base_output = serde_json::json!({
            "dimensions": [],
            "perspectives": [],
            "themes": [],
            "insights": [],
            "synthesis": {},
            "metadata": {
                "execution_profile": format!("{:?}", profile),
                "m2_enhanced": true,
                "protocol_version": self.version
            }
        });

        // Execute interleaved thinking pattern
        use super::interleaved_thinking::MultiStepReasoning;

        let pattern = &self.interleaved_protocol.patterns[0];
        let mut reasoning_engine = MultiStepReasoning::new(pattern.clone());

        let interleaved_result = reasoning_engine.execute(query).await?;

        // Populate output from reasoning results
        if let Some(serde_json::Value::Array(perspectives)) = base_output.get_mut("perspectives") {
            for step in &interleaved_result.steps_completed {
                if step.step_id == "perspective_generation" {
                    for node in &step.reasoning_chain {
                        perspectives.push(serde_json::json!({
                            "id": node.node_id,
                            "content": node.content,
                            "reasoning_type": format!("{:?}", node.reasoning_type),
                            "confidence": node.confidence,
                            "supporting_evidence": node.supporting_evidence.len(),
                            "cross_validated": step.cross_validation_passed
                        }));
                    }
                }
            }
        }

        // Calculate processing metrics
        let processing_time = start_time.elapsed().as_millis() as u64;
        let token_count = (processing_time / 10) as u32; // Rough estimate

        // Create M2 result
        let mut result = M2ThinkToolResult::new(self.module_id.clone(), base_output);
        result.constraint_adherence = constraint_result;
        result.interleaved_steps = interleaved_result.steps_completed;
        result.processing_time_ms = processing_time;
        result.token_count = token_count;

        // Apply profile-specific optimizations
        result.confidence = self.calculate_profile_confidence(&result, profile);

        Ok(result)
    }

    /// Calculate confidence based on execution profile
    fn calculate_profile_confidence(
        &self,
        result: &M2ThinkToolResult,
        profile: ProfileType,
    ) -> f64 {
        let base_confidence = match profile {
            ProfileType::Quick => 0.70,
            ProfileType::Balanced => 0.80,
            ProfileType::Deep => 0.85,
            ProfileType::Paranoid => 0.95,
        };

        // Adjust based on constraint adherence
        let constraint_bonus = match &result.constraint_adherence {
            ConstraintResult::Passed(score) => score * 0.1,
            ConstraintResult::Failed(_) => -0.2,
            ConstraintResult::Pending => 0.0,
        };

        // Adjust based on cross-validation
        let validation_bonus = if result
            .interleaved_steps
            .iter()
            .any(|step| step.cross_validation_passed)
        {
            0.1
        } else {
            0.0
        };

        (base_confidence + constraint_bonus + validation_bonus).clamp(0.0, 1.0)
    }
}

impl M2ThinkTool for EnhancedGigaThink {
    fn execute_with_m2(&self, input: &str, profile: ProfileType) -> Result<M2ThinkToolResult> {
        if tokio::runtime::Handle::try_current().is_ok() {
            return Err(crate::error::Error::M2ExecutionError(
                "execute_with_m2 cannot be called from within a Tokio runtime".to_string(),
            ));
        }

        let rt = tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()?;
        rt.block_on(self.execute_m2_methodology(input, profile))
    }

    fn get_composite_constraints(&self) -> Vec<CompositeInstruction> {
        self.composite_constraints.clone()
    }

    fn get_interleaved_pattern(&self) -> InterleavedProtocol {
        self.interleaved_protocol.clone()
    }

    fn get_performance_target(&self) -> super::performance_monitor::PerformanceMetrics {
        super::performance_monitor::PerformanceMetrics {
            target_confidence: 0.92,
            max_processing_time_ms: 5000,
            max_token_count: 2500,
            target_cost_efficiency: 1.08, // 8% cost reduction
            target_cross_validation_score: 0.85,
            ..Default::default()
        }
    }
}

/// Async execution wrapper for Enhanced GigaThink
pub async fn execute_enhanced_gigathink(
    query: &str,
    profile: ProfileType,
) -> Result<M2ThinkToolResult> {
    let thinktool = EnhancedGigaThink::new();
    execute_profile_based_thinktool(&thinktool, query, profile).await
}

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

    #[test]
    fn test_enhanced_gigathink_creation() {
        let gigathink = EnhancedGigaThink::new();
        assert_eq!(gigathink.module_id, "enhanced_gigathink");
        assert_eq!(gigathink.version, "2.0.0-minimax");
        assert_eq!(gigathink.composite_constraints.len(), 4);
        assert_eq!(gigathink.interleaved_protocol.patterns.len(), 1);
    }

    #[test]
    fn test_composite_constraints_structure() {
        let constraints = EnhancedGigaThink::create_composite_constraints();

        // Check system prompt constraint
        if let Some(CompositeInstruction::SystemPrompt(prompt)) = constraints.first() {
            assert!(prompt.template.contains("GigaThink"));
            assert!(prompt.token_limit.is_some());
        }

        // Check user query constraint
        if let Some(CompositeInstruction::UserQuery(query)) = constraints.get(1) {
            assert_eq!(
                query.intent,
                crate::thinktool::minimax::composite_constraints::QueryIntent::Creative
            );
            assert!(query.required_tools.contains(&"gigathink".to_string()));
        }
    }

    #[tokio::test]
    async fn test_execution_with_quick_profile() {
        let gigathink = EnhancedGigaThink::new();
        let result = gigathink.execute_with_m2(
            "What are the key factors for startup success?",
            ProfileType::Quick,
        );

        match result {
            Ok(result) => {
                assert_eq!(result.module, "enhanced_gigathink");
                assert!(result.confidence >= 0.7); // Quick profile minimum
                assert!(result.processing_time_ms > 0);
            }
            Err(e) => {
                // Expected to fail in test environment without LLM
                println!("Expected error in test: {:?}", e);
            }
        }
    }
}