//! Reflection Engine - Agent self-improvement through conversation analysis
//!
//! Periodically analyzes recent conversations to:
//! - Identify behavioral patterns (positive and negative)
//! - Generate improvement suggestions
//! - Propose identity file changes (with user approval)
//! - Create meta-memories about agent performance
//!
//! Phase 3 of Intelligence Layer Migration.
//! Reference: ZCLAW_AGENT_INTELLIGENCE_EVOLUTION.md §6.4.2
//!
//! NOTE: Some methods are reserved for future self-improvement features.

// NOTE: #[tauri::command] functions are registered via invoke_handler! at runtime,
// which the Rust compiler does not track as "use". Module-level allow required
// for Tauri-commanded functions. Genuinely unused methods annotated individually.
#![allow(dead_code)]

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;

// Re-export from zclaw-runtime for LLM integration
use zclaw_runtime::driver::{CompletionRequest, ContentBlock, LlmDriver};

// === Types ===

/// Reflection configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReflectionConfig {
    #[serde(default = "default_trigger_conversations")]
    pub trigger_after_conversations: usize,
    #[serde(default = "default_trigger_hours")]
    pub trigger_after_hours: u64,
    #[serde(default)]
    pub allow_soul_modification: bool,
    #[serde(default = "default_require_approval")]
    pub require_approval: bool,
    #[serde(default = "default_use_llm")]
    pub use_llm: bool,
    #[serde(default = "default_llm_fallback")]
    pub llm_fallback_to_rules: bool,
}

fn default_trigger_conversations() -> usize { 5 }
fn default_trigger_hours() -> u64 { 24 }
fn default_require_approval() -> bool { true }
fn default_use_llm() -> bool { true }
fn default_llm_fallback() -> bool { true }

impl Default for ReflectionConfig {
    fn default() -> Self {
        Self {
            trigger_after_conversations: 5,
            trigger_after_hours: 24,
            allow_soul_modification: true,  // Allow soul modification by default for self-evolution
            require_approval: true,
            use_llm: true,
            llm_fallback_to_rules: true,
        }
    }
}

/// Observed pattern from analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PatternObservation {
    pub observation: String,
    pub frequency: usize,
    pub sentiment: Sentiment,
    pub evidence: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Sentiment {
    Positive,
    Negative,
    Neutral,
}

/// Improvement suggestion
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImprovementSuggestion {
    pub area: String,
    pub suggestion: String,
    pub priority: Priority,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Priority {
    High,
    Medium,
    Low,
}

/// Identity change proposal
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentityChangeProposal {
    pub agent_id: String,
    pub field: String,
    pub current_value: String,
    pub proposed_value: String,
    pub reason: String,
}

/// Result of reflection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReflectionResult {
    pub patterns: Vec<PatternObservation>,
    pub improvements: Vec<ImprovementSuggestion>,
    pub identity_proposals: Vec<IdentityChangeProposal>,
    pub new_memories: usize,
    pub timestamp: String,
    /// P2-07: Whether rules-based fallback was used instead of LLM
    #[serde(default)]
    pub used_fallback: bool,
}

/// Reflection state
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReflectionState {
    pub conversations_since_reflection: usize,
    pub last_reflection_time: Option<String>,
    pub last_reflection_agent_id: Option<String>,
}

impl Default for ReflectionState {
    fn default() -> Self {
        Self {
            conversations_since_reflection: 0,
            last_reflection_time: None,
            last_reflection_agent_id: None,
        }
    }
}

// === Memory Entry (simplified for analysis) ===

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryEntryForAnalysis {
    pub memory_type: String,
    pub content: String,
    pub importance: usize,
    pub access_count: usize,
    pub tags: Vec<String>,
}

// === Reflection Engine ===

pub struct ReflectionEngine {
    config: ReflectionConfig,
    state: ReflectionState,
    history: Vec<ReflectionResult>,
}

impl ReflectionEngine {
    pub fn new(config: Option<ReflectionConfig>) -> Self {
        Self {
            config: config.unwrap_or_default(),
            state: ReflectionState::default(),
            history: Vec::new(),
        }
    }

    /// Record that a conversation happened
    pub fn record_conversation(&mut self) {
        self.state.conversations_since_reflection += 1;
    }

    /// Check if it's time for reflection
    pub fn should_reflect(&self) -> bool {
        // Conversation count trigger
        if self.state.conversations_since_reflection >= self.config.trigger_after_conversations {
            return true;
        }

        // Time-based trigger
        if let Some(last_time) = &self.state.last_reflection_time {
            if let Ok(last) = DateTime::parse_from_rfc3339(last_time) {
                let elapsed = Utc::now().signed_duration_since(last);
                let hours_since = elapsed.num_hours() as u64;
                if hours_since >= self.config.trigger_after_hours {
                    return true;
                }
            }
        } else {
            // Never reflected before, trigger after initial conversations
            return self.state.conversations_since_reflection >= 3;
        }

        false
    }

    /// Execute reflection cycle
    pub async fn reflect(
        &mut self,
        agent_id: &str,
        memories: &[MemoryEntryForAnalysis],
        driver: Option<Arc<dyn LlmDriver>>,
    ) -> ReflectionResult {
        // P2-07: Track whether rules-based fallback was used
        let mut used_fallback = !self.config.use_llm;
        // 1. Analyze memory patterns (LLM if configured, rules fallback)
        let patterns = if self.config.use_llm {
            if let Some(ref llm) = driver {
                match self.analyze_patterns_with_llm(memories, llm).await {
                    Ok(p) => p,
                    Err(e) => {
                        tracing::warn!("[reflection] LLM analysis failed, falling back to rules: {}", e);
                        used_fallback = true;
                        if self.config.llm_fallback_to_rules {
                            self.analyze_patterns(memories)
                        } else {
                            Vec::new()
                        }
                    }
                }
            } else {
                tracing::debug!("[reflection] use_llm=true but no driver available, using rules");
                used_fallback = true;
                self.analyze_patterns(memories)
            }
        } else {
            self.analyze_patterns(memories)
        };

        // 2. Generate improvement suggestions
        let improvements = self.generate_improvements(&patterns, memories);

        // 3. Propose identity changes if patterns warrant it
        let identity_proposals: Vec<IdentityChangeProposal> = if self.config.allow_soul_modification {
            self.propose_identity_changes(agent_id, &patterns)
        } else {
            vec![]
        };

        // 4. Count new memories (would be saved)
        // Include LLM-generated patterns and high-priority improvements
        let new_memories = patterns.iter()
            .filter(|p| p.frequency >= 1 || p.frequency >= 2)
            .count()
            + improvements.iter()
                .filter(|i| matches!(i.priority, Priority::High))
                .count();
        // Include all LLM-proposed improvements

        // 5. Build result
        let result = ReflectionResult {
            patterns,
            improvements,
            identity_proposals,
            new_memories,
            timestamp: Utc::now().to_rfc3339(),
            used_fallback, // P2-07: expose fallback status to callers
        };

        // 6. Update state
        self.state.conversations_since_reflection = 0;
        self.state.last_reflection_time = Some(result.timestamp.clone());
        self.state.last_reflection_agent_id = Some(agent_id.to_string());

        // 7. Store in history
        self.history.push(result.clone());
        if self.history.len() > 20 {
            self.history = self.history.split_off(10);
        }

        // 8. Persist result, state, and history to VikingStorage (fire-and-forget)
        let state_to_persist = self.state.clone();
        let result_to_persist = result.clone();
        let agent_id_owned = agent_id.to_string();
        tokio::spawn(async move {
            if let Ok(storage) = crate::viking_commands::get_storage().await {
                // Persist state as JSON string
                let state_key = format!("reflection:state:{}", agent_id_owned);
                if let Ok(state_json) = serde_json::to_string(&state_to_persist) {
                    if let Err(e) = zclaw_growth::VikingStorage::store_metadata_json(
                        &*storage, &state_key, &state_json,
                    ).await {
                        tracing::warn!("[reflection] Failed to persist state: {}", e);
                    }
                }

                // Persist latest result as JSON string
                let result_key = format!("reflection:latest:{}", agent_id_owned);
                if let Ok(result_json) = serde_json::to_string(&result_to_persist) {
                    if let Err(e) = zclaw_growth::VikingStorage::store_metadata_json(
                        &*storage, &result_key, &result_json,
                    ).await {
                        tracing::warn!("[reflection] Failed to persist result: {}", e);
                    }
                }

                // Persist full history array (append new result)
                let history_key = format!("reflection:history:{}", agent_id_owned);
                let mut history: Vec<ReflectionResult> =
                    match zclaw_growth::VikingStorage::get_metadata_json(
                        &*storage, &history_key,
                    ).await {
                        Ok(Some(json)) => serde_json::from_str(&json).unwrap_or_default(),
                        _ => Vec::new(),
                    };
                history.push(result_to_persist);
                // Keep last 20 entries
                if history.len() > 20 {
                    history = history.split_off(history.len() - 20);
                }
                if let Ok(history_json) = serde_json::to_string(&history) {
                    if let Err(e) = zclaw_growth::VikingStorage::store_metadata_json(
                        &*storage, &history_key, &history_json,
                    ).await {
                        tracing::warn!("[reflection] Failed to persist history: {}", e);
                    }
                }
            }
        });

        result
    }

    /// Analyze patterns using LLM for deeper behavioral insights
    async fn analyze_patterns_with_llm(
        &self,
        memories: &[MemoryEntryForAnalysis],
        driver: &Arc<dyn LlmDriver>,
    ) -> Result<Vec<PatternObservation>, String> {
        if memories.is_empty() {
            return Ok(Vec::new());
        }

        // Build memory summary for the prompt
        let memory_summary: String = memories.iter().enumerate().map(|(i, m)| {
            format!("{}. [{}] (重要性:{}, 访问:{}) {}",
                i + 1, m.memory_type, m.importance, m.access_count, m.content)
        }).collect::<Vec<_>>().join("\n");

        let system_prompt = r#"你是行为分析专家。分析以下 Agent 记忆条目，识别行为模式和趋势。

请返回 JSON 数组，每个元素包含：
- "observation": string — 模式描述（中文）
- "frequency": number — 该模式出现的频率估计（1-10）
- "sentiment": "positive" | "negative" | "neutral" — 情感倾向
- "evidence": string[] — 支持该观察的证据（记忆内容摘要，最多3条）

只返回 JSON 数组，不要其他内容。如果没有明显模式，返回空数组。"#
            .to_string();

        let request = CompletionRequest {
            model: driver.provider().to_string(),
            system: Some(system_prompt),
            messages: vec![zclaw_types::Message::assistant(
                format!("分析以下记忆条目：\n\n{}", memory_summary)
            )],
            max_tokens: Some(2048),
            temperature: Some(0.3),
            stream: false,
            ..Default::default()
        };

        let response = driver.complete(request).await
            .map_err(|e| format!("LLM 调用失败: {}", e))?;

        // Extract text from response
        let text = response.content.iter()
            .filter_map(|block| match block {
                ContentBlock::Text { text } => Some(text.as_str()),
                _ => None,
            })
            .collect::<Vec<_>>()
            .join("");

        // Parse JSON response (handle markdown code blocks)
        let json_str = extract_json_from_llm_response(&text);

        serde_json::from_str::<Vec<PatternObservation>>(&json_str)
            .map_err(|e| format!("解析 LLM 响应失败: {} — 原始响应: {}", e, &text[..text.len().min(200)]))
    }

    /// Analyze patterns in memories (rule-based fallback)
    fn analyze_patterns(&self, memories: &[MemoryEntryForAnalysis]) -> Vec<PatternObservation> {
        let mut patterns = Vec::new();

        // Analyze memory type distribution
        let mut type_counts: HashMap<String, usize> = HashMap::new();
        for m in memories {
            *type_counts.entry(m.memory_type.clone()).or_insert(0) += 1;
        }

        // Pattern: Too many tasks accumulating
        let task_count = *type_counts.get("task").unwrap_or(&0);
        if task_count >= 3 {
            let evidence: Vec<String> = memories
                .iter()
                .filter(|m| m.memory_type == "task")
                .take(3)
                .map(|m| m.content.clone())
                .collect();

            patterns.push(PatternObservation {
                observation: format!("积累了 {} 个待办任务，可能存在任务管理不善", task_count),
                frequency: task_count,
                sentiment: Sentiment::Negative,
                evidence,
            });
        }

        // Pattern: Strong preference accumulation
        let pref_count = *type_counts.get("preference").unwrap_or(&0);
        if pref_count >= 3 {
            let evidence: Vec<String> = memories
                .iter()
                .filter(|m| m.memory_type == "preference")
                .take(3)
                .map(|m| m.content.clone())
                .collect();

            patterns.push(PatternObservation {
                observation: format!("已记录 {} 个用户偏好，对用户习惯有较好理解", pref_count),
                frequency: pref_count,
                sentiment: Sentiment::Positive,
                evidence,
            });
        }

        // Pattern: Many lessons learned
        let lesson_count = *type_counts.get("lesson").unwrap_or(&0);
        if lesson_count >= 3 {
            let evidence: Vec<String> = memories
                .iter()
                .filter(|m| m.memory_type == "lesson")
                .take(3)
                .map(|m| m.content.clone())
                .collect();

            patterns.push(PatternObservation {
                observation: format!("积累了 {} 条经验教训，知识库在成长", lesson_count),
                frequency: lesson_count,
                sentiment: Sentiment::Positive,
                evidence,
            });
        }

        // Pattern: High-importance items being accessed frequently
        let high_access: Vec<_> = memories
            .iter()
            .filter(|m| m.access_count >= 5 && m.importance >= 7)
            .collect();
        if high_access.len() >= 2 {
            let evidence: Vec<String> = high_access.iter().take(3).map(|m| m.content.clone()).collect();

            patterns.push(PatternObservation {
                observation: format!("有 {} 条高频访问的重要记忆，核心知识正在形成", high_access.len()),
                frequency: high_access.len(),
                sentiment: Sentiment::Positive,
                evidence,
            });
        }

        // Pattern: Low-importance memories accumulating
        let low_importance_count = memories.iter().filter(|m| m.importance <= 3).count();
        if low_importance_count > 15 {
            patterns.push(PatternObservation {
                observation: format!("有 {} 条低重要性记忆，可考虑清理", low_importance_count),
                frequency: low_importance_count,
                sentiment: Sentiment::Neutral,
                evidence: vec![],
            });
        }

        // Pattern: Tag analysis - recurring topics
        let mut tag_counts: HashMap<String, usize> = HashMap::new();
        for m in memories {
            for tag in &m.tags {
                if tag != "auto-extracted" {
                    *tag_counts.entry(tag.clone()).or_insert(0) += 1;
                }
            }
        }

        let mut frequent_tags: Vec<_> = tag_counts
            .iter()
            .filter(|(_, count)| **count >= 5)
            .map(|(tag, count)| (tag.clone(), *count))
            .collect();
        frequent_tags.sort_by(|a, b| b.1.cmp(&a.1));

        if !frequent_tags.is_empty() {
            let tag_str: Vec<String> = frequent_tags
                .iter()
                .take(5)
                .map(|(tag, count)| format!("{}({}次)", tag, count))
                .collect();

            patterns.push(PatternObservation {
                observation: format!("反复出现的主题: {}", tag_str.join(", ")),
                frequency: frequent_tags[0].1,
                sentiment: Sentiment::Neutral,
                evidence: frequent_tags.iter().take(5).map(|(t, _)| t.clone()).collect(),
            });
        }

        patterns
    }

    /// Generate improvement suggestions
    fn generate_improvements(
        &self,
        patterns: &[PatternObservation],
        memories: &[MemoryEntryForAnalysis],
    ) -> Vec<ImprovementSuggestion> {
        let mut improvements = Vec::new();

        // Suggestion: Clear pending tasks
        if patterns.iter().any(|p| p.observation.contains("待办任务")) {
            improvements.push(ImprovementSuggestion {
                area: "任务管理".to_string(),
                suggestion: "清理已完成的任务记忆，对长期未处理的任务降低重要性或标记为已取消".to_string(),
                priority: Priority::High,
            });
        }

        // Suggestion: Prune low-importance memories
        if patterns.iter().any(|p| p.observation.contains("低重要性")) {
            improvements.push(ImprovementSuggestion {
                area: "记忆管理".to_string(),
                suggestion: "执行记忆清理，移除30天以上未访问且重要性低于3的记忆".to_string(),
                priority: Priority::Medium,
            });
        }

        // Suggestion: User profile enrichment
        let pref_count = memories.iter().filter(|m| m.memory_type == "preference").count();
        if pref_count < 3 {
            improvements.push(ImprovementSuggestion {
                area: "用户理解".to_string(),
                suggestion: "主动在对话中了解用户偏好（沟通风格、技术栈、工作习惯），丰富用户画像".to_string(),
                priority: Priority::Medium,
            });
        }

        // Suggestion: Knowledge consolidation
        let fact_count = memories.iter().filter(|m| m.memory_type == "fact").count();
        if fact_count > 20 {
            improvements.push(ImprovementSuggestion {
                area: "知识整合".to_string(),
                suggestion: "合并相似的事实记忆，提高检索效率。可将相关事实整合为结构化的项目/用户档案".to_string(),
                priority: Priority::Low,
            });
        }

        improvements
    }

    /// Propose identity changes based on patterns
    fn propose_identity_changes(
        &self,
        agent_id: &str,
        patterns: &[PatternObservation],
    ) -> Vec<IdentityChangeProposal> {
        let mut proposals = Vec::new();

        // If many negative patterns, propose instruction update
        let negative_patterns: Vec<_> = patterns
            .iter()
            .filter(|p| matches!(p.sentiment, Sentiment::Negative))
            .collect();

        if negative_patterns.len() >= 2 {
            let additions: Vec<String> = negative_patterns
                .iter()
                .map(|p| format!("- 注意: {}", p.observation))
                .collect();

            proposals.push(IdentityChangeProposal {
                agent_id: agent_id.to_string(),
                field: "instructions".to_string(),
                current_value: "...".to_string(),
                proposed_value: format!("\n\n## 自我反思改进\n{}", additions.join("\n")),
                reason: format!(
                    "基于 {} 个负面模式观察，建议在指令中增加自我改进提醒",
                    negative_patterns.len()
                ),
            });
        }

        proposals
    }

    /// Get reflection history
    pub fn get_history(&self, limit: usize) -> Vec<&ReflectionResult> {
        self.history.iter().rev().take(limit).collect()
    }

    /// Get current state
    pub fn get_state(&self) -> &ReflectionState {
        &self.state
    }

    /// Get configuration
    pub fn get_config(&self) -> &ReflectionConfig {
        &self.config
    }

    /// Update configuration
    pub fn update_config(&mut self, config: ReflectionConfig) {
        self.config = config;
    }

    /// Restore state from VikingStorage metadata (called during init)
    ///
    /// Spawns an async task to read persisted state and result from VikingStorage.
    /// Results are placed in global caches, consumed one-shot by intelligence_hooks.
    pub fn restore_state(&self, agent_id: &str) {
        let rt = tokio::runtime::Handle::current();
        let state_key = format!("reflection:state:{}", agent_id);
        let result_key = format!("reflection:latest:{}", agent_id);
        let agent_id_owned = agent_id.to_string();

        rt.spawn(async move {
            match crate::viking_commands::get_storage().await {
                Ok(storage) => {
                    // Restore state
                    match zclaw_growth::VikingStorage::get_metadata_json(
                        &*storage, &state_key,
                    ).await {
                        Ok(Some(state_json)) => {
                            if let Ok(persisted_state) = serde_json::from_str::<ReflectionState>(&state_json) {
                                tracing::info!(
                                    "[reflection] Restored state for {}: {} conversations since last reflection",
                                    agent_id_owned,
                                    persisted_state.conversations_since_reflection
                                );
                                let cache = get_state_cache();
                                if let Ok(mut cache) = cache.write() {
                                    cache.insert(agent_id_owned.clone(), persisted_state);
                                }
                            }
                        }
                        Ok(None) => {
                            tracing::debug!("[reflection] No persisted state for {}", agent_id_owned);
                        }
                        Err(e) => {
                            tracing::warn!("[reflection] Failed to read state: {}", e);
                        }
                    }

                    // Restore latest result into history
                    match zclaw_growth::VikingStorage::get_metadata_json(
                        &*storage, &result_key,
                    ).await {
                        Ok(Some(result_json)) => {
                            if let Ok(persisted_result) = serde_json::from_str::<ReflectionResult>(&result_json) {
                                let cache = get_result_cache();
                                if let Ok(mut cache) = cache.write() {
                                    cache.insert(agent_id_owned.clone(), persisted_result);
                                }
                            }
                        }
                        Ok(None) => {}
                        Err(e) => {
                            tracing::warn!("[reflection] Failed to read result: {}", e);
                        }
                    }
                }
                Err(e) => {
                    tracing::warn!("[reflection] Storage unavailable during restore: {}", e);
                }
            }
        });
    }

    /// Apply a restored state (called from intelligence_hooks after restore completes)
    pub fn apply_restored_state(&mut self, state: ReflectionState) {
        self.state = state;
    }

    /// Apply a restored latest result to history
    pub fn apply_restored_result(&mut self, result: ReflectionResult) {
        self.history.push(result);
    }
}

// === State Restoration Cache ===

use std::sync::RwLock as StdRwLock;
use std::sync::OnceLock as StdOnceLock;

/// Temporary cache for restored reflection state (bridges async init ↔ sync apply)
static REFLECTION_STATE_CACHE: StdOnceLock<StdRwLock<HashMap<String, ReflectionState>>> = StdOnceLock::new();

/// Temporary cache for restored reflection result
static REFLECTION_RESULT_CACHE: StdOnceLock<StdRwLock<HashMap<String, ReflectionResult>>> = StdOnceLock::new();

fn get_state_cache() -> &'static StdRwLock<HashMap<String, ReflectionState>> {
    REFLECTION_STATE_CACHE.get_or_init(|| StdRwLock::new(HashMap::new()))
}

fn get_result_cache() -> &'static StdRwLock<HashMap<String, ReflectionResult>> {
    REFLECTION_RESULT_CACHE.get_or_init(|| StdRwLock::new(HashMap::new()))
}

/// Pop restored state from cache (one-shot, removes after read)
pub fn pop_restored_state(agent_id: &str) -> Option<ReflectionState> {
    let cache = get_state_cache();
    if let Ok(mut cache) = cache.write() {
        cache.remove(agent_id)
    } else {
        None
    }
}

/// Pop restored result from cache (one-shot, removes after read)
pub fn pop_restored_result(agent_id: &str) -> Option<ReflectionResult> {
    let cache = get_result_cache();
    if let Ok(mut cache) = cache.write() {
        cache.remove(agent_id)
    } else {
        None
    }
}

/// Peek restored state from cache (non-destructive read)
pub fn peek_restored_state(agent_id: &str) -> Option<ReflectionState> {
    let cache = get_state_cache();
    cache.read().ok()?.get(agent_id).cloned()
}

/// Peek restored result from cache (non-destructive read)
pub fn peek_restored_result(agent_id: &str) -> Option<ReflectionResult> {
    let cache = get_result_cache();
    cache.read().ok()?.get(agent_id).cloned()
}

// === Tauri Commands ===

use tokio::sync::Mutex;

pub type ReflectionEngineState = Arc<Mutex<ReflectionEngine>>;

/// Initialize reflection engine with config
/// Updates the shared state with new configuration
// @connected
#[tauri::command]
pub async fn reflection_init(
    config: Option<ReflectionConfig>,
    state: tauri::State<'_, ReflectionEngineState>,
) -> Result<bool, String> {
    let mut engine = state.lock().await;
    if let Some(cfg) = config {
        engine.update_config(cfg);
    }
    Ok(true)
}

/// Record a conversation
// @connected
#[tauri::command]
pub async fn reflection_record_conversation(
    state: tauri::State<'_, ReflectionEngineState>,
) -> Result<(), String> {
    let mut engine = state.lock().await;
    engine.record_conversation();
    Ok(())
}

/// Check if reflection should run
// @connected
#[tauri::command]
pub async fn reflection_should_reflect(
    state: tauri::State<'_, ReflectionEngineState>,
) -> Result<bool, String> {
    let engine = state.lock().await;
    Ok(engine.should_reflect())
}

/// Execute reflection
// @connected
#[tauri::command]
pub async fn reflection_reflect(
    agent_id: String,
    memories: Vec<MemoryEntryForAnalysis>,
    state: tauri::State<'_, ReflectionEngineState>,
    kernel_state: tauri::State<'_, crate::kernel_commands::KernelState>,
) -> Result<ReflectionResult, String> {
    let driver = {
        let kernel_lock = kernel_state.lock().await;
        kernel_lock.as_ref().map(|k| k.driver())
    };
    let mut engine = state.lock().await;
    Ok(engine.reflect(&agent_id, &memories, driver).await)
}

/// Get reflection history
///
/// Returns in-memory history first. If empty and an agent_id is provided,
/// falls back to the persisted history array from VikingStorage metadata,
/// then to the single latest result for backward compatibility.
// @connected
#[tauri::command]
pub async fn reflection_get_history(
    limit: Option<usize>,
    agent_id: Option<String>,
    state: tauri::State<'_, ReflectionEngineState>,
) -> Result<Vec<ReflectionResult>, String> {
    let limit = limit.unwrap_or(10);
    let engine = state.lock().await;
    let mut results: Vec<ReflectionResult> = engine.get_history(limit)
        .into_iter()
        .cloned()
        .collect();

    // If no in-memory results and we have an agent_id, load persisted history
    if results.is_empty() {
        if let Some(ref aid) = agent_id {
            if let Ok(storage) = crate::viking_commands::get_storage().await {
                let history_key = format!("reflection:history:{}", aid);
                match zclaw_growth::VikingStorage::get_metadata_json(&*storage, &history_key).await {
                    Ok(Some(json)) => {
                        if let Ok(mut persisted) = serde_json::from_str::<Vec<ReflectionResult>>(&json) {
                            persisted.reverse();
                            persisted.truncate(limit);
                            results = persisted;
                        }
                    }
                    Ok(None) => {
                        // Fallback: try loading single latest result (pre-history format)
                        let latest_key = format!("reflection:latest:{}", aid);
                        if let Ok(Some(json)) = zclaw_growth::VikingStorage::get_metadata_json(
                            &*storage, &latest_key,
                        ).await {
                            if let Ok(persisted) = serde_json::from_str::<ReflectionResult>(&json) {
                                results.push(persisted);
                            }
                        }
                    }
                    Err(e) => {
                        tracing::warn!("[reflection] Failed to load persisted history: {}", e);
                    }
                }
            }
        }
    }

    Ok(results)
}

/// Get reflection state
// @connected
#[tauri::command]
pub async fn reflection_get_state(
    state: tauri::State<'_, ReflectionEngineState>,
) -> Result<ReflectionState, String> {
    let engine = state.lock().await;
    Ok(engine.get_state().clone())
}

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

    #[test]
    fn test_should_reflect_initial() {
        let mut engine = ReflectionEngine::new(None);
        assert!(!engine.should_reflect());

        // After 3 conversations
        for _ in 0..3 {
            engine.record_conversation();
        }
        assert!(engine.should_reflect());
    }

    #[test]
    fn test_analyze_patterns() {
        let engine = ReflectionEngine::new(None);
        let memories = vec![
            MemoryEntryForAnalysis {
                memory_type: "task".to_string(),
                content: "Task 1".to_string(),
                importance: 7,
                access_count: 1,
                tags: vec![],
            },
            MemoryEntryForAnalysis {
                memory_type: "task".to_string(),
                content: "Task 2".to_string(),
                importance: 8,
                access_count: 2,
                tags: vec![],
            },
        ];

        let patterns = engine.analyze_patterns(&memories);
        // Should not trigger (only 2 tasks, threshold is 3)
        assert!(!patterns.iter().any(|p| p.observation.contains("待办任务")));
    }

    #[tokio::test]
    async fn test_reflection_cycle_full() {
        // Use config with use_llm=false to test rules-based path without driver
        let config = ReflectionConfig {
            use_llm: false,
            trigger_after_conversations: 5,
            ..Default::default()
        };
        let mut engine = ReflectionEngine::new(Some(config));

        // Record 5 conversations
        for _ in 0..5 {
            engine.record_conversation();
        }
        assert!(engine.should_reflect(), "Should trigger after 5 conversations");

        // Provide memories with enough task entries to exceed threshold (5)
        let mut memories = Vec::new();
        for i in 0..6 {
            memories.push(MemoryEntryForAnalysis {
                memory_type: "task".to_string(),
                content: format!("待办任务 {}", i),
                importance: 7,
                access_count: 1,
                tags: vec!["任务".to_string()],
            });
        }
        // Add some preferences and knowledge
        memories.push(MemoryEntryForAnalysis {
            memory_type: "preferences".to_string(),
            content: "用户偏好简洁回复".to_string(),
            importance: 8,
            access_count: 3,
            tags: vec!["偏好".to_string()],
        });
        memories.push(MemoryEntryForAnalysis {
            memory_type: "knowledge".to_string(),
            content: "用户熟悉 Rust 编程".to_string(),
            importance: 6,
            access_count: 2,
            tags: vec!["知识".to_string()],
        });

        // Run reflection (no LLM driver, rules-based)
        let result = engine.reflect("agent-test", &memories, None).await;

        // Verify result structure
        assert!(!result.patterns.is_empty(), "Should detect patterns from memories");
        assert!(!result.improvements.is_empty(), "Should generate improvements");
        assert!(!result.timestamp.is_empty(), "Should have timestamp");
        assert!(result.used_fallback, "Should use rules-based fallback when no LLM driver");

        // Verify state reset after reflection
        assert!(!engine.should_reflect(), "Counter should reset after reflection");

        // Verify history stored
        assert_eq!(engine.history.len(), 1, "History should contain 1 reflection result");
    }

    #[tokio::test]
    async fn test_reflection_generates_identity_proposals() {
        let config = ReflectionConfig {
            use_llm: false,
            allow_soul_modification: true,
            trigger_after_conversations: 3,
            ..Default::default()
        };
        let mut engine = ReflectionEngine::new(Some(config));

        for _ in 0..3 {
            engine.record_conversation();
        }

        // High-frequency preference pattern should trigger identity proposal
        let memories: Vec<MemoryEntryForAnalysis> = (0..7)
            .map(|i| MemoryEntryForAnalysis {
                memory_type: "preferences".to_string(),
                content: format!("偏好项目 {}", i),
                importance: 8,
                access_count: 5,
                tags: vec!["偏好".to_string()],
            })
            .collect();

        let result = engine.reflect("agent-identity-test", &memories, None).await;

        // Identity proposals are generated when patterns are strong enough
        // (rules-based may not always produce proposals, but result structure should be valid)
        assert!(result.identity_proposals.len() <= 5, "Identity proposals should be bounded");
    }
}

// === Helpers ===

/// Extract JSON from LLM response, handling markdown code blocks and extra text
fn extract_json_from_llm_response(text: &str) -> String {
    let trimmed = text.trim();

    // Try to find JSON array in markdown code block
    if let Some(start) = trimmed.find("```json") {
        if let Some(content_start) = trimmed[start..].find('\n') {
            if let Some(end) = trimmed[content_start..].find("```") {
                return trimmed[content_start + 1..content_start + end].trim().to_string();
            }
        }
    }

    // Try to find bare JSON array
    if let Some(start) = trimmed.find('[') {
        if let Some(end) = trimmed.rfind(']') {
            return trimmed[start..end + 1].to_string();
        }
    }

    trimmed.to_string()
}