//! Agent Identity Manager - Per-agent dynamic identity files
//!
//! Manages SOUL.md, AGENTS.md, USER.md per agent with:
//! - Per-agent isolated identity directories
//! - USER.md auto-update by agent (stores learned preferences)
//! - SOUL.md/AGENTS.md change proposals (require user approval)
//! - Snapshot history for rollback
//! - File system persistence (survives app restart)
//!
//! Phase 3 of Intelligence Layer Migration.
//! Reference: ZCLAW_AGENT_INTELLIGENCE_EVOLUTION.md §6.2.3
//!
//! NOTE: Some methods are reserved for future integration.

// NOTE: #[tauri::command] functions are registered via invoke_handler! at runtime,
// which the Rust compiler does not track as "use". This module-level allow is
// required for all Tauri-commanded functions. Only genuinely unused non-command
// methods have individual #[allow(dead_code)] annotations below.
#![allow(dead_code)]

use chrono::Utc;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use tracing::{debug, error, warn};

// === Types ===

/// Identity files for an agent
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentityFiles {
    pub soul: String,
    pub instructions: String,
    pub user_profile: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub heartbeat: Option<String>,
}

/// Proposal for identity change (requires user approval)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentityChangeProposal {
    pub id: String,
    pub agent_id: String,
    pub file: IdentityFile,
    pub reason: String,
    pub current_content: String,
    pub suggested_content: String,
    pub status: ProposalStatus,
    pub created_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum IdentityFile {
    Soul,
    Instructions,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ProposalStatus {
    Pending,
    Approved,
    Rejected,
}

/// Snapshot for rollback
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentitySnapshot {
    pub id: String,
    pub agent_id: String,
    pub files: IdentityFiles,
    pub timestamp: String,
    pub reason: String,
}

// === Default Identity Content ===

fn default_soul() -> String {
    r#"# ZCLAW 人格

你是 ZCLAW（智能助手），一个成长性的中文 AI 助手。

## 核心特质

- **高效执行**: 你不只是出主意，你会真正动手完成任务
- **中文优先**: 默认使用中文交流，必要时切换英文
- **专业可靠**: 对技术问题给出精确答案，不确定时坦诚说明
- **持续成长**: 你会记住与用户的交互，不断改进自己的服务方式

## 语气

简洁、专业、友好。避免过度客套，直接给出有用信息。"#.to_string()
}

fn default_instructions() -> String {
    r#"# Agent 指令

## 操作规范

1. 执行文件操作前，先确认目标路径
2. 执行 Shell 命令前，评估安全风险
3. 长时间任务需定期汇报进度
4. 优先使用中文回复

## 记忆管理

- 重要的用户偏好自动记录
- 项目上下文保存到工作区
- 对话结束时总结关键信息"#.to_string()
}

fn default_user_profile() -> String {
    r#"# 用户画像

_尚未收集到用户偏好信息。随着交互积累，此文件将自动更新。_"#.to_string()
}

// === Agent Identity Manager ===

/// Data structure for disk persistence
#[derive(Debug, Clone, Serialize, Deserialize)]
struct IdentityStore {
    identities: HashMap<String, IdentityFiles>,
    proposals: Vec<IdentityChangeProposal>,
    snapshots: Vec<IdentitySnapshot>,
    snapshot_counter: usize,
}

pub struct AgentIdentityManager {
    identities: HashMap<String, IdentityFiles>,
    proposals: Vec<IdentityChangeProposal>,
    snapshots: Vec<IdentitySnapshot>,
    snapshot_counter: usize,
    data_dir: PathBuf,
}

impl AgentIdentityManager {
    /// Create a new identity manager with persistence
    pub fn new() -> Self {
        let data_dir = Self::get_data_dir();
        let mut manager = Self {
            identities: HashMap::new(),
            proposals: Vec::new(),
            snapshots: Vec::new(),
            snapshot_counter: 0,
            data_dir,
        };
        manager.load_from_disk();
        manager
    }

    /// Get the data directory for identity storage
    fn get_data_dir() -> PathBuf {
        // Use ~/.zclaw/identity/ as the data directory
        if let Some(home) = dirs::home_dir() {
            home.join(".zclaw").join("identity")
        } else {
            // Fallback to current directory
            PathBuf::from(".zclaw").join("identity")
        }
    }

    /// Load all data from disk
    fn load_from_disk(&mut self) {
        let store_path = self.data_dir.join("store.json");
        if !store_path.exists() {
            return; // No saved data, use defaults
        }

        match fs::read_to_string(&store_path) {
            Ok(content) => {
                match serde_json::from_str::<IdentityStore>(&content) {
                    Ok(store) => {
                        self.identities = store.identities;
                        self.proposals = store.proposals;
                        self.snapshots = store.snapshots;
                        self.snapshot_counter = store.snapshot_counter;
                        debug!(
                            identities_count = self.identities.len(),
                            proposals_count = self.proposals.len(),
                            snapshots_count = self.snapshots.len(),
                            "[IdentityManager] Loaded identity data from disk"
                        );
                    }
                    Err(e) => {
                        warn!("[IdentityManager] Failed to parse store.json: {}", e);
                    }
                }
            }
            Err(e) => {
                warn!("[IdentityManager] Failed to read store.json: {}", e);
            }
        }
    }

    /// Save all data to disk
    fn save_to_disk(&self) {
        // Ensure directory exists
        if let Err(e) = fs::create_dir_all(&self.data_dir) {
            error!("[IdentityManager] Failed to create data directory: {}", e);
            return;
        }

        let store = IdentityStore {
            identities: self.identities.clone(),
            proposals: self.proposals.clone(),
            snapshots: self.snapshots.clone(),
            snapshot_counter: self.snapshot_counter,
        };

        let store_path = self.data_dir.join("store.json");
        match serde_json::to_string_pretty(&store) {
            Ok(content) => {
                if let Err(e) = fs::write(&store_path, content) {
                    error!("[IdentityManager] Failed to write store.json: {}", e);
                }
            }
            Err(e) => {
                error!("[IdentityManager] Failed to serialize data: {}", e);
            }
        }
    }

    /// Get identity files for an agent (creates default if not exists)
    pub fn get_identity(&mut self, agent_id: &str) -> IdentityFiles {
        if let Some(existing) = self.identities.get(agent_id) {
            return existing.clone();
        }

        // Initialize with defaults
        let defaults = IdentityFiles {
            soul: default_soul(),
            instructions: default_instructions(),
            user_profile: default_user_profile(),
            heartbeat: None,
        };
        self.identities.insert(agent_id.to_string(), defaults.clone());
        defaults
    }

    /// Get a specific file content
    pub fn get_file(&mut self, agent_id: &str, file: IdentityFile) -> String {
        let identity = self.get_identity(agent_id);
        match file {
            IdentityFile::Soul => identity.soul,
            IdentityFile::Instructions => identity.instructions,
        }
    }

    /// Build system prompt from identity files
    pub fn build_system_prompt(&mut self, agent_id: &str, memory_context: Option<&str>) -> String {
        let identity = self.get_identity(agent_id);
        let mut sections = Vec::new();

        if !identity.soul.is_empty() {
            sections.push(identity.soul.clone());
        }
        if !identity.instructions.is_empty() {
            sections.push(identity.instructions.clone());
        }
        if !identity.user_profile.is_empty()
            && identity.user_profile != default_user_profile()
        {
            sections.push(format!("## 用户画像\n{}", identity.user_profile));
        }
        if let Some(ctx) = memory_context {
            sections.push(ctx.to_string());
        }

        sections.join("\n\n")
    }

    /// Update user profile (auto, no approval needed)
    pub fn update_user_profile(&mut self, agent_id: &str, new_content: &str) {
        let identity = self.get_identity(agent_id);
        let _old_content = identity.user_profile.clone();

        // Create snapshot before update
        self.create_snapshot(agent_id, "Auto-update USER.md");

        let mut updated = identity.clone();
        updated.user_profile = new_content.to_string();
        self.identities.insert(agent_id.to_string(), updated);
        self.save_to_disk();
    }

    /// Append to user profile
    pub fn append_to_user_profile(&mut self, agent_id: &str, addition: &str) {
        let identity = self.get_identity(agent_id);
        let updated = format!("{}\n\n{}", identity.user_profile.trim_end(), addition);
        self.update_user_profile(agent_id, &updated);
    }

    /// Propose a change to soul or instructions (requires approval)
    pub fn propose_change(
        &mut self,
        agent_id: &str,
        file: IdentityFile,
        suggested_content: &str,
        reason: &str,
    ) -> IdentityChangeProposal {
        let identity = self.get_identity(agent_id);
        let current_content = match file {
            IdentityFile::Soul => identity.soul.clone(),
            IdentityFile::Instructions => identity.instructions.clone(),
        };

        let proposal = IdentityChangeProposal {
            id: format!("prop_{}_{}", Utc::now().timestamp(), rand_id()),
            agent_id: agent_id.to_string(),
            file,
            reason: reason.to_string(),
            current_content,
            suggested_content: suggested_content.to_string(),
            status: ProposalStatus::Pending,
            created_at: Utc::now().to_rfc3339(),
        };

        self.proposals.push(proposal.clone());
        self.save_to_disk();
        proposal
    }

    /// Approve a pending proposal
    pub fn approve_proposal(&mut self, proposal_id: &str) -> Result<IdentityFiles, String> {
        let proposal_idx = self
            .proposals
            .iter()
            .position(|p| p.id == proposal_id && p.status == ProposalStatus::Pending)
            .ok_or_else(|| "Proposal not found or not pending".to_string())?;

        // Clone all needed data before mutating
        let proposal = self.proposals[proposal_idx].clone();
        let agent_id = proposal.agent_id.clone();
        let file = proposal.file.clone();
        let reason = proposal.reason.clone();
        let suggested_content = proposal.suggested_content.clone();

        // Create snapshot before applying
        self.create_snapshot(&agent_id, &format!("Approved proposal: {}", reason));

        // Get current identity and update
        let identity = self.get_identity(&agent_id);
        let mut updated = identity.clone();

        match file {
            IdentityFile::Soul => updated.soul = suggested_content,
            IdentityFile::Instructions => {
                updated.instructions = suggested_content
            }
        }

        self.identities.insert(agent_id.clone(), updated.clone());

        // Update proposal status
        self.proposals[proposal_idx].status = ProposalStatus::Approved;

        self.save_to_disk();
        Ok(updated)
    }

    /// Reject a pending proposal
    pub fn reject_proposal(&mut self, proposal_id: &str) -> Result<(), String> {
        let proposal = self
            .proposals
            .iter_mut()
            .find(|p| p.id == proposal_id && p.status == ProposalStatus::Pending)
            .ok_or_else(|| "Proposal not found or not pending".to_string())?;

        proposal.status = ProposalStatus::Rejected;
        self.save_to_disk();
        Ok(())
    }

    /// Get pending proposals for an agent (or all agents if None)
    pub fn get_pending_proposals(&self, agent_id: Option<&str>) -> Vec<&IdentityChangeProposal> {
        self.proposals
            .iter()
            .filter(|p| {
                p.status == ProposalStatus::Pending
                    && agent_id.map_or(true, |id| p.agent_id == id)
            })
            .collect()
    }

    /// Direct file update (user explicitly edits in UI)
    pub fn update_file(
        &mut self,
        agent_id: &str,
        file: &str,
        content: &str,
    ) -> Result<(), String> {
        let identity = self.get_identity(agent_id);
        self.create_snapshot(agent_id, &format!("Manual edit: {}", file));

        let mut updated = identity.clone();
        match file {
            "soul" => updated.soul = content.to_string(),
            "instructions" => updated.instructions = content.to_string(),
            "userProfile" | "user_profile" => updated.user_profile = content.to_string(),
            _ => return Err(format!("Unknown file: {}", file)),
        }

        self.identities.insert(agent_id.to_string(), updated);
        self.save_to_disk();
        Ok(())
    }

    /// Create a snapshot
    fn create_snapshot(&mut self, agent_id: &str, reason: &str) {
        let identity = self.get_identity(agent_id);
        self.snapshot_counter += 1;

        self.snapshots.push(IdentitySnapshot {
            id: format!(
                "snap_{}_{}_{}",
                Utc::now().timestamp(),
                self.snapshot_counter,
                rand_id()
            ),
            agent_id: agent_id.to_string(),
            files: identity,
            timestamp: Utc::now().to_rfc3339(),
            reason: reason.to_string(),
        });

        // Keep only last 50 snapshots per agent
        let agent_snapshots: Vec<_> = self
            .snapshots
            .iter()
            .filter(|s| s.agent_id == agent_id)
            .cloned()
            .collect();
        if agent_snapshots.len() > 50 {
            // Keep only the 50 most recent snapshots for this agent
            let ids_to_keep: std::collections::HashSet<_> = agent_snapshots
                .iter()
                .rev()
                .take(50)
                .map(|s| s.id.clone())
                .collect();
            self.snapshots.retain(|s| {
                s.agent_id != agent_id || ids_to_keep.contains(&s.id)
            });
        }
    }

    /// Get snapshots for an agent
    pub fn get_snapshots(&self, agent_id: &str, limit: usize) -> Vec<&IdentitySnapshot> {
        let mut filtered: Vec<_> = self
            .snapshots
            .iter()
            .filter(|s| s.agent_id == agent_id)
            .collect();
        filtered.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
        filtered.into_iter().take(limit).collect()
    }

    /// Restore a snapshot
    pub fn restore_snapshot(&mut self, agent_id: &str, snapshot_id: &str) -> Result<(), String> {
        let snapshot = self
            .snapshots
            .iter()
            .find(|s| s.agent_id == agent_id && s.id == snapshot_id)
            .ok_or_else(|| "Snapshot not found".to_string())?
            .clone();

        // Clone files before creating new snapshot
        let files = snapshot.files.clone();
        let timestamp = snapshot.timestamp.clone();

        // Create snapshot before rollback
        self.create_snapshot(
            agent_id,
            &format!("Rollback to {}", timestamp),
        );

        self.identities
            .insert(agent_id.to_string(), files);
        self.save_to_disk();
        Ok(())
    }

    /// List all agents with identities
    pub fn list_agents(&self) -> Vec<String> {
        self.identities.keys().cloned().collect()
    }

    /// Delete an agent's identity
    pub fn delete_agent(&mut self, agent_id: &str) {
        self.identities.remove(agent_id);
        self.proposals.retain(|p| p.agent_id != agent_id);
        self.snapshots.retain(|s| s.agent_id != agent_id);
        self.save_to_disk();
    }

    /// Export all identities for backup
    #[allow(dead_code)] // Reserved: no Tauri command yet
    pub fn export_all(&self) -> HashMap<String, IdentityFiles> {
        self.identities.clone()
    }

    /// Import identities from backup
    #[allow(dead_code)] // Reserved: no Tauri command yet
    pub fn import(&mut self, identities: HashMap<String, IdentityFiles>) {
        for (agent_id, files) in identities {
            self.identities.insert(agent_id, files);
        }
        self.save_to_disk();
    }

    /// Get all proposals (for debugging)
    #[allow(dead_code)] // Reserved: no Tauri command yet
    pub fn get_all_proposals(&self) -> &[IdentityChangeProposal] {
        &self.proposals
    }
}

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

/// Generate random ID suffix
fn rand_id() -> String {
    use std::sync::atomic::{AtomicU64, Ordering};
    static COUNTER: AtomicU64 = AtomicU64::new(0);
    let count = COUNTER.fetch_add(1, Ordering::Relaxed);
    format!("{:04x}", count % 0x10000)
}

// === Tauri Commands ===

use std::sync::Arc;
use tokio::sync::Mutex;

pub type IdentityManagerState = Arc<Mutex<AgentIdentityManager>>;

/// Initialize identity manager
#[tauri::command]
pub async fn identity_init() -> Result<IdentityManagerState, String> {
    Ok(Arc::new(Mutex::new(AgentIdentityManager::new())))
}

/// Get identity files for an agent
#[tauri::command]
pub async fn identity_get(
    agent_id: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<IdentityFiles, String> {
    let mut manager = state.lock().await;
    Ok(manager.get_identity(&agent_id))
}

/// Get a specific file
#[tauri::command]
pub async fn identity_get_file(
    agent_id: String,
    file: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<String, String> {
    let mut manager = state.lock().await;
    let file_type = match file.as_str() {
        "soul" => IdentityFile::Soul,
        "instructions" => IdentityFile::Instructions,
        _ => return Err(format!("Unknown file: {}", file)),
    };
    Ok(manager.get_file(&agent_id, file_type))
}

/// Build system prompt
#[tauri::command]
pub async fn identity_build_prompt(
    agent_id: String,
    memory_context: Option<String>,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<String, String> {
    let mut manager = state.lock().await;
    Ok(manager.build_system_prompt(&agent_id, memory_context.as_deref()))
}

/// Update user profile (auto)
#[tauri::command]
pub async fn identity_update_user_profile(
    agent_id: String,
    content: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<(), String> {
    let mut manager = state.lock().await;
    manager.update_user_profile(&agent_id, &content);
    Ok(())
}

/// Append to user profile
#[tauri::command]
pub async fn identity_append_user_profile(
    agent_id: String,
    addition: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<(), String> {
    let mut manager = state.lock().await;
    manager.append_to_user_profile(&agent_id, &addition);
    Ok(())
}

/// Propose a change
#[tauri::command]
pub async fn identity_propose_change(
    agent_id: String,
    file: String,
    suggested_content: String,
    reason: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<IdentityChangeProposal, String> {
    let mut manager = state.lock().await;
    let file_type = match file.as_str() {
        "soul" => IdentityFile::Soul,
        "instructions" => IdentityFile::Instructions,
        _ => return Err(format!("Unknown file: {}", file)),
    };
    Ok(manager.propose_change(&agent_id, file_type, &suggested_content, &reason))
}

/// Approve a proposal
#[tauri::command]
pub async fn identity_approve_proposal(
    proposal_id: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<IdentityFiles, String> {
    let mut manager = state.lock().await;
    manager.approve_proposal(&proposal_id)
}

/// Reject a proposal
#[tauri::command]
pub async fn identity_reject_proposal(
    proposal_id: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<(), String> {
    let mut manager = state.lock().await;
    manager.reject_proposal(&proposal_id)
}

/// Get pending proposals
#[tauri::command]
pub async fn identity_get_pending_proposals(
    agent_id: Option<String>,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<Vec<IdentityChangeProposal>, String> {
    let manager = state.lock().await;
    Ok(manager
        .get_pending_proposals(agent_id.as_deref())
        .into_iter()
        .cloned()
        .collect())
}

/// Update file directly
#[tauri::command]
pub async fn identity_update_file(
    agent_id: String,
    file: String,
    content: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<(), String> {
    let mut manager = state.lock().await;
    manager.update_file(&agent_id, &file, &content)
}

/// Get snapshots
#[tauri::command]
pub async fn identity_get_snapshots(
    agent_id: String,
    limit: Option<usize>,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<Vec<IdentitySnapshot>, String> {
    let manager = state.lock().await;
    Ok(manager
        .get_snapshots(&agent_id, limit.unwrap_or(10))
        .into_iter()
        .cloned()
        .collect())
}

/// Restore snapshot
#[tauri::command]
pub async fn identity_restore_snapshot(
    agent_id: String,
    snapshot_id: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<(), String> {
    let mut manager = state.lock().await;
    manager.restore_snapshot(&agent_id, &snapshot_id)
}

/// List agents
#[tauri::command]
pub async fn identity_list_agents(
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<Vec<String>, String> {
    let manager = state.lock().await;
    Ok(manager.list_agents())
}

/// Delete agent identity
#[tauri::command]
pub async fn identity_delete_agent(
    agent_id: String,
    state: tauri::State<'_, IdentityManagerState>,
) -> Result<(), String> {
    let mut manager = state.lock().await;
    manager.delete_agent(&agent_id);
    Ok(())
}

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

    #[test]
    fn test_get_identity_creates_default() {
        let mut manager = AgentIdentityManager::new();
        let identity = manager.get_identity("test-agent");
        assert!(!identity.soul.is_empty());
        assert!(!identity.instructions.is_empty());
    }

    #[test]
    fn test_update_user_profile() {
        let mut manager = AgentIdentityManager::new();
        manager.update_user_profile("test-agent", "New profile content");
        let identity = manager.get_identity("test-agent");
        assert_eq!(identity.user_profile, "New profile content");
    }

    #[test]
    fn test_proposal_flow() {
        let mut manager = AgentIdentityManager::new();
        let proposal = manager.propose_change(
            "test-agent",
            IdentityFile::Soul,
            "New soul content",
            "Test proposal",
        );

        assert_eq!(proposal.status, ProposalStatus::Pending);

        let pending = manager.get_pending_proposals(None);
        assert_eq!(pending.len(), 1);

        // Approve
        let result = manager.approve_proposal(&proposal.id);
        assert!(result.is_ok());

        let identity = manager.get_identity("test-agent");
        assert_eq!(identity.soul, "New soul content");
    }

    #[test]
    fn test_snapshots() {
        let mut manager = AgentIdentityManager::new();
        manager.update_user_profile("test-agent", "First update");
        manager.update_user_profile("test-agent", "Second update");

        let snapshots = manager.get_snapshots("test-agent", 10);
        assert!(snapshots.len() >= 2);
    }
}