-- 1. 工作目录注册表
CREATE TABLE IF NOT EXISTS working_directories (
    id TEXT PRIMARY KEY,
    path TEXT NOT NULL UNIQUE,
    name TEXT,
    is_current BOOLEAN NOT NULL DEFAULT 0,
    created_at INTEGER NOT NULL DEFAULT 0
);

-- 2. Provider 状态快照 (is_current + in_failover_queue)
--    每个目录保存所有 provider 的两个状态标志
CREATE TABLE IF NOT EXISTS dir_provider_state (
    dir_id TEXT NOT NULL,
    app_type TEXT NOT NULL,
    provider_id TEXT NOT NULL,
    is_current BOOLEAN NOT NULL DEFAULT 0,
    in_failover_queue BOOLEAN NOT NULL DEFAULT 0,
    PRIMARY KEY (dir_id, app_type, provider_id)
);

-- 3. MCP 启用状态快照 (直接镜像 4 列，不做行展开)
CREATE TABLE IF NOT EXISTS dir_mcp_state (
    dir_id TEXT NOT NULL,
    mcp_id TEXT NOT NULL,
    enabled_claude BOOLEAN NOT NULL DEFAULT 0,
    enabled_codex BOOLEAN NOT NULL DEFAULT 0,
    enabled_gemini BOOLEAN NOT NULL DEFAULT 0,
    enabled_opencode BOOLEAN NOT NULL DEFAULT 0,
    PRIMARY KEY (dir_id, mcp_id)
);

-- 4. Skill 启用状态快照 (直接镜像 4 列)
CREATE TABLE IF NOT EXISTS dir_skill_state (
    dir_id TEXT NOT NULL,
    skill_id TEXT NOT NULL,
    enabled_claude BOOLEAN NOT NULL DEFAULT 0,
    enabled_codex BOOLEAN NOT NULL DEFAULT 0,
    enabled_gemini BOOLEAN NOT NULL DEFAULT 0,
    enabled_opencode BOOLEAN NOT NULL DEFAULT 0,
    PRIMARY KEY (dir_id, skill_id)
);

-- 5. Prompt 启用状态快照 (每个 app_type 只存激活的 prompt_id)
CREATE TABLE IF NOT EXISTS dir_prompt_state (
    dir_id TEXT NOT NULL,
    app_type TEXT NOT NULL,
    prompt_id TEXT NOT NULL,
    PRIMARY KEY (dir_id, app_type)
);

fn migrate_v8_to_v9(conn: &Connection) -> Result<(), AppError> {
    // 创建 5 张表（使用 IF NOT EXISTS，幂等）
    // ...
    // 插入 __default__ 虚拟目录，代表"全局默认"状态
    conn.execute(
        "INSERT OR IGNORE INTO working_directories (id, path, name, is_current, created_at) \
         VALUES ('__default__', '__default__', NULL, 0, ?1)",
        [crate::database::get_unix_timestamp()?],
    )?;
    Ok(())
}

// ═══ 工作目录 CRUD ═══
pub fn list_working_directories(&self) -> Result<Vec<WorkingDirectory>, AppError>
pub fn add_working_directory(&self, id: &str, path: &str, name: Option<&str>) -> Result<(), AppError>
pub fn delete_working_directory(&self, id: &str) -> Result<(), AppError>
pub fn rename_working_directory(&self, id: &str, name: &str) -> Result<(), AppError>
pub fn get_current_working_directory(&self) -> Result<Option<WorkingDirectory>, AppError>

// 使用 _on_conn 变体，在 Service 层的事务中调用
fn set_current_working_directory_on_conn(conn: &Connection, id: &str) -> Result<(), AppError>

// ═══ 快照写入 ═══ (都有 _on_conn 变体)
fn snapshot_providers_on_conn(conn: &Connection, dir_id: &str) -> Result<(), AppError>
fn snapshot_mcp_on_conn(conn: &Connection, dir_id: &str) -> Result<(), AppError>
fn snapshot_skills_on_conn(conn: &Connection, dir_id: &str) -> Result<(), AppError>
fn snapshot_prompts_on_conn(conn: &Connection, dir_id: &str) -> Result<(), AppError>

// ═══ 快照恢复 ═══ (都有 _on_conn 变体, 返回 bool = 是否有快照)
fn apply_provider_snapshot_on_conn(conn: &Connection, dir_id: &str) -> Result<bool, AppError>
fn apply_mcp_snapshot_on_conn(conn: &Connection, dir_id: &str) -> Result<bool, AppError>
fn apply_skill_snapshot_on_conn(conn: &Connection, dir_id: &str) -> Result<bool, AppError>
fn apply_prompt_snapshot_on_conn(conn: &Connection, dir_id: &str) -> Result<bool, AppError>

-- 先清除旧快照
DELETE FROM dir_provider_state WHERE dir_id = ?1;
-- 从主表复制当前状态
INSERT INTO dir_provider_state (dir_id, app_type, provider_id, is_current, in_failover_queue)
SELECT ?1, app_type, id, is_current, in_failover_queue
FROM providers
WHERE is_current = 1 OR in_failover_queue = 1;

-- 检查是否有快照
SELECT COUNT(*) FROM dir_provider_state WHERE dir_id = ?1;  -- 如果 0，返回 false

-- 在事务中：先清除主表所有 is_current 和 in_failover_queue
UPDATE providers SET is_current = 0;
UPDATE providers SET in_failover_queue = 0;

-- 从快照恢复
UPDATE providers SET is_current = 1
WHERE (id, app_type) IN (SELECT provider_id, app_type FROM dir_provider_state WHERE dir_id = ?1 AND is_current = 1);

UPDATE providers SET in_failover_queue = 1
WHERE (id, app_type) IN (SELECT provider_id, app_type FROM dir_provider_state WHERE dir_id = ?1 AND in_failover_queue = 1);

DELETE FROM dir_mcp_state WHERE dir_id = ?1;
INSERT INTO dir_mcp_state (dir_id, mcp_id, enabled_claude, enabled_codex, enabled_gemini, enabled_opencode)
SELECT ?1, id, enabled_claude, enabled_codex, enabled_gemini, enabled_opencode
FROM mcp_servers;

-- 先全部禁用
UPDATE mcp_servers SET enabled_claude = 0, enabled_codex = 0, enabled_gemini = 0, enabled_opencode = 0;

-- 从快照恢复
UPDATE mcp_servers SET
    enabled_claude = (SELECT enabled_claude FROM dir_mcp_state WHERE dir_id = ?1 AND mcp_id = mcp_servers.id),
    enabled_codex  = (SELECT enabled_codex  FROM dir_mcp_state WHERE dir_id = ?1 AND mcp_id = mcp_servers.id),
    enabled_gemini = (SELECT enabled_gemini FROM dir_mcp_state WHERE dir_id = ?1 AND mcp_id = mcp_servers.id),
    enabled_opencode = (SELECT enabled_opencode FROM dir_mcp_state WHERE dir_id = ?1 AND mcp_id = mcp_servers.id)
WHERE id IN (SELECT mcp_id FROM dir_mcp_state WHERE dir_id = ?1);

use crate::store::AppState;
use crate::error::AppError;
use crate::database::lock_conn;
use crate::app_config::AppType;
use crate::services::{McpService, ProviderService, SkillService};
use crate::config::write_text_file;
use crate::prompt_files::prompt_file_path;

pub struct WorkingDirService;

impl WorkingDirService {
    /// 核心切换逻辑
    pub fn switch(state: &AppState, target_dir_id: &str) -> Result<(), AppError> {
        // ═══ 前置检查 ═══
        // 1. 检查代理接管状态，若活跃则拒绝切换
        //    使用 db.is_live_takeover_active() 或同步检查 proxy_config.live_takeover_active
        //    （因为 ProxyService::is_running() 是 async，而此函数是 sync）
        Self::check_proxy_not_active(state)?;

        // ═══ Phase 1: 回填 Prompt ═══
        // 在 snapshot 之前，将 live 文件内容回填到当前 enabled prompt
        // 这样即使用户手动编辑了 live 文件，内容也不会丢失
        Self::backfill_prompt_content(state)?;

        // ═══ Phase 2: 数据库操作（事务） ═══
        {
            let conn = lock_conn!(state.db.conn);
            conn.execute("BEGIN IMMEDIATE", [])?;

            let result = (|| -> Result<(), AppError> {
                // 获取当前工作目录
                let current = Self::get_current_dir_id_on_conn(&conn)?;

                // 保存当前状态到旧目录
                if let Some(old_id) = &current {
                    Database::snapshot_providers_on_conn(&conn, old_id)?;
                    Database::snapshot_mcp_on_conn(&conn, old_id)?;
                    Database::snapshot_skills_on_conn(&conn, old_id)?;
                    Database::snapshot_prompts_on_conn(&conn, old_id)?;
                } else {
                    // 无当前目录 = 全局模式，保存到 __default__
                    Database::snapshot_providers_on_conn(&conn, "__default__")?;
                    Database::snapshot_mcp_on_conn(&conn, "__default__")?;
                    Database::snapshot_skills_on_conn(&conn, "__default__")?;
                    Database::snapshot_prompts_on_conn(&conn, "__default__")?;
                }

                // 加载目标目录快照（如果有的话）
                // 如果无快照（首次进入），保持主表不变
                Database::apply_provider_snapshot_on_conn(&conn, target_dir_id)?;
                Database::apply_mcp_snapshot_on_conn(&conn, target_dir_id)?;
                Database::apply_skill_snapshot_on_conn(&conn, target_dir_id)?;
                Database::apply_prompt_snapshot_on_conn(&conn, target_dir_id)?;

                // 更新 is_current 标记
                Database::set_current_working_directory_on_conn(&conn, target_dir_id)?;

                Ok(())
            })();

            match result {
                Ok(()) => conn.execute("COMMIT", [])?,
                Err(e) => {
                    let _ = conn.execute("ROLLBACK", []);
                    return Err(e);
                }
            };
        }
        // conn 锁在此处释放

        // ═══ Phase 3: 同步 live 配置文件 ═══
        Self::sync_all_live(state)?;

        // ═══ Phase 4: 清除 Provider Health ═══
        state.db.clear_all_provider_health()?;

        Ok(())
    }

    /// 回填 live prompt 文件内容到 DB（切换前调用）
    fn backfill_prompt_content(state: &AppState) -> Result<(), AppError> {
        for app in AppType::all() {
            let path = prompt_file_path(&app)?;
            if !path.exists() { continue; }
            let live_content = std::fs::read_to_string(&path).unwrap_or_default();
            if live_content.trim().is_empty() { continue; }

            let mut prompts = state.db.get_prompts(app.as_str())?;
            if let Some((_, prompt)) = prompts.iter_mut().find(|(_, p)| p.enabled) {
                prompt.content = live_content;
                prompt.updated_at = Some(get_unix_timestamp()?);
                state.db.save_prompt(app.as_str(), prompt)?;
            }
        }
        Ok(())
    }

    /// 将 DB 中的 enabled prompt 内容写入 live 文件（切换后调用）
    /// 注意：不做回填！只写入。区别于 PromptService::enable_prompt()
    fn write_prompts_to_live(state: &AppState) -> Result<(), AppError> {
        for app in AppType::all() {
            let path = prompt_file_path(&app)?;
            let prompts = state.db.get_prompts(app.as_str())?;
            if let Some(prompt) = prompts.values().find(|p| p.enabled) {
                write_text_file(&path, &prompt.content)?;
            }
            // 无 enabled prompt 时不清空文件（保留现状）
        }
        Ok(())
    }

    /// 同步所有 live 配置（Provider + MCP + Skill + Prompt）
    fn sync_all_live(state: &AppState) -> Result<(), AppError> {
        // 1. Provider → live files
        ProviderService::sync_current_to_live(state)?;
        // sync_current_to_live 内部已调用 McpService::sync_all_enabled()

        // 2. Skills → app dirs (循环每个 app)
        for app in AppType::all() {
            let _ = SkillService::sync_to_app(&state.db, &app);
        }

        // 3. Prompts → live files
        Self::write_prompts_to_live(state)?;

        Ok(())
    }

    /// 检查代理是否活跃（同步检查数据库标志）
    fn check_proxy_not_active(state: &AppState) -> Result<(), AppError> {
        // 检查 proxy_config 表中 live_takeover_active 列
        // 如果有任何 app 的 live_takeover_active = 1，拒绝切换
        let conn = lock_conn!(state.db.conn);
        let active: bool = conn.query_row(
            "SELECT EXISTS(SELECT 1 FROM proxy_config WHERE live_takeover_active = 1)",
            [], |r| r.get(0)
        ).unwrap_or(false);

        if active {
            return Err(AppError::Message(
                "代理接管模式运行中，请先停止代理再切换工作目录".into()
            ));
        }
        Ok(())
    }
}

#[tauri::command]
pub fn list_working_directories(state: State<'_, AppState>) -> Result<Vec<WorkingDirectory>, String>

#[tauri::command]
pub fn add_working_directory(state: State<'_, AppState>, path: String, name: Option<String>) -> Result<WorkingDirectory, String>

#[tauri::command]
pub fn delete_working_directory(state: State<'_, AppState>, id: String) -> Result<(), String>

#[tauri::command]
pub fn rename_working_directory(state: State<'_, AppState>, id: String, name: String) -> Result<(), String>

#[tauri::command]
pub fn switch_working_directory(state: State<'_, AppState>, id: String) -> Result<(), String>
// 调用 WorkingDirService::switch()

#[tauri::command]
pub fn get_current_working_directory(state: State<'_, AppState>) -> Result<Option<WorkingDirectory>, String>

/// 清除所有 provider_health 记录（切换目录时调用）
pub fn clear_all_provider_health(&self) -> Result<(), AppError>

import { invoke } from "@tauri-apps/api/core";

export interface WorkingDirectory {
  id: string;
  path: string;
  name?: string;
  isCurrent: boolean;
  createdAt: number;
}

export const workingDirApi = {
  list: () => invoke<WorkingDirectory[]>("list_working_directories"),
  add: (path: string, name?: string) =>
    invoke<WorkingDirectory>("add_working_directory", { path, name }),
  delete: (id: string) => invoke<void>("delete_working_directory", { id }),
  rename: (id: string, name: string) =>
    invoke<void>("rename_working_directory", { id, name }),
  switch: (id: string) => invoke<void>("switch_working_directory", { id }),
  getCurrent: () =>
    invoke<WorkingDirectory | null>("get_current_working_directory"),
};

// 需要验证实际的 queryKey 名称
queryClient.invalidateQueries({ queryKey: ["providers"] });
queryClient.invalidateQueries({ queryKey: ["mcp-servers"] });
queryClient.invalidateQueries({ queryKey: ["installed-skills"] });
queryClient.invalidateQueries({ queryKey: ["prompts"] });
queryClient.invalidateQueries({ queryKey: ["workingDirectories"] });

用户选择目录 B
    │
    ├── 1. check_proxy_not_active()
    │       → 如果代理接管中，返回错误，终止
    │
    ├── 2. backfill_prompt_content()
    │       → 读 live prompt 文件 → 更新 DB 中已启用 prompt 的 content
    │       → 保护用户手动编辑的 prompt 不丢失
    │
    ├── 3. BEGIN TRANSACTION
    │   ├── snapshot(old_dir / __default__)
    │   │   ├── providers → dir_provider_state (is_current + in_failover_queue)
    │   │   ├── mcp_servers → dir_mcp_state (4 列直接复制)
    │   │   ├── skills → dir_skill_state (4 列直接复制)
    │   │   └── prompts → dir_prompt_state (enabled prompt_id)
    │   │
    │   ├── apply(target_dir)
    │   │   ├── dir_provider_state → providers
    │   │   ├── dir_mcp_state → mcp_servers
    │   │   ├── dir_skill_state → skills
    │   │   └── dir_prompt_state → prompts
    │   │
    │   └── set_current_working_directory(target_dir)
    │
    ├── COMMIT
    │
    ├── 4. sync_all_live()
    │   ├── ProviderService::sync_current_to_live(state)
    │   │   └── 内部已调用 McpService::sync_all_enabled()
    │   ├── for app in AppType::all() { SkillService::sync_to_app(&db, &app) }
    │   └── write_prompts_to_live() ← 无回填，直接写
    │
    └── 5. clear_all_provider_health()
            → 清除运行时熔断器状态