reasonkit-core 0.1.8

//! GigaThink Module - Expansive Creative Thinking
//!
//! Generates 10+ diverse perspectives through divergent thinking.
//! This module implements structured multi-dimensional analysis
//! to explore problems from multiple angles.
//!
//! ## Features
//!
//! - **10+ Perspectives**: Guaranteed minimum of 10 distinct analytical perspectives
//! - **Dimensional Analysis**: Systematic exploration across 12 analytical dimensions
//! - **Confidence Scoring**: Evidence-based confidence calculation
//! - **Async Execution**: Full async/await support for LLM integration
//! - **Cross-Validation**: Built-in perspective coherence validation
//!
//! ## Usage
//!
//! ```rust,ignore
//! use reasonkit::thinktool::modules::{GigaThink, ThinkToolModule, ThinkToolContext};
//!
//! let module = GigaThink::new();
//! let context = ThinkToolContext {
//!     query: "What are the key factors for startup success?".to_string(),
//!     previous_steps: vec![],
//! };
//!
//! // Sync execution
//! let result = module.execute(&context)?;
//!
//! // Async execution
//! let async_result = module.execute_async(&context).await?;
//! ```
//!
//! ## Note
//!
//! For protocol-based execution (with LLM calls), use the `ProtocolExecutor`:
//!
//! ```rust,ignore
//! let executor = ProtocolExecutor::new()?;
//! let result = executor.execute("gigathink", ProtocolInput::query("question")).await?;
//! ```

use std::future::Future;
use std::pin::Pin;

use serde::{Deserialize, Serialize};
use serde_json::json;
use thiserror::Error;

use super::{ThinkToolContext, ThinkToolModule, ThinkToolModuleConfig, ThinkToolOutput};
use crate::error::{Error, Result};
use rayon::prelude::*;

// ============================================================================
// ERROR TYPES
// ============================================================================

/// Errors specific to GigaThink module execution
#[derive(Error, Debug, Clone)]
pub enum GigaThinkError {
    /// Insufficient perspectives generated
    #[error("Insufficient perspectives: generated {generated}, required minimum {required}")]
    InsufficientPerspectives { generated: usize, required: usize },

    /// Invalid dimension specified
    #[error("Invalid analysis dimension: {dimension}")]
    InvalidDimension { dimension: String },

    /// Query too short for meaningful analysis
    #[error("Query too short: {length} characters, minimum required is {minimum}")]
    QueryTooShort { length: usize, minimum: usize },

    /// Query too long for processing
    #[error("Query too long: {length} characters, maximum allowed is {maximum}")]
    QueryTooLong { length: usize, maximum: usize },

    /// Confidence below acceptable threshold
    #[error("Confidence too low: {confidence:.2}, minimum required is {threshold:.2}")]
    LowConfidence { confidence: f64, threshold: f64 },

    /// Cross-validation failed
    #[error("Cross-validation failed: {reason}")]
    CrossValidationFailed { reason: String },

    /// Synthesis failed
    #[error("Failed to synthesize perspectives: {reason}")]
    SynthesisFailed { reason: String },

    /// Timeout during execution
    #[error("Execution timeout after {duration_ms}ms")]
    ExecutionTimeout { duration_ms: u64 },
}

impl From<GigaThinkError> for Error {
    fn from(err: GigaThinkError) -> Self {
        Error::ThinkToolExecutionError(err.to_string())
    }
}

// ============================================================================
// REASONING MODE (Chain-of-Draft Support)
// ============================================================================

/// Reasoning mode for GigaThink execution
///
/// Chain-of-Draft (CoD) is based on Xu et al. 2025 (arXiv:2502.18600)
/// which achieves 92% token reduction while maintaining accuracy.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ReasoningMode {
    /// Standard Chain-of-Thought reasoning with full verbosity
    #[default]
    Standard,

    /// Chain-of-Draft: Minimalist intermediate outputs (~5 words per step)
    /// Reduces token usage to ~7.6% of CoT while maintaining accuracy.
    /// Uses draft-then-refine approach with `####` answer markers.
    ChainOfDraft,

    /// Hybrid mode: Start with CoD, expand only when confidence < threshold
    Adaptive,
}

impl ReasoningMode {
    /// Returns the system prompt modifier for this reasoning mode
    pub fn system_prompt_modifier(&self) -> &'static str {
        match self {
            Self::Standard => "",
            Self::ChainOfDraft => {
                "Think step by step, but keep each intermediate step to ~5 words maximum. \
                 Focus on essential reasoning only. Mark your final answer with ####."
            }
            Self::Adaptive => {
                "Start with brief (~5 word) reasoning steps. If uncertain, expand that step. \
                 Mark your final answer with ####."
            }
        }
    }

    /// Returns the answer extraction marker
    pub fn answer_marker(&self) -> &'static str {
        match self {
            Self::Standard => "",
            Self::ChainOfDraft | Self::Adaptive => "####",
        }
    }

    /// Returns whether this mode uses token-efficient drafts
    pub fn is_token_efficient(&self) -> bool {
        matches!(self, Self::ChainOfDraft | Self::Adaptive)
    }
}

/// Configuration for Chain-of-Draft mode
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChainOfDraftConfig {
    /// Target word budget per reasoning step (soft limit)
    /// Default: 5 words per step (per Xu et al. 2025)
    pub words_per_step: usize,

    /// Whether to enforce word budget strictly (may reduce quality)
    pub strict_word_budget: bool,

    /// Answer marker for final answer extraction
    pub answer_marker: String,

    /// Whether to include step numbers in drafts
    pub include_step_numbers: bool,

    /// Confidence threshold for adaptive mode expansion
    pub adaptive_expansion_threshold: f64,
}

impl Default for ChainOfDraftConfig {
    fn default() -> Self {
        Self {
            words_per_step: 5,
            strict_word_budget: false,
            answer_marker: "####".to_string(),
            include_step_numbers: true,
            adaptive_expansion_threshold: 0.7,
        }
    }
}

// ============================================================================
// CHAIN-OF-DRAFT UTILITIES
// ============================================================================

/// Utilities for Chain-of-Draft processing
pub struct ChainOfDraftUtils;

impl ChainOfDraftUtils {
    /// Count words in a text string
    pub fn count_words(text: &str) -> usize {
        text.split_whitespace().count()
    }

    /// Check if a draft step exceeds the word budget
    pub fn exceeds_word_budget(step: &str, budget: usize) -> bool {
        Self::count_words(step) > budget
    }

    /// Extract the final answer from CoD output using the marker
    pub fn extract_answer(output: &str, marker: &str) -> Option<String> {
        if marker.is_empty() {
            return None;
        }
        output.split(marker).nth(1).map(|s| s.trim().to_string())
    }

    /// Parse draft steps from CoD output
    pub fn parse_draft_steps(output: &str, marker: &str) -> Vec<String> {
        // Get everything before the answer marker
        let reasoning_part = if marker.is_empty() {
            output
        } else {
            output.split(marker).next().unwrap_or(output)
        };

        // Split by newlines or step markers
        reasoning_part
            .lines()
            .filter(|line| !line.trim().is_empty())
            .map(|line| {
                // Remove step numbers if present (e.g., "1.", "Step 1:", etc.)
                let trimmed = line.trim();
                if let Some(rest) = trimmed.strip_prefix(|c: char| c.is_ascii_digit()) {
                    rest.trim_start_matches(['.', ':', ')']).trim().to_string()
                } else {
                    trimmed.to_string()
                }
            })
            .collect()
    }

    /// Calculate token efficiency ratio (draft tokens / full CoT estimate)
    pub fn estimate_token_efficiency(draft_words: usize, estimated_full_cot_words: usize) -> f64 {
        if estimated_full_cot_words == 0 {
            return 1.0;
        }
        draft_words as f64 / estimated_full_cot_words as f64
    }

    /// Generate a CoD-style prompt for a given query
    pub fn generate_cod_prompt(query: &str, words_per_step: usize) -> String {
        format!(
            "Question: {}\n\n\
             Instructions: Think step by step to solve this problem. \
             Keep each reasoning step to approximately {} words. \
             Focus on the essential logic only. \
             After your reasoning, write #### followed by your final answer.\n\n\
             Reasoning:",
            query, words_per_step
        )
    }

    /// Generate a dimension-specific CoD prompt for GigaThink
    pub fn generate_dimension_cod_prompt(
        query: &str,
        dimension: &str,
        guiding_question: &str,
        words_per_step: usize,
    ) -> String {
        format!(
            "Analyze from {} perspective: {}\n\
             Guiding question: {}\n\n\
             Instructions: Provide brief insights (~{} words per point). \
             Mark final insight with ####.\n\n\
             Analysis:",
            dimension, query, guiding_question, words_per_step
        )
    }
}

/// Metrics for Chain-of-Draft execution
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ChainOfDraftMetrics {
    /// Total words in reasoning steps
    pub total_reasoning_words: usize,

    /// Number of reasoning steps
    pub step_count: usize,

    /// Average words per step
    pub avg_words_per_step: f64,

    /// Estimated token efficiency (vs full CoT)
    pub token_efficiency_ratio: f64,

    /// Number of steps that exceeded word budget
    pub steps_over_budget: usize,

    /// Whether adaptive expansion was triggered
    pub adaptive_expansion_used: bool,
}

impl ChainOfDraftMetrics {
    /// Create metrics from draft output
    pub fn from_draft(output: &str, marker: &str, word_budget: usize) -> Self {
        let steps = ChainOfDraftUtils::parse_draft_steps(output, marker);
        let step_count = steps.len();
        let total_words: usize = steps
            .iter()
            .map(|s| ChainOfDraftUtils::count_words(s))
            .sum();
        let steps_over: usize = steps
            .iter()
            .filter(|s| ChainOfDraftUtils::exceeds_word_budget(s, word_budget))
            .count();

        // Estimate full CoT would use ~50 words per step on average
        let estimated_full_cot = step_count * 50;

        Self {
            total_reasoning_words: total_words,
            step_count,
            avg_words_per_step: if step_count > 0 {
                total_words as f64 / step_count as f64
            } else {
                0.0
            },
            token_efficiency_ratio: ChainOfDraftUtils::estimate_token_efficiency(
                total_words,
                estimated_full_cot,
            ),
            steps_over_budget: steps_over,
            adaptive_expansion_used: false,
        }
    }
}

// ============================================================================
// CONFIGURATION
// ============================================================================

/// Configuration for GigaThink module behavior
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigaThinkConfig {
    /// Reasoning mode: Standard, ChainOfDraft, or Adaptive
    pub reasoning_mode: ReasoningMode,

    /// Chain-of-Draft specific configuration
    pub cod_config: ChainOfDraftConfig,
    /// Minimum number of perspectives to generate
    pub min_perspectives: usize,

    /// Maximum number of perspectives to generate
    pub max_perspectives: usize,

    /// Minimum confidence threshold for output
    pub min_confidence: f64,

    /// Enable cross-validation of perspectives
    pub enable_cross_validation: bool,

    /// Minimum query length in characters
    pub min_query_length: usize,

    /// Maximum query length in characters
    pub max_query_length: usize,

    /// Dimensions to explore (if empty, use all default dimensions)
    pub dimensions: Vec<AnalysisDimension>,

    /// Weight applied to novelty in confidence calculation
    pub novelty_weight: f64,

    /// Weight applied to depth in confidence calculation
    pub depth_weight: f64,

    /// Weight applied to coherence in confidence calculation
    pub coherence_weight: f64,

    /// Maximum execution time in milliseconds
    pub max_execution_time_ms: Option<u64>,
}

impl Default for GigaThinkConfig {
    fn default() -> Self {
        Self {
            reasoning_mode: ReasoningMode::default(),
            cod_config: ChainOfDraftConfig::default(),
            min_perspectives: 10,
            max_perspectives: 15,
            min_confidence: 0.70,
            enable_cross_validation: true,
            min_query_length: 10,
            max_query_length: 5000,
            dimensions: Vec::new(), // Use all default dimensions
            novelty_weight: 0.30,
            depth_weight: 0.40,
            coherence_weight: 0.30,
            max_execution_time_ms: Some(10000),
        }
    }
}

impl GigaThinkConfig {
    /// Create a configuration for Chain-of-Draft mode (92% token reduction)
    pub fn chain_of_draft() -> Self {
        Self {
            reasoning_mode: ReasoningMode::ChainOfDraft,
            cod_config: ChainOfDraftConfig::default(),
            // Reduce perspectives for CoD mode to maximize efficiency
            min_perspectives: 5,
            max_perspectives: 8,
            // Slightly lower confidence threshold (CoD is more focused)
            min_confidence: 0.65,
            ..Self::default()
        }
    }

    /// Create a configuration for Adaptive mode (CoD with expansion when needed)
    pub fn adaptive() -> Self {
        Self {
            reasoning_mode: ReasoningMode::Adaptive,
            cod_config: ChainOfDraftConfig {
                adaptive_expansion_threshold: 0.7,
                ..ChainOfDraftConfig::default()
            },
            min_perspectives: 7,
            max_perspectives: 12,
            min_confidence: 0.70,
            ..Self::default()
        }
    }

    /// Set the reasoning mode
    pub fn with_reasoning_mode(mut self, mode: ReasoningMode) -> Self {
        self.reasoning_mode = mode;
        self
    }

    /// Set the words-per-step budget for Chain-of-Draft
    pub fn with_words_per_step(mut self, words: usize) -> Self {
        self.cod_config.words_per_step = words;
        self
    }
}

// ============================================================================
// ANALYSIS DIMENSIONS
// ============================================================================

/// Analytical dimensions for perspective generation
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AnalysisDimension {
    /// Economic and financial implications
    Economic,
    /// Technological and innovation aspects
    Technological,
    /// Social and cultural considerations
    Social,
    /// Environmental and sustainability factors
    Environmental,
    /// Political and regulatory landscape
    Political,
    /// Psychological and behavioral patterns
    Psychological,
    /// Ethical and moral implications
    Ethical,
    /// Historical context and evolution
    Historical,
    /// Competitive and market dynamics
    Competitive,
    /// User experience and adoption
    UserExperience,
    /// Risk assessment and opportunities
    RiskOpportunity,
    /// Long-term and strategic outlook
    Strategic,
}

impl AnalysisDimension {
    /// Returns all available dimensions
    pub fn all() -> Vec<Self> {
        vec![
            Self::Economic,
            Self::Technological,
            Self::Social,
            Self::Environmental,
            Self::Political,
            Self::Psychological,
            Self::Ethical,
            Self::Historical,
            Self::Competitive,
            Self::UserExperience,
            Self::RiskOpportunity,
            Self::Strategic,
        ]
    }

    /// Returns the display name for this dimension
    pub fn display_name(&self) -> &'static str {
        match self {
            Self::Economic => "Economic/Financial",
            Self::Technological => "Technological/Innovation",
            Self::Social => "Social/Cultural",
            Self::Environmental => "Environmental/Sustainability",
            Self::Political => "Political/Regulatory",
            Self::Psychological => "Psychological/Behavioral",
            Self::Ethical => "Ethical/Moral",
            Self::Historical => "Historical/Evolutionary",
            Self::Competitive => "Competitive/Market",
            Self::UserExperience => "User Experience/Adoption",
            Self::RiskOpportunity => "Risk/Opportunity",
            Self::Strategic => "Long-term/Strategic",
        }
    }

    /// Returns guiding questions for this dimension
    pub fn guiding_questions(&self) -> Vec<&'static str> {
        match self {
            Self::Economic => vec![
                "What are the financial implications?",
                "How does this affect costs and revenues?",
                "What economic forces are at play?",
            ],
            Self::Technological => vec![
                "What technologies enable or constrain this?",
                "How might technology evolve to change this?",
                "What innovation opportunities exist?",
            ],
            Self::Social => vec![
                "How does society perceive this?",
                "What cultural factors influence adoption?",
                "Who are the key stakeholders affected?",
            ],
            Self::Environmental => vec![
                "What is the environmental impact?",
                "How sustainable is this approach?",
                "What ecological factors are relevant?",
            ],
            Self::Political => vec![
                "What regulations apply or might apply?",
                "How do political dynamics affect this?",
                "What policy changes could impact this?",
            ],
            Self::Psychological => vec![
                "What cognitive biases might be at play?",
                "How do people emotionally respond?",
                "What behavioral patterns are relevant?",
            ],
            Self::Ethical => vec![
                "What are the moral implications?",
                "Who might be harmed or helped?",
                "What ethical principles apply?",
            ],
            Self::Historical => vec![
                "What historical precedents exist?",
                "How has this evolved over time?",
                "What can we learn from the past?",
            ],
            Self::Competitive => vec![
                "Who are the competitors?",
                "What are the market dynamics?",
                "How do switching costs affect this?",
            ],
            Self::UserExperience => vec![
                "How does this affect the user?",
                "What friction points exist?",
                "How can adoption be improved?",
            ],
            Self::RiskOpportunity => vec![
                "What are the key risks?",
                "What opportunities might emerge?",
                "How can risks be mitigated?",
            ],
            Self::Strategic => vec![
                "What is the long-term impact?",
                "How does this fit into larger goals?",
                "What strategic options exist?",
            ],
        }
    }

    /// Returns a prompt template for LLM analysis of this dimension
    pub fn prompt_template(&self) -> &'static str {
        match self {
            Self::Economic => {
                "Analyze the economic and financial aspects. Consider costs, benefits, \
                 market forces, pricing dynamics, and value creation potential."
            }
            Self::Technological => {
                "Examine the technological dimensions. Consider enabling technologies, \
                 technical constraints, innovation potential, and technical debt."
            }
            Self::Social => {
                "Explore the social and cultural factors. Consider stakeholder interests, \
                 social norms, cultural adoption barriers, and community impact."
            }
            Self::Environmental => {
                "Assess environmental implications. Consider sustainability, ecological \
                 footprint, resource consumption, and environmental regulations."
            }
            Self::Political => {
                "Analyze the political and regulatory landscape. Consider current \
                 regulations, potential policy changes, and political stakeholders."
            }
            Self::Psychological => {
                "Examine psychological and behavioral factors. Consider cognitive biases, \
                 emotional responses, habit formation, and decision-making patterns."
            }
            Self::Ethical => {
                "Evaluate ethical and moral dimensions. Consider fairness, transparency, \
                 potential harms, beneficiaries, and alignment with ethical principles."
            }
            Self::Historical => {
                "Review historical context and precedents. Consider how similar situations \
                 evolved, lessons learned, and historical patterns that might repeat."
            }
            Self::Competitive => {
                "Analyze competitive dynamics. Consider existing competitors, potential \
                 entrants, substitute solutions, and market positioning."
            }
            Self::UserExperience => {
                "Assess user experience and adoption factors. Consider ease of use, \
                 learning curve, friction points, and paths to adoption."
            }
            Self::RiskOpportunity => {
                "Evaluate risks and opportunities. Consider potential downsides, \
                 upside scenarios, mitigation strategies, and contingency plans."
            }
            Self::Strategic => {
                "Examine long-term strategic implications. Consider competitive advantage, \
                 strategic positioning, future optionality, and path dependencies."
            }
        }
    }
}

// ============================================================================
// PERSPECTIVE DATA STRUCTURES
// ============================================================================

/// A single perspective generated by GigaThink
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Perspective {
    /// Unique identifier for this perspective
    pub id: String,

    /// The analytical dimension this perspective explores
    pub dimension: AnalysisDimension,

    /// Title or summary of the perspective
    pub title: String,

    /// Detailed content of the perspective
    pub content: String,

    /// Key insight derived from this perspective
    pub key_insight: String,

    /// Supporting evidence or examples
    pub supporting_evidence: Vec<String>,

    /// Implications or consequences identified
    pub implications: Vec<String>,

    /// Confidence score for this perspective (0.0 - 1.0)
    pub confidence: f64,

    /// Novelty score - how unique is this perspective
    pub novelty_score: f64,

    /// Depth score - how thoroughly is this explored
    pub depth_score: f64,
}

impl Perspective {
    /// Create a new perspective
    pub fn new(
        id: impl Into<String>,
        dimension: AnalysisDimension,
        title: impl Into<String>,
        content: impl Into<String>,
    ) -> Self {
        Self {
            id: id.into(),
            dimension,
            title: title.into(),
            content: content.into(),
            key_insight: String::new(),
            supporting_evidence: Vec::new(),
            implications: Vec::new(),
            confidence: 0.70,
            novelty_score: 0.5,
            depth_score: 0.5,
        }
    }

    /// Builder: set key insight
    pub fn with_key_insight(mut self, insight: impl Into<String>) -> Self {
        self.key_insight = insight.into();
        self
    }

    /// Builder: add supporting evidence
    pub fn with_evidence(mut self, evidence: impl Into<String>) -> Self {
        self.supporting_evidence.push(evidence.into());
        self
    }

    /// Builder: add implication
    pub fn with_implication(mut self, implication: impl Into<String>) -> Self {
        self.implications.push(implication.into());
        self
    }

    /// Builder: set confidence
    pub fn with_confidence(mut self, confidence: f64) -> Self {
        self.confidence = confidence.clamp(0.0, 1.0);
        self
    }

    /// Builder: set novelty score
    pub fn with_novelty(mut self, novelty: f64) -> Self {
        self.novelty_score = novelty.clamp(0.0, 1.0);
        self
    }

    /// Builder: set depth score
    pub fn with_depth(mut self, depth: f64) -> Self {
        self.depth_score = depth.clamp(0.0, 1.0);
        self
    }

    /// Calculate overall quality score
    pub fn quality_score(&self) -> f64 {
        (self.confidence * 0.4 + self.novelty_score * 0.3 + self.depth_score * 0.3).clamp(0.0, 1.0)
    }
}

/// A theme identified across multiple perspectives
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Theme {
    /// Theme identifier
    pub id: String,

    /// Theme title
    pub title: String,

    /// Theme description
    pub description: String,

    /// IDs of perspectives that contribute to this theme
    pub contributing_perspectives: Vec<String>,

    /// Confidence in theme identification
    pub confidence: f64,
}

/// Synthesized insight from perspective analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SynthesizedInsight {
    /// Insight identifier
    pub id: String,

    /// The synthesized insight content
    pub content: String,

    /// Perspectives that contributed to this insight
    pub source_perspectives: Vec<String>,

    /// Actionability score (how actionable is this insight)
    pub actionability: f64,

    /// Confidence score
    pub confidence: f64,
}

/// Complete GigaThink output
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigaThinkResult {
    /// Query that was analyzed
    pub query: String,

    /// Dimensions that were explored
    pub dimensions_explored: Vec<AnalysisDimension>,

    /// Generated perspectives (10+ guaranteed)
    pub perspectives: Vec<Perspective>,

    /// Identified themes
    pub themes: Vec<Theme>,

    /// Synthesized insights
    pub insights: Vec<SynthesizedInsight>,

    /// Overall confidence score
    pub confidence: f64,

    /// Cross-validation passed
    pub cross_validated: bool,

    /// Execution metadata
    pub metadata: GigaThinkMetadata,
}

/// Execution metadata
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigaThinkMetadata {
    /// Module version
    pub version: String,

    /// Execution duration in milliseconds
    pub duration_ms: u64,

    /// Number of dimensions explored
    pub dimensions_count: usize,

    /// Total perspectives generated
    pub perspectives_count: usize,

    /// Configuration used
    pub config: GigaThinkConfig,
}

// ============================================================================
// ASYNC TRAIT FOR ASYNC EXECUTION
// ============================================================================

/// Trait for async ThinkTool execution
pub trait AsyncThinkToolModule: ThinkToolModule {
    /// Execute the module asynchronously
    fn execute_async<'a>(
        &'a self,
        context: &'a ThinkToolContext,
    ) -> Pin<Box<dyn Future<Output = Result<ThinkToolOutput>> + Send + 'a>>;
}

// ============================================================================
// GIGATHINK MODULE
// ============================================================================

/// GigaThink reasoning module for multi-perspective expansion.
///
/// Generates 10+ diverse viewpoints through systematic exploration
/// of analytical dimensions using creative expansion techniques.
pub struct GigaThink {
    /// Module configuration
    module_config: ThinkToolModuleConfig,

    /// GigaThink-specific configuration
    config: GigaThinkConfig,
}

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

impl GigaThink {
    /// Create a new GigaThink module instance with default configuration.
    pub fn new() -> Self {
        Self::with_config(GigaThinkConfig::default())
    }

    /// Create a GigaThink module with custom configuration.
    pub fn with_config(config: GigaThinkConfig) -> Self {
        Self {
            module_config: ThinkToolModuleConfig {
                name: "GigaThink".to_string(),
                version: "2.1.0".to_string(),
                description: "Expansive creative thinking with 10+ diverse perspectives"
                    .to_string(),
                confidence_weight: 0.15,
            },
            config,
        }
    }

    /// Get the current configuration
    pub fn config(&self) -> &GigaThinkConfig {
        &self.config
    }

    /// Validate the input query
    fn validate_query(&self, query: &str) -> Result<()> {
        let length = query.len();

        if length < self.config.min_query_length {
            return Err(GigaThinkError::QueryTooShort {
                length,
                minimum: self.config.min_query_length,
            }
            .into());
        }

        if length > self.config.max_query_length {
            return Err(GigaThinkError::QueryTooLong {
                length,
                maximum: self.config.max_query_length,
            }
            .into());
        }

        Ok(())
    }

    /// Get dimensions to analyze
    fn get_dimensions(&self) -> Vec<AnalysisDimension> {
        if self.config.dimensions.is_empty() {
            AnalysisDimension::all()
        } else {
            self.config.dimensions.clone()
        }
    }

    /// Generate perspectives for all dimensions
    fn generate_perspectives(
        &self,
        query: &str,
        dimensions: &[AnalysisDimension],
    ) -> Vec<Perspective> {
        dimensions
            .par_iter()
            .enumerate()
            .map(|(idx, dim)| self.generate_perspective_for_dimension(query, *dim, idx))
            .collect()
    }

    /// Generate a perspective for a specific dimension
    fn generate_perspective_for_dimension(
        &self,
        query: &str,
        dimension: AnalysisDimension,
        index: usize,
    ) -> Perspective {
        let id = format!("perspective_{}", index + 1);
        let title = format!("{} Analysis", dimension.display_name());

        // Generate content based on dimension and query
        let content = self.generate_dimension_content(query, dimension);
        let key_insight = self.extract_key_insight(query, dimension);

        // Calculate scores based on dimension and query characteristics
        let novelty_score = self.calculate_novelty_score(query, dimension);
        let depth_score = self.calculate_depth_score(query, dimension);
        let confidence = self.calculate_perspective_confidence(novelty_score, depth_score);

        let mut perspective = Perspective::new(id, dimension, title, content)
            .with_key_insight(key_insight)
            .with_confidence(confidence)
            .with_novelty(novelty_score)
            .with_depth(depth_score);

        // Add supporting evidence
        for evidence in self.generate_evidence(query, dimension) {
            perspective = perspective.with_evidence(evidence);
        }

        // Add implications
        for implication in self.generate_implications(query, dimension) {
            perspective = perspective.with_implication(implication);
        }

        perspective
    }

    /// Generate content for a dimension (placeholder for LLM integration)
    fn generate_dimension_content(&self, query: &str, dimension: AnalysisDimension) -> String {
        format!(
            "From the {} perspective, analyzing \"{}\":\n\n{}\n\nThis dimension reveals \
             important considerations that may not be immediately apparent in other analyses.",
            dimension.display_name(),
            query,
            dimension.prompt_template()
        )
    }

    /// Extract key insight for a dimension
    fn extract_key_insight(&self, _query: &str, dimension: AnalysisDimension) -> String {
        format!(
            "The {} lens reveals unique factors that warrant deeper exploration.",
            dimension.display_name()
        )
    }

    /// Generate supporting evidence for a dimension
    fn generate_evidence(&self, _query: &str, dimension: AnalysisDimension) -> Vec<String> {
        dimension
            .guiding_questions()
            .iter()
            .map(|q| format!("Addressed: {}", q))
            .collect()
    }

    /// Generate implications for a dimension
    fn generate_implications(&self, _query: &str, dimension: AnalysisDimension) -> Vec<String> {
        vec![format!(
            "The {} dimension has significant implications for decision-making.",
            dimension.display_name()
        )]
    }

    /// Calculate novelty score based on query and dimension
    fn calculate_novelty_score(&self, _query: &str, _dimension: AnalysisDimension) -> f64 {
        // Base novelty score - in real implementation, this would analyze
        // how unique this perspective is compared to common analyses
        0.75
    }

    /// Calculate depth score based on query and dimension
    fn calculate_depth_score(&self, _query: &str, _dimension: AnalysisDimension) -> f64 {
        // Base depth score - in real implementation, this would analyze
        // how thoroughly the dimension is explored
        0.72
    }

    /// Calculate perspective confidence from novelty and depth
    fn calculate_perspective_confidence(&self, novelty: f64, depth: f64) -> f64 {
        (novelty * self.config.novelty_weight
            + depth * self.config.depth_weight
            + 0.80 * self.config.coherence_weight)
            .clamp(0.0, 1.0)
    }

    /// Identify themes across perspectives
    fn identify_themes(&self, perspectives: &[Perspective]) -> Vec<Theme> {
        // Group perspectives by related concepts
        // In real implementation, this would use semantic clustering

        let mut themes = Vec::new();

        // Create cross-cutting themes
        if perspectives.len() >= 3 {
            themes.push(Theme {
                id: "theme_1".to_string(),
                title: "Cross-Dimensional Patterns".to_string(),
                description: "Patterns that emerge across multiple analytical dimensions."
                    .to_string(),
                contributing_perspectives: perspectives
                    .iter()
                    .take(4)
                    .map(|p| p.id.clone())
                    .collect(),
                confidence: 0.78,
            });
        }

        if perspectives.len() >= 6 {
            themes.push(Theme {
                id: "theme_2".to_string(),
                title: "Stakeholder Impact".to_string(),
                description: "How different stakeholders are affected across dimensions."
                    .to_string(),
                contributing_perspectives: perspectives
                    .iter()
                    .filter(|p| {
                        matches!(
                            p.dimension,
                            AnalysisDimension::Social
                                | AnalysisDimension::UserExperience
                                | AnalysisDimension::Ethical
                        )
                    })
                    .map(|p| p.id.clone())
                    .collect(),
                confidence: 0.82,
            });
        }

        themes
    }

    /// Synthesize insights from perspectives and themes
    fn synthesize_insights(
        &self,
        perspectives: &[Perspective],
        themes: &[Theme],
    ) -> Vec<SynthesizedInsight> {
        let mut insights = Vec::new();

        // Generate insights from high-confidence perspectives
        let high_conf_perspectives: Vec<_> = perspectives
            .iter()
            .filter(|p| p.confidence > 0.75)
            .collect();

        if !high_conf_perspectives.is_empty() {
            insights.push(SynthesizedInsight {
                id: "insight_1".to_string(),
                content: format!(
                    "High-confidence analysis from {} perspectives suggests actionable opportunities.",
                    high_conf_perspectives.len()
                ),
                source_perspectives: high_conf_perspectives.iter().map(|p| p.id.clone()).collect(),
                actionability: 0.80,
                confidence: 0.85,
            });
        }

        // Generate insights from themes
        for (idx, theme) in themes.iter().enumerate() {
            insights.push(SynthesizedInsight {
                id: format!("insight_{}", idx + 2),
                content: format!(
                    "Theme '{}' integrates insights from {} perspectives.",
                    theme.title,
                    theme.contributing_perspectives.len()
                ),
                source_perspectives: theme.contributing_perspectives.clone(),
                actionability: 0.70,
                confidence: theme.confidence,
            });
        }

        insights
    }

    /// Cross-validate perspectives for coherence
    fn cross_validate(&self, perspectives: &[Perspective]) -> Result<bool> {
        if !self.config.enable_cross_validation {
            return Ok(true);
        }

        // Check minimum perspective count
        if perspectives.len() < self.config.min_perspectives {
            return Err(GigaThinkError::InsufficientPerspectives {
                generated: perspectives.len(),
                required: self.config.min_perspectives,
            }
            .into());
        }

        // Check that all perspectives meet minimum confidence
        for perspective in perspectives {
            if perspective.confidence < self.config.min_confidence {
                return Err(GigaThinkError::LowConfidence {
                    confidence: perspective.confidence,
                    threshold: self.config.min_confidence,
                }
                .into());
            }
        }

        // Check for logical consistency (simplified)
        let avg_confidence =
            perspectives.iter().map(|p| p.confidence).sum::<f64>() / perspectives.len() as f64;

        if avg_confidence < self.config.min_confidence {
            return Err(GigaThinkError::CrossValidationFailed {
                reason: format!(
                    "Average confidence {:.2} below threshold {:.2}",
                    avg_confidence, self.config.min_confidence
                ),
            }
            .into());
        }

        Ok(true)
    }

    /// Calculate overall confidence from perspectives
    fn calculate_overall_confidence(&self, perspectives: &[Perspective]) -> f64 {
        if perspectives.is_empty() {
            return 0.0;
        }

        // Weight by quality score
        let total_quality: f64 = perspectives.iter().map(|p| p.quality_score()).sum();
        let avg_quality = total_quality / perspectives.len() as f64;

        // Factor in diversity (more dimensions = higher confidence)
        let unique_dimensions: std::collections::HashSet<_> =
            perspectives.iter().map(|p| p.dimension).collect();
        let diversity_factor = (unique_dimensions.len() as f64 / 12.0).min(1.0);

        // Combine factors
        (avg_quality * 0.7 + diversity_factor * 0.3).clamp(0.0, 1.0)
    }

    /// Build complete GigaThink result
    fn build_result(
        &self,
        context: &ThinkToolContext,
        duration_ms: u64,
    ) -> Result<GigaThinkResult> {
        let query = &context.query;
        let dimensions = self.get_dimensions();

        let perspectives = self.generate_perspectives(query, &dimensions);
        let cross_validated = self.cross_validate(&perspectives)?;
        let themes = self.identify_themes(&perspectives);
        let insights = self.synthesize_insights(&perspectives, &themes);
        let confidence = self.calculate_overall_confidence(&perspectives);

        Ok(GigaThinkResult {
            query: query.clone(),
            dimensions_explored: dimensions.clone(),
            perspectives,
            themes,
            insights,
            confidence,
            cross_validated,
            metadata: GigaThinkMetadata {
                version: self.module_config.version.clone(),
                duration_ms,
                dimensions_count: dimensions.len(),
                perspectives_count: self.config.min_perspectives,
                config: self.config.clone(),
            },
        })
    }
}

impl ThinkToolModule for GigaThink {
    fn config(&self) -> &ThinkToolModuleConfig {
        &self.module_config
    }

    fn execute(&self, context: &ThinkToolContext) -> Result<ThinkToolOutput> {
        let start = std::time::Instant::now();

        // Validate input
        self.validate_query(&context.query)?;

        // Build result
        let duration_ms = start.elapsed().as_millis() as u64;
        let result = self.build_result(context, duration_ms)?;

        // Convert to ThinkToolOutput
        let output = json!({
            "dimensions": result.dimensions_explored.iter()
                .map(|d| d.display_name())
                .collect::<Vec<_>>(),
            "perspectives": result.perspectives.iter().map(|p| json!({
                "id": p.id,
                "dimension": p.dimension.display_name(),
                "title": p.title,
                "key_insight": p.key_insight,
                "confidence": p.confidence,
                "quality_score": p.quality_score()
            })).collect::<Vec<_>>(),
            "themes": result.themes.iter().map(|t| json!({
                "id": t.id,
                "title": t.title,
                "description": t.description,
                "contributing_count": t.contributing_perspectives.len(),
                "confidence": t.confidence
            })).collect::<Vec<_>>(),
            "insights": result.insights.iter().map(|i| json!({
                "id": i.id,
                "content": i.content,
                "actionability": i.actionability,
                "confidence": i.confidence
            })).collect::<Vec<_>>(),
            "confidence": result.confidence,
            "cross_validated": result.cross_validated,
            "metadata": {
                "version": result.metadata.version,
                "duration_ms": result.metadata.duration_ms,
                "dimensions_count": result.metadata.dimensions_count,
                "perspectives_count": result.metadata.perspectives_count
            }
        });

        Ok(ThinkToolOutput {
            module: self.module_config.name.clone(),
            confidence: result.confidence,
            output,
        })
    }
}

// GigaThink is Send + Sync because all its fields are Send + Sync
// (ThinkToolModuleConfig contains Arc<> which is thread-safe)

impl AsyncThinkToolModule for GigaThink {
    fn execute_async<'a>(
        &'a self,
        context: &'a ThinkToolContext,
    ) -> Pin<Box<dyn Future<Output = Result<ThinkToolOutput>> + Send + 'a>> {
        Box::pin(async move {
            // For now, delegate to sync execution
            // In a real implementation, this would use async LLM calls
            self.execute(context)
        })
    }
}

// ============================================================================
// BUILDER PATTERN
// ============================================================================

/// Builder for GigaThink module with fluent configuration
#[derive(Default)]
pub struct GigaThinkBuilder {
    config: GigaThinkConfig,
}

impl GigaThinkBuilder {
    /// Create a new builder
    pub fn new() -> Self {
        Self::default()
    }

    /// Set minimum perspectives
    pub fn min_perspectives(mut self, count: usize) -> Self {
        self.config.min_perspectives = count;
        self
    }

    /// Set maximum perspectives
    pub fn max_perspectives(mut self, count: usize) -> Self {
        self.config.max_perspectives = count;
        self
    }

    /// Set minimum confidence threshold
    pub fn min_confidence(mut self, confidence: f64) -> Self {
        self.config.min_confidence = confidence.clamp(0.0, 1.0);
        self
    }

    /// Enable or disable cross-validation
    pub fn cross_validation(mut self, enabled: bool) -> Self {
        self.config.enable_cross_validation = enabled;
        self
    }

    /// Set specific dimensions to analyze
    pub fn dimensions(mut self, dimensions: Vec<AnalysisDimension>) -> Self {
        self.config.dimensions = dimensions;
        self
    }

    /// Set novelty weight for confidence calculation
    pub fn novelty_weight(mut self, weight: f64) -> Self {
        self.config.novelty_weight = weight.clamp(0.0, 1.0);
        self
    }

    /// Set depth weight for confidence calculation
    pub fn depth_weight(mut self, weight: f64) -> Self {
        self.config.depth_weight = weight.clamp(0.0, 1.0);
        self
    }

    /// Set coherence weight for confidence calculation
    pub fn coherence_weight(mut self, weight: f64) -> Self {
        self.config.coherence_weight = weight.clamp(0.0, 1.0);
        self
    }

    /// Set maximum execution time
    pub fn max_execution_time_ms(mut self, ms: u64) -> Self {
        self.config.max_execution_time_ms = Some(ms);
        self
    }

    /// Build the GigaThink module
    pub fn build(self) -> GigaThink {
        GigaThink::with_config(self.config)
    }
}

// ============================================================================
// TESTS
// ============================================================================

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

    #[test]
    fn test_gigathink_creation() {
        let module = GigaThink::new();
        // Access the ThinkToolModule trait method via the trait
        use crate::thinktool::ThinkToolModule;
        assert_eq!(ThinkToolModule::config(&module).name, "GigaThink");
        assert_eq!(ThinkToolModule::config(&module).version, "2.1.0");
    }

    #[test]
    fn test_builder_pattern() {
        let module = GigaThinkBuilder::new()
            .min_perspectives(12)
            .max_perspectives(20)
            .min_confidence(0.80)
            .cross_validation(false)
            .build();

        assert_eq!(module.config.min_perspectives, 12);
        assert_eq!(module.config.max_perspectives, 20);
        assert_eq!(module.config.min_confidence, 0.80);
        assert!(!module.config.enable_cross_validation);
    }

    #[test]
    fn test_all_dimensions() {
        let dimensions = AnalysisDimension::all();
        assert_eq!(dimensions.len(), 12);
    }

    #[test]
    fn test_dimension_display_names() {
        assert_eq!(
            AnalysisDimension::Economic.display_name(),
            "Economic/Financial"
        );
        assert_eq!(
            AnalysisDimension::Technological.display_name(),
            "Technological/Innovation"
        );
    }

    #[test]
    fn test_dimension_guiding_questions() {
        let questions = AnalysisDimension::Economic.guiding_questions();
        assert!(!questions.is_empty());
        assert!(questions[0].contains("financial"));
    }

    #[test]
    fn test_perspective_creation() {
        let perspective = Perspective::new(
            "p1",
            AnalysisDimension::Economic,
            "Economic Analysis",
            "Content",
        )
        .with_key_insight("Key insight")
        .with_evidence("Evidence 1")
        .with_implication("Implication 1")
        .with_confidence(0.85)
        .with_novelty(0.75)
        .with_depth(0.80);

        assert_eq!(perspective.id, "p1");
        assert_eq!(perspective.dimension, AnalysisDimension::Economic);
        assert_eq!(perspective.confidence, 0.85);
        assert!(!perspective.supporting_evidence.is_empty());
        assert!(!perspective.implications.is_empty());
    }

    #[test]
    fn test_perspective_quality_score() {
        let perspective = Perspective::new("p1", AnalysisDimension::Economic, "Title", "Content")
            .with_confidence(0.90)
            .with_novelty(0.80)
            .with_depth(0.70);

        let quality = perspective.quality_score();
        // 0.90 * 0.4 + 0.80 * 0.3 + 0.70 * 0.3 = 0.36 + 0.24 + 0.21 = 0.81
        assert!((quality - 0.81).abs() < 0.01);
    }

    #[test]
    fn test_query_validation_too_short() {
        let module = GigaThink::new();
        let result = module.validate_query("short");
        assert!(result.is_err());
    }

    #[test]
    fn test_query_validation_valid() {
        let module = GigaThink::new();
        let result = module.validate_query("This is a valid query for analysis");
        assert!(result.is_ok());
    }

    #[test]
    fn test_execute_generates_perspectives() {
        let module = GigaThink::new();
        let context = ThinkToolContext {
            query: "What are the key factors for startup success?".to_string(),
            previous_steps: vec![],
        };

        let result = module.execute(&context).unwrap();

        assert_eq!(result.module, "GigaThink");
        assert!(result.confidence > 0.0);

        // Check that perspectives were generated
        let perspectives = result
            .output
            .get("perspectives")
            .unwrap()
            .as_array()
            .unwrap();
        assert!(perspectives.len() >= 10);
    }

    #[test]
    fn test_execute_includes_metadata() {
        let module = GigaThink::new();
        let context = ThinkToolContext {
            query: "What are the implications of AI on employment?".to_string(),
            previous_steps: vec![],
        };

        let result = module.execute(&context).unwrap();
        let metadata = result.output.get("metadata").unwrap();

        assert!(metadata.get("version").is_some());
        assert!(metadata.get("duration_ms").is_some());
        assert!(metadata.get("dimensions_count").is_some());
    }

    #[test]
    fn test_cross_validation() {
        let module = GigaThink::new();

        let perspectives: Vec<Perspective> = AnalysisDimension::all()
            .iter()
            .enumerate()
            .map(|(i, dim)| {
                Perspective::new(
                    format!("p{}", i),
                    *dim,
                    format!("{} Analysis", dim.display_name()),
                    "Content",
                )
                .with_confidence(0.80)
            })
            .collect();

        let result = module.cross_validate(&perspectives);
        assert!(result.is_ok());
    }

    #[test]
    fn test_cross_validation_fails_low_confidence() {
        let module = GigaThink::new();

        let perspectives: Vec<Perspective> = AnalysisDimension::all()
            .iter()
            .enumerate()
            .map(|(i, dim)| {
                Perspective::new(
                    format!("p{}", i),
                    *dim,
                    format!("{} Analysis", dim.display_name()),
                    "Content",
                )
                .with_confidence(0.50) // Below threshold
            })
            .collect();

        let result = module.cross_validate(&perspectives);
        assert!(result.is_err());
    }

    #[test]
    fn test_theme_identification() {
        let module = GigaThink::new();
        let perspectives: Vec<Perspective> = AnalysisDimension::all()
            .iter()
            .enumerate()
            .map(|(i, dim)| {
                Perspective::new(format!("p{}", i), *dim, "Title", "Content").with_confidence(0.80)
            })
            .collect();

        let themes = module.identify_themes(&perspectives);
        assert!(!themes.is_empty());
    }

    #[test]
    fn test_insight_synthesis() {
        let module = GigaThink::new();

        let perspectives: Vec<Perspective> = vec![
            Perspective::new("p1", AnalysisDimension::Economic, "Title", "Content")
                .with_confidence(0.85),
            Perspective::new("p2", AnalysisDimension::Social, "Title", "Content")
                .with_confidence(0.80),
        ];

        let themes = vec![Theme {
            id: "t1".to_string(),
            title: "Theme 1".to_string(),
            description: "Description".to_string(),
            contributing_perspectives: vec!["p1".to_string(), "p2".to_string()],
            confidence: 0.75,
        }];

        let insights = module.synthesize_insights(&perspectives, &themes);
        assert!(!insights.is_empty());
    }

    #[tokio::test]
    async fn test_async_execution() {
        let module = GigaThink::new();
        let context = ThinkToolContext {
            query: "What are the future trends in renewable energy?".to_string(),
            previous_steps: vec![],
        };

        let result = module.execute_async(&context).await.unwrap();
        assert_eq!(result.module, "GigaThink");
        assert!(result.confidence > 0.0);
    }

    #[test]
    fn test_error_types() {
        let err = GigaThinkError::InsufficientPerspectives {
            generated: 5,
            required: 10,
        };
        assert!(err.to_string().contains("5"));
        assert!(err.to_string().contains("10"));

        let err = GigaThinkError::QueryTooShort {
            length: 5,
            minimum: 10,
        };
        assert!(err.to_string().contains("too short"));

        let err = GigaThinkError::LowConfidence {
            confidence: 0.50,
            threshold: 0.70,
        };
        assert!(err.to_string().contains("0.50"));
    }

    // =========================================================================
    // Chain-of-Draft (CoD) Tests
    // Based on Xu et al. 2025 (arXiv:2502.18600)
    // =========================================================================

    #[test]
    fn test_reasoning_mode_default() {
        let mode = ReasoningMode::default();
        assert_eq!(mode, ReasoningMode::Standard);
    }

    #[test]
    fn test_reasoning_mode_system_prompts() {
        assert!(ReasoningMode::Standard.system_prompt_modifier().is_empty());
        assert!(ReasoningMode::ChainOfDraft
            .system_prompt_modifier()
            .contains("5 words"));
        assert!(ReasoningMode::Adaptive
            .system_prompt_modifier()
            .contains("brief"));
    }

    #[test]
    fn test_reasoning_mode_answer_marker() {
        assert!(ReasoningMode::Standard.answer_marker().is_empty());
        assert_eq!(ReasoningMode::ChainOfDraft.answer_marker(), "####");
        assert_eq!(ReasoningMode::Adaptive.answer_marker(), "####");
    }

    #[test]
    fn test_reasoning_mode_token_efficient() {
        assert!(!ReasoningMode::Standard.is_token_efficient());
        assert!(ReasoningMode::ChainOfDraft.is_token_efficient());
        assert!(ReasoningMode::Adaptive.is_token_efficient());
    }

    #[test]
    fn test_chain_of_draft_config_default() {
        let config = ChainOfDraftConfig::default();
        assert_eq!(config.words_per_step, 5);
        assert!(!config.strict_word_budget);
        assert_eq!(config.answer_marker, "####");
        assert!(config.include_step_numbers);
        assert!((config.adaptive_expansion_threshold - 0.7).abs() < 0.001);
    }

    #[test]
    fn test_cod_utils_count_words() {
        assert_eq!(ChainOfDraftUtils::count_words("hello world"), 2);
        assert_eq!(ChainOfDraftUtils::count_words("one two three four five"), 5);
        assert_eq!(ChainOfDraftUtils::count_words(""), 0);
        assert_eq!(ChainOfDraftUtils::count_words("  spaced   out   "), 2);
    }

    #[test]
    fn test_cod_utils_exceeds_word_budget() {
        assert!(!ChainOfDraftUtils::exceeds_word_budget("one two three", 5));
        assert!(!ChainOfDraftUtils::exceeds_word_budget(
            "one two three four five",
            5
        ));
        assert!(ChainOfDraftUtils::exceeds_word_budget(
            "one two three four five six",
            5
        ));
    }

    #[test]
    fn test_cod_utils_extract_answer() {
        let output = "Step 1: analyze problem\nStep 2: identify key factors\n#### The answer is 42";
        let answer = ChainOfDraftUtils::extract_answer(output, "####");
        assert_eq!(answer, Some("The answer is 42".to_string()));

        // Test with no marker
        let no_answer = ChainOfDraftUtils::extract_answer("no marker here", "####");
        assert!(no_answer.is_none());

        // Test with empty marker
        let empty_marker = ChainOfDraftUtils::extract_answer(output, "");
        assert!(empty_marker.is_none());
    }

    #[test]
    fn test_cod_utils_parse_draft_steps() {
        let output = "1. Identify key factors\n2. Analyze relationships\n3. Draw conclusion\n#### Final answer";
        let steps = ChainOfDraftUtils::parse_draft_steps(output, "####");

        assert_eq!(steps.len(), 3);
        assert!(steps[0].contains("Identify"));
        assert!(steps[1].contains("Analyze"));
        assert!(steps[2].contains("Draw"));
    }

    #[test]
    fn test_cod_utils_token_efficiency() {
        // CoD paper claims 7.6% of CoT tokens (92% reduction)
        let efficiency = ChainOfDraftUtils::estimate_token_efficiency(38, 500);
        assert!((efficiency - 0.076).abs() < 0.001);

        // Edge case: zero full CoT
        let edge = ChainOfDraftUtils::estimate_token_efficiency(10, 0);
        assert!((edge - 1.0).abs() < 0.001);
    }

    #[test]
    fn test_cod_utils_generate_prompt() {
        let prompt = ChainOfDraftUtils::generate_cod_prompt("What is 2+2?", 5);
        assert!(prompt.contains("What is 2+2?"));
        assert!(prompt.contains("5 words"));
        assert!(prompt.contains("####"));
    }

    #[test]
    fn test_cod_utils_dimension_prompt() {
        let prompt = ChainOfDraftUtils::generate_dimension_cod_prompt(
            "Analyze startup success",
            "Economic/Financial",
            "What are the financial implications?",
            5,
        );
        assert!(prompt.contains("Economic/Financial"));
        assert!(prompt.contains("financial implications"));
        assert!(prompt.contains("5 words"));
    }

    #[test]
    fn test_chain_of_draft_metrics() {
        let output = "1. Check inputs\n2. Validate data\n3. Compute result\n#### 42";
        let metrics = ChainOfDraftMetrics::from_draft(output, "####", 5);

        assert_eq!(metrics.step_count, 3);
        assert!(metrics.total_reasoning_words > 0);
        assert!(metrics.avg_words_per_step > 0.0);
        // Should be efficient (draft words / estimated full CoT)
        assert!(metrics.token_efficiency_ratio < 1.0);
        assert!(!metrics.adaptive_expansion_used);
    }

    #[test]
    fn test_gigathink_config_chain_of_draft() {
        let config = GigaThinkConfig::chain_of_draft();
        assert_eq!(config.reasoning_mode, ReasoningMode::ChainOfDraft);
        assert_eq!(config.min_perspectives, 5);
        assert_eq!(config.max_perspectives, 8);
        assert!((config.min_confidence - 0.65).abs() < 0.001);
    }

    #[test]
    fn test_gigathink_config_adaptive() {
        let config = GigaThinkConfig::adaptive();
        assert_eq!(config.reasoning_mode, ReasoningMode::Adaptive);
        assert_eq!(config.min_perspectives, 7);
        assert_eq!(config.max_perspectives, 12);
    }

    #[test]
    fn test_gigathink_config_builder_methods() {
        let config = GigaThinkConfig::default()
            .with_reasoning_mode(ReasoningMode::ChainOfDraft)
            .with_words_per_step(7);

        assert_eq!(config.reasoning_mode, ReasoningMode::ChainOfDraft);
        assert_eq!(config.cod_config.words_per_step, 7);
    }

    #[test]
    fn test_cod_metrics_steps_over_budget() {
        // Create output with some steps over budget
        let output =
            "1. Check\n2. This step has many more words than allowed\n3. Done\n#### Result";
        let metrics = ChainOfDraftMetrics::from_draft(output, "####", 3);

        // The second step has more than 3 words
        assert!(metrics.steps_over_budget >= 1);
    }
}