//! Computer Agent Runner 聊天处理器
//!
//! 处理 Computer Agent Runner 模式的聊天请求。
//! 与 RCoder 的 project_id 容器模式不同，ComputerAgentRunner 使用 user_id 作为容器标识。
//!
//! ## 请求流程
//! ```text
//! POST /computer/chat { user_id, project_id?, prompt, ... }
//!     ↓
//! 1. 验证 user_id
//! 2. 生成 project_id（若未提供）
//! 3. get_or_create_container_for_user(user_id)
//!    - 挂载配置: config.yml mounts (配置化管理)
//!    - 宿主机: /computer-project-workspace/{user_id} → 容器: /home/user
//! 4. 创建项目工作目录: /home/user/{project_id} (通过挂载自动同步)
//! 5. 创建/更新项目和会话信息
//! 6. gRPC Chat RPC → agent_runner (带 project_id)
//! 7. 更新会话映射
//! 8. 返回 ChatResponse
//! ```
//!
//! 注意：Resume 会话的降级逻辑已在 agent_runner 层通过 list_sessions API 预检查处理

use axum::{extract::State, http::HeaderMap};
use shared_types::{ChatResponse, ComputerChatRequest, IsolationType};
use std::sync::Arc;
use tracing::{debug, error, info, instrument, warn};

use crate::{AppError, HttpResult, router::AppState, service::ComputerContainerManager};
use docker_manager::ContainerBasicInfo;

use super::utils::{
    I18nJsonOrQuery, extract_grpc_addr_with_port, get_locale_from_headers,
    get_realtime_container_ip, project_dir, build_computer_workspace_path,
};

/// 处理 Computer Agent 聊天请求
///
/// 1. 根据 user_id 获取或创建用户容器
/// 2. 将聊天请求转发到容器内的 agent_runner 服务
/// 3. 更新会话映射
///
/// 注意：
/// - user_id 是必填的，用于标识用户的容器
/// - project_id 可选，若未提供则自动生成
/// - 一个用户容器内可以运行多个 project_id 的 Agent 实例
/// - Resume 会话的降级逻辑已在 agent_runner 层通过 list_sessions API 预检查处理
#[utoipa::path(
    post,
    path = "/computer/chat",
    request_body(
        content = ComputerChatRequest,
        description = "Computer Agent 聊天请求，包含 user_id 和 prompt",
        content_type = "application/json"
    ),
    responses(
        (
            status = 200,
            description = "成功处理聊天请求",
            body = HttpResult<ChatResponse>,
            example = json!({
                "success": true,
                "data": {
                    "project_id": "proj_456",
                    "session_id": "session789",
                    "error": null,
                    "request_id": "req_123456789"
                },
                "error": null
            })
        ),
        (
            status = 400,
            description = "请求参数错误（如 user_id 为空）",
            body = HttpResult<String>
        ),
        (
            status = 401,
            description = "API Key 鉴权失败",
            body = HttpResult<String>
        ),
        (
            status = 500,
            description = "服务器内部错误",
            body = HttpResult<String>
        )
    ),
    tag = "computer",
    operation_id = "handle_computer_chat",
    summary = "发送聊天消息到 Computer Agent",
    description = "根据 user_id 动态管理容器，一个用户对应一个带桌面环境的容器"
)]
#[instrument(skip(state, request), fields(user_id = %request.user_id, project_id = ?request.project_id))]
pub async fn handle_computer_chat(
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
    I18nJsonOrQuery(mut request): I18nJsonOrQuery<ComputerChatRequest>,
) -> Result<HttpResult<ChatResponse>, AppError> {
    // 获取语言设置
    let locale = get_locale_from_headers(&headers);

    // 1. 验证 user_id
    if request.user_id.trim().is_empty() {
        error!("[COMPUTER_CHAT] user_id is required");
        return Ok(HttpResult::error_with_locale(
            shared_types::error_codes::ERR_VALIDATION,
            locale,
        ));
    }

    let user_id = request.user_id.clone();

    // ========== 隔离类型参数校验 ==========
    // IF pod_id IS NOT NULL THEN isolation_type, tenant_id, space_id 必须非空
    if request.pod_id.is_some() {
        if request.isolation_type.is_none() {
            error!("[COMPUTER_CHAT] Validation failed: isolation_type is required when pod_id is provided");
            return Ok(HttpResult::error_with_message(
                shared_types::error_codes::ERR_VALIDATION,
                locale,
                "isolation_type is required when pod_id is provided",
            ));
        }
        if request.tenant_id.is_none() {
            error!("[COMPUTER_CHAT] Validation failed: tenant_id is required when pod_id is provided");
            return Ok(HttpResult::error_with_message(
                shared_types::error_codes::ERR_VALIDATION,
                locale,
                "tenant_id is required when pod_id is provided",
            ));
        }
        if request.space_id.is_none() {
            error!("[COMPUTER_CHAT] Validation failed: space_id is required when pod_id is provided");
            return Ok(HttpResult::error_with_message(
                shared_types::error_codes::ERR_VALIDATION,
                locale,
                "space_id is required when pod_id is provided",
            ));
        }

        // 验证 isolation_type 值有效（大小写不敏感）
        if let Some(ref it) = request.isolation_type {
            if IsolationType::from_str(it).is_err() {
                error!("[COMPUTER_CHAT] Validation failed: invalid isolation_type '{}', expected tenant|space|project", it);
                return Ok(HttpResult::error_with_message(
                    shared_types::error_codes::ERR_VALIDATION,
                    locale,
                    &format!("invalid isolation_type '{}', expected: tenant, space, project", it),
                ));
            }
        }

        // 记录验证通过的参数（此时 pod_id, isolation_type, tenant_id, space_id 必定为 Some）
        if let (Some(pid), Some(it), Some(tid), Some(sid)) = (
            request.pod_id.as_deref(),
            request.isolation_type.as_deref(),
            request.tenant_id.as_deref(),
            request.space_id.as_deref(),
        ) {
            info!(
                "🔒 [COMPUTER_CHAT] Isolation parameters validated: pod_id={}, isolation_type={}, tenant_id={}, space_id={}",
                pid, it, tid, sid
            );
        }
    }

    // 2. 生成或使用提供的 project_id
    let project_id = match &request.project_id {
        Some(id) if !id.trim().is_empty() => id.clone(),
        _ => {
            let generated_id = crate::service::container_manager::generate_project_id();
            request.project_id = Some(generated_id.clone());
            generated_id
        }
    };

    info!(
        "🚀 [COMPUTER_CHAT] Starting to process request: user_id={}, project_id={}, session_id={:?}, prompt_len={}, attachments={}, model_provider={:?}, agent_config={:?}",
        user_id,
        project_id,
        request.session_id,
        request.prompt.len(),
        request.attachments.len(),
        request.model_provider,
        request.agent_config
    );

    // 3. 验证资源限制配置
    if let Some(ref agent_config) = request.agent_config {
        if let Some(ref resource_limits) = agent_config.resource_limits {
            if let Err(e) = resource_limits.validate() {
                error!("[COMPUTER_CHAT] Resource limits validation failed: {}", e);
                return Ok(HttpResult::error_with_locale(
                    shared_types::error_codes::ERR_INVALID_RESOURCE_LIMITS,
                    locale,
                ));
            }
        }
    }

    // 4. === 并发保护：检查是否有其他请求正在创建同一用户的容器 ===
    // 使用原子标记（DashMap）避免并发请求互相干扰，无死锁风险
    let mut waited_container_info: Option<ContainerBasicInfo> = None;
    if let Some(creating_since) = state.pod_creating.get(&user_id) {
        let elapsed = creating_since.elapsed();
        drop(creating_since); // 释放 DashMap ref

        // 标记超过 60 秒视为过期（创建方可能已崩溃），忽略并继续
        if elapsed < std::time::Duration::from_secs(60) {
            info!(
                "⏳ [COMPUTER_CHAT] Container is being created, waiting for completion: user_id={}, elapsed={:?}",
                user_id, elapsed
            );

            // 轮询等待容器就绪（最多等 30 秒，每秒检查一次）
            for wait_sec in 1..=30 {
                tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

                // 标记已被移除 = 创建完成
                if !state.pod_creating.contains_key(&user_id) {
                    // 尝试获取容器信息
                    if let Ok(runtime) = docker_manager::runtime::RuntimeManager::get().await
                    {
                        if let Ok(Some(info)) = runtime
                            .get_container_info_by_identifier(
                                &user_id,
                                &shared_types::ServiceType::ComputerAgentRunner,
                            )
                            .await
                        {
                            info!(
                                "✅ [COMPUTER_CHAT] Wait successful, container is ready (waited {}s): user_id={}, container_id={}",
                                wait_sec, user_id, info.container_id
                            );
                            waited_container_info = Some(info);
                            break;
                        }
                    }
                }

                if wait_sec % 5 == 0 {
                    debug!(
                        "[COMPUTER_CHAT] Still waiting for container creation: user_id={}, {}s elapsed",
                        user_id, wait_sec
                    );
                }
            }

            if waited_container_info.is_none() {
                // 等待超时，继续正常的创建流程（此时标记可能已过期被清理）
                warn!(
                    "⚠️ [COMPUTER_CHAT] Wait for container creation timeout (30s), will try to create: user_id={}",
                    user_id
                );
            }
        } else {
            // 标记过期，清理后继续
            warn!(
                "⚠️ [COMPUTER_CHAT] Creation marker expired ({:?}), cleaning up and continuing",
                elapsed
            );
            state.pod_creating.remove(&user_id);
        }
    }

    // 5. 获取或创建用户容器
    let container_info = if let Some(info) = waited_container_info {
        // 使用等待获得的容器信息
        info!(
            "📦 [COMPUTER_CHAT] Using ready container (waiting for other request to finish creation): user_id={}, container_id={}",
            user_id, info.container_id
        );
        info
    } else {
        // 正常创建容器 - 设置标记防止并发
        state
            .pod_creating
            .insert(user_id.clone(), std::time::Instant::now());

        let result = ComputerContainerManager::get_or_create_container_for_user(
            &user_id,
            request
                .agent_config
                .as_ref()
                .and_then(|c| c.resource_limits.clone()),
            request.pod_id.as_deref(),
            request.isolation_type.as_deref(),
            request.tenant_id.as_deref(),
            request.space_id.as_deref(),
        )
        .await;

        // 清除标记（无论成功还是失败）
        state.pod_creating.remove(&user_id);

        match result {
            Ok(info) => info,
            Err(e) => {
                error!("[COMPUTER_CHAT] Failed to get or create container: {}", e);
                return Ok(HttpResult::error_with_locale(
                    shared_types::error_codes::ERR_CONTAINER_ERROR,
                    locale,
                ));
            }
        }
    };

    // 🛡️ 二次验证：确保容器 IP 非空
    // 容器管理器应该已经处理了空 IP 的情况，但缓存/Docker API 可能返回不一致结果
    // 如果 IP 为空，先清理旧容器再强制重建（不返回错误给客户端）
    let container_info = if container_info.container_ip.trim().is_empty() {
        warn!(
            "⚠️ [COMPUTER_CHAT] Container has empty IP after get_or_create, cleaning up and recreating: \
             user_id={}, old_container_id={}",
            user_id, container_info.container_id
        );
        // 必须先清理旧容器，否则 create_container 发现同名 "running" 容器会复用它
        let container_identifier = request.pod_id.as_deref().unwrap_or(&user_id);
        if let Ok(runtime) = docker_manager::runtime::RuntimeManager::get().await {
            if let Err(e) = runtime
                .stop_container_by_identifier(
                    container_identifier,
                    &shared_types::ServiceType::ComputerAgentRunner,
                )
                .await
            {
                warn!(
                    "⚠️ [COMPUTER_CHAT] Failed to cleanup broken container before recreate: {}",
                    e
                );
            }
        }
        ComputerContainerManager::force_create_container_for_user(
            &user_id,
            request
                .agent_config
                .as_ref()
                .and_then(|c| c.resource_limits.clone()),
            request.pod_id.as_deref(),
            request.isolation_type.as_deref(),
            request.tenant_id.as_deref(),
            request.space_id.as_deref(),
        )
        .await
        .map_err(|e| {
            error!("[COMPUTER_CHAT] Force recreate container failed: {}", e);
            AppError::with_message(
                shared_types::error_codes::ERR_CONTAINER_ERROR,
                format!("Container recreation failed: {}", e),
            )
        })?
    } else {
        container_info
    };

    info!(
        "✅ [COMPUTER_CHAT] Container ready: user_id={}, container_id={}, ip={}",
        user_id, container_info.container_id, container_info.container_ip
    );

    // 🔍 检测 user_id 变化：同一个 project_id 被不同的 user_id 请求
    // 这通常意味着负载测试脚本使用了多个不同的 user_id，会导致创建多个容器浪费资源
    if let Some(existing_info) = state.get_project(&project_id) {
        if let Some(existing_user_id) = existing_info.user_id() {
            if existing_user_id != user_id {
                warn!(
                    "⚠️ [USER_ID_MISMATCH] Detected user_id change for project_id: \
                     project_id={}, original user_id={}, new user_id={}, time={}. \
                     This may be caused by load test scripts using different user_ids, \
                     which creates multiple containers and wastes resources. \
                     Please ensure the same project_id uses the same user_id in your test scripts.",
                    project_id,
                    existing_user_id,
                    user_id,
                    chrono::Utc::now().to_rfc3339()
                );
            }
        }
    }

    // 🛡️ 关键修复：容器创建成功后立即插入 DuckDB 记录
    // 这样可以防止孤立容器清理器误判并清理刚创建的容器
    //
    // 必须在 gRPC 请求之前就插入记录，因为：
    // 1. 孤立容器清理器会检查 DuckDB 中是否存在该 user_id 的记录
    // 2. 如果记录不存在，容器会被判定为孤立并清理
    // 3. gRPC 请求是异步的，可能需要较长时间才能返回
    ensure_project_mapping_in_state(&state, &user_id, &project_id, &container_info, &request)?;

    // 请求到达时立即更新活动时间（不等待请求执行结果）
    // 这样可以防止在 gRPC 请求期间被 cleanup_task 误清理
    // 注意：这里使用 project_id 而不是 user_id，因为 DuckDB 的 key 是 project_id
    state.update_activity(&project_id);
    debug!(
        "🔄 [COMPUTER_CHAT] Updated activity time: project_id={}",
        project_id
    );

    // 5. 创建项目工作目录（在用户容器内）
    // Computer Agent Runner 需要在用户工作区内为 project_id 创建子目录
    if let Err(e) = ensure_project_workspace_exists(
        request.isolation_type.as_deref(),
        request.tenant_id.as_deref(),
        request.space_id.as_deref(),
        &user_id,
        &project_id,
    )
    .await {
        error!("[COMPUTER_CHAT] Failed to create project workspace: {}", e);
        return Ok(HttpResult::error_with_locale(
            shared_types::error_codes::ERR_WORKSPACE_ERROR,
            locale,
        ));
    }

    // 6. 注册 VNC 后端到 Pingora（用于 WebSocket 代理）
    if let Some(ref pingora_service) = state.pingora_service {
        pingora_service.add_vnc_backend(&user_id, &container_info.container_ip);
        debug!(
            "🔗 [COMPUTER_CHAT] VNC backend registered: user_id={} -> {}",
            user_id, container_info.container_ip
        );
    }

    // 6.5. 🆕 主动查询 Agent 状态 (User Request)
    // 在转发请求前，主动查询 Agent 状态，确保状态是最新的。
    // 这有助于在容器重启后，确认 Agent 是否真正处于空闲状态。
    {
        // 💫 使用实时 IP 获取，避免 restart 后 IP 过期的问题
        let grpc_addr_result = async {
            let container_ip = get_realtime_container_ip(
                &container_info.container_name,
                &container_info.container_ip,
                &state.container_prefix_rcoder,
                &state.container_prefix_computer,
            )
            .await
            .map_err(|e| format!("IP resolution error: {}", e))?;

            Ok::<_, String>(format!(
                "{}:{}",
                container_ip,
                shared_types::GRPC_DEFAULT_PORT
            ))
        }
        .await;

        if let Ok(grpc_addr) = grpc_addr_result {
            debug!("[COMPUTER_CHAT] Checking Agent status: {}", grpc_addr);
            if let Ok(mut client) = state.grpc_pool.get_client(&grpc_addr).await {
                let status_req = shared_types::grpc::GetStatusRequest {
                    project_id: project_id.clone(),
                    session_id: "".to_string(), // 我们只关心 project 级别的状态
                };

                let mut grpc_request = crate::grpc::new_request_with_locale(status_req, locale);
                grpc_request.set_timeout(std::time::Duration::from_secs(5));

                match client.get_status(grpc_request).await {
                    Ok(resp) => {
                        let status = resp.into_inner().status;
                        info!(
                            "📊 [COMPUTER_CHAT] Agent current status: project_id={}, status={}",
                            project_id, status
                        );
                        // 如果状态是 idle，我们可以更有信心地继续
                    }
                    Err(e) => {
                        warn!("[COMPUTER_CHAT] Failed to get Agent status: {}", e);
                        // Query failed不阻止请求继续，可能是网络波动，让后续的 Chat 请求去处理
                    }
                }
            }
        }
    }

    // 7. 🆕 自动查找 session_id 逻辑
    // 如果用户没有传递 session_id，尝试从状态中查找最新的 session_id
    let session_id_to_use = match &request.session_id {
        Some(sid) if !sid.is_empty() => {
            debug!("[COMPUTER_CHAT] Using session_id: {}", sid);
            sid.clone()
        }
        _ => {
            // 用户没有传递 session_id，尝试查找最新的
            match state.get_project(&project_id) {
                Some(project_info) => {
                    let existing_session_id = project_info.session_id();
                    match existing_session_id {
                        Some(sid) if !sid.is_empty() => {
                            info!(
                                "🔄 [COMPUTER_CHAT] No session_id provided, auto using latest session: project_id={}, session_id={}",
                                project_id, sid
                            );
                            sid.to_string()
                        }
                        _ => {
                            debug!(
                                "[COMPUTER_CHAT] Project exists, creating new session"
                            );
                            String::new()
                        }
                    }
                }
                None => {
                    debug!("[COMPUTER_CHAT] No project, creating new session");
                    String::new()
                }
            }
        }
    };

    // 克隆 request 并修改 session_id
    let mut request_for_forward = request.clone();
    request_for_forward.session_id = if session_id_to_use.is_empty() {
        None
    } else {
        Some(session_id_to_use)
    };
    // 🆕 自动查找 session_id 逻辑结束

    // 8. 转发请求到容器服务（使用 gRPC）
    let result = forward_computer_request_to_container(
        &request_for_forward, // 使用修改后的 request
        &project_id,
        &container_info,
        &state.grpc_pool,
        locale,
        &state.container_prefix_rcoder,
        &state.container_prefix_computer,
    )
    .await;

    // 8. 更新会话映射（填充所有三个映射表，保持一致性）
    // 无论请求成功还是失败，只要响应中包含 session_id，都要更新映射
    // 这样用户可以通过 SSE 接口获取错误通知，而不会收到 SESSION_EXPIRED 错误
    if let Some(chat_response) = &result.data {
        let session_id = chat_response.session_id.clone();

        // 只有当 session_id 非空时才更新映射
        if !session_id.is_empty() {
            info!(
                "🔗 [COMPUTER_CHAT] Associated session: session_id={} -> user_id={}, project_id={}, success={}",
                session_id,
                user_id,
                project_id,
                result.is_success()
            );

            // 从 Runtime API 获取最新容器信息，避免使用过期 IP
            let runtime = docker_manager::runtime::RuntimeManager::get()
                .await
                .map_err(|e| {
                    error!("[COMPUTER_CHAT] Failed to get runtime: {}", e);
                    AppError::internal_server_error(&format!("Failed to get runtime: {}", e))
                })?;

            let container_info = match runtime
                .get_container_info_by_identifier(
                    &user_id,
                    &shared_types::ServiceType::ComputerAgentRunner,
                )
                .await
            {
                Ok(Some(info)) => {
                    info!(
                        "🔄 [COMPUTER_CHAT] Getting latest container info from Runtime API: user_id={}, container_id={}, container_ip={}",
                        user_id, info.container_id, info.container_ip
                    );
                    info
                }
                Ok(None) => {
                    warn!(
                        "⚠️ [COMPUTER_CHAT] Container not found in runtime: user_id={}, using cached container info",
                        user_id
                    );
                    // 使用之前获取的容器信息
                    container_info.clone()
                }
                Err(e) => {
                    warn!(
                        "⚠️ [COMPUTER_CHAT] Failed to get container info from runtime: user_id={}, error={}, using cached container info",
                        user_id, e
                    );
                    // 使用之前获取的容器信息
                    container_info.clone()
                }
            };

            // ComputerAgentRunner 模式：每个 project 独立记录
            // 使用真正的 project_id 作为 map_key，user_id 存储在数据字段中
            let map_key = project_id.clone();

            // 检查是否已存在该 project_id 的记录
            if let Some(existing_info) = state.get_project(&map_key) {
                // 已存在：更新信息
                let mut updated_info = (*existing_info).clone();

                // 更新活动时间
                updated_info.update_activity();
                updated_info.update_session(session_id.clone());

                // 更新扩展信息
                updated_info.update_extended_from_request(
                    Some(container_info.clone()),
                    request.model_provider.clone(),
                    request.request_id.clone(),
                    Some(shared_types::ServiceType::ComputerAgentRunner),
                );

                state.insert_project(map_key.clone(), Arc::new(updated_info));

                // 更新会话映射
                state.update_session(&map_key, &session_id);

                info!(
                    "🔄 [COMPUTER_CHAT] Updated existing container mapping: user_id={}, project_id={}, session_id={} (last_activity refreshed)",
                    user_id, project_id, session_id
                );
            } else {
                // 不存在：创建新的 ProjectAndContainerInfo
                let mut project_info = shared_types::ProjectAndContainerInfo::new(map_key.clone());

                // 设置 user_id（ComputerAgentRunner 模式）
                project_info.set_user_id(Some(user_id.clone()));
                // 设置 pod_id（共享容器模式）
                project_info.set_pod_id(request.pod_id.clone());

                // 更新会话ID
                project_info.update_session(session_id.clone());

                // 更新扩展信息（容器、模型配置等）
                project_info.update_extended_from_request(
                    Some(container_info.clone()),
                    request.model_provider.clone(),
                    request.request_id.clone(),
                    Some(shared_types::ServiceType::ComputerAgentRunner),
                );

                state.insert_project(map_key.clone(), Arc::new(project_info));

                // 更新会话映射
                state.update_session(&map_key, &session_id);

                info!(
                    "🆕 [COMPUTER_CHAT] Created new container mapping: user_id={}, project_id={}, session_id={}",
                    user_id, project_id, session_id
                );
            }

            if result.is_success() {
                info!(
                    "✅ [COMPUTER_CHAT] Request processed: user_id={}, project_id={}, session_id={} (all mappings updated)",
                    user_id, project_id, session_id
                );
            } else {
                warn!(
                    "⚠️ [COMPUTER_CHAT] Request failed but session mapping saved: user_id={}, project_id={}, session_id={}, code={}, message={}",
                    user_id, project_id, session_id, result.code, result.message
                );
            }
        }
    }

    if !result.is_success()
        && result
            .data
            .as_ref()
            .map_or(true, |d| d.session_id.is_empty())
    {
        error!(
            "❌ [COMPUTER_CHAT] Container service returned error (no session_id): user_id={}, project_id={}, code={}, message={}",
            user_id, project_id, result.code, result.message
        );
    }

    Ok(result)
}

/// 转发请求到容器内的 agent_runner 服务（仅使用 gRPC）
///
/// 与 RCoder 的 forward_request_to_container_service 类似，
/// 但专门用于 ComputerAgentRunner 模式。
async fn forward_computer_request_to_container(
    request: &ComputerChatRequest,
    project_id: &str,
    container_info: &ContainerBasicInfo,
    grpc_pool: &Arc<crate::grpc::GrpcChannelPool>,
    locale: &'static str,
    rcoder_prefix: &str,
    computer_prefix: &str,
) -> HttpResult<ChatResponse> {
    info!(
        "📤 [COMPUTER_FORWARD] Forwarding request to container (gRPC): user_id={}, project_id={}, session_id={:?}, container_id={}",
        request.user_id, project_id, request.session_id, container_info.container_id
    );

    // 直接使用 gRPC 的健康检查机制，不额外检查容器状态
    // gRPC 连接失败会自动返回错误，由上层处理

    // 从 service_url 提取 gRPC 地址
    // 🆕 使用实时 IP 获取，避免 restart 后 IP 过期的问题
    let mut grpc_addr = match get_realtime_container_ip(
        &container_info.container_name,
        &container_info.container_ip,
        rcoder_prefix,
        computer_prefix,
    )
    .await
    {
        Ok(ip) => format!("{}:{}", ip, shared_types::GRPC_DEFAULT_PORT),
        Err(e) => {
            warn!(
                "⚠️ [COMPUTER_FORWARD] Real-time IP resolution failed: {}, trying to extract from service_url",
                e
            );
            match extract_grpc_addr_with_port(
                &container_info.service_url,
                shared_types::GRPC_DEFAULT_PORT,
            ) {
                Ok(addr) => addr,
                Err(e) => {
                    error!("[COMPUTER_FORWARD] Failed to extract gRPC address: {}", e);
                    return HttpResult::error_with_locale(
                        shared_types::error_codes::ERR_GRPC_ADDR_ERROR,
                        locale,
                    );
                }
            }
        }
    };

    debug!(
        "📡 [COMPUTER_FORWARD] gRPC address: {}, prompt_len={}, attachments={}",
        grpc_addr,
        request.prompt.len(),
        request.attachments.len()
    );

    // Computer Agent Runner 的工作目录路径
    // 在容器内：/app/computer-project-workspace/{user_id}/{project_id}
    let project_workspace = format!("{}/", project_dir(&request.user_id, &project_id));

    debug!(
        "[COMPUTER_FORWARD] projectworkdirectory: {}",
        project_workspace
    );

    // gRPC 调用（带重试机制）
    let max_retries = 2;
    let mut last_error = None;

    for attempt in 1..=max_retries {
        match crate::grpc::grpc_chat_with_pool(
            grpc_pool,
            &grpc_addr,
            project_id.to_string(),
            request.session_id.clone(),
            request.prompt.clone(),
            request.attachments.clone(),
            request.data_source_attachments.clone(),
            request.model_provider.clone(),
            request.request_id.clone(),
            Some(std::time::Duration::from_secs(300)), // 5 分钟超时，避免永久阻塞
            request.system_prompt.clone(),
            request.user_prompt.clone(),
            request.agent_config.clone(),
            Some(shared_types::ServiceType::ComputerAgentRunner), // ✅ 传递正确的 ServiceType
            Some(request.user_id.clone()), // ✅ 传递 user_id（ComputerAgentRunner 必需）
        )
        .await
        {
            Ok(grpc_response) => {
                if grpc_response.success {
                    let chat_response = crate::grpc::grpc_response_to_chat_response(grpc_response);
                    info!(
                        "✅ [COMPUTER_FORWARD] gRPC response success: project_id={}, session_id={}",
                        chat_response.project_id, chat_response.session_id
                    );
                    return HttpResult::success(chat_response);
                } else {
                    let error_msg = grpc_response
                        .error
                        .unwrap_or_else(|| "Unknown error".to_string());
                    // 🎯 从 gRPC 响应中提取错误码（完整透传）
                    let error_code = grpc_response
                        .error_code
                        .unwrap_or_else(|| shared_types::error_codes::ERR_AGENT_ERROR.to_string());
                    error!(
                        "❌ [COMPUTER_FORWARD] gRPC response error: code={}, message={}",
                        error_code, error_msg
                    );
                    return HttpResult::error(&error_code, &error_msg);
                }
            }
            Err(e) => {
                warn!(
                    "⚠️ [COMPUTER_FORWARD] gRPC call failed (attempt {}/{}): {}",
                    attempt, max_retries, e
                );

                let should_retry = crate::grpc::should_retry_error(&e);

                if should_retry && attempt < max_retries {
                    info!(
                        "🔄 [COMPUTER_FORWARD] Detected retryable error, re-resolving container IP and retrying..."
                    );
                    grpc_pool.remove(&grpc_addr);

                    // 重新获取最新容器 IP（容器可能已重建，IP 可能变化）
                    match get_realtime_container_ip(
                        &container_info.container_name,
                        &container_info.container_ip,
                        rcoder_prefix,
                        computer_prefix,
                    )
                    .await
                    {
                        Ok(ip) => {
                            let new_addr = format!("{}:{}", ip, shared_types::GRPC_DEFAULT_PORT);
                            info!(
                                "🔄 [COMPUTER_FORWARD] Container IP re-resolved: {} -> {}",
                                grpc_addr, new_addr
                            );
                            grpc_addr = new_addr;
                        }
                        Err(e) => {
                            warn!(
                                "⚠️ [COMPUTER_FORWARD] Failed to re-resolve container IP, keeping old address: {}",
                                e
                            );
                        }
                    }

                    last_error = Some(e);
                    continue;
                } else if !should_retry {
                    error!(
                        "[COMPUTER_FORWARD] Retry error, stopped retry: {}",
                        e
                    );
                    last_error = Some(e);
                    break;
                }

                last_error = Some(e);
            }
        }
    }

    // 所有重试都失败
    if let Some(e) = last_error {
        error!(
            "❌ [COMPUTER_FORWARD] gRPC final call failed: {}, user_id={}, project_id={}",
            e, request.user_id, project_id
        );

        // gRPC 通信失败，直接返回错误
        // 注：业务错误码（如 Agent busy）现在由 agent_runner 通过 grpc_response.error_code 返回
        HttpResult::error_with_locale(shared_types::error_codes::ERR_GRPC_ERROR, locale)
    } else {
        HttpResult::error_with_locale(shared_types::error_codes::ERR_UNKNOWN, locale)
    }
}

/// 确保 project_id 对应的工作目录存在
///
/// Computer Agent Runner 的目录结构：
/// /app/computer-project-workspace/{user_id}/{project_id}/
///
/// 注意：这个目录已经在 docker-compose.yml 中挂载，可以直接在 rcoder 容器内创建
///
/// # 参数
/// - `isolation_type`: 隔离类型（可选）
/// - `tenant_id`: 租户 ID（可选）
/// - `space_id`: 空间 ID（可选）
/// - `user_id`: 用户 ID（当 isolation_type 为 project 时使用）
/// - `project_id`: 项目 ID
async fn ensure_project_workspace_exists(
    isolation_type: Option<&str>,
    tenant_id: Option<&str>,
    space_id: Option<&str>,
    user_id: &str,
    project_id: &str,
) -> Result<(), AppError> {
    // 根据隔离类型构建工作空间路径
    let project_workspace_path = std::path::PathBuf::from(build_computer_workspace_path(
        isolation_type,
        tenant_id,
        space_id,
        user_id,
        project_id,
    ));

    debug!(
        "📁 [COMPUTER_CHAT] Ensuring project workspace directory exists: {:?}",
        project_workspace_path
    );

    // 直接在 rcoder 容器内创建目录
    tokio::fs::create_dir_all(&project_workspace_path)
        .await
        .map_err(|e| {
            error!(
                "❌ [COMPUTER_CHAT] Failed to create project workspace: path={:?}, error={}",
                project_workspace_path, e
            );
            AppError::internal_server_error(&format!("Failed to create project workspace: {}", e))
        })?;

    info!(
        "✅ [COMPUTER_CHAT] Project workspace directory created: user_id={}, project_id={}, isolation_type={:?}, path={:?}",
        user_id, project_id, isolation_type, project_workspace_path
    );

    Ok(())
}

/// 确保 DuckDB 中存在 project_id 到容器的映射
///
/// 🛡️ 关键修复：容器创建成功后立即插入 DuckDB 记录
///
/// 这样可以防止孤立容器清理器误判并清理刚创建的容器，因为：
/// 1. 孤立容器清理器会检查 DuckDB 中是否存在该 user_id 关联的记录
/// 2. 如果记录不存在，容器会被判定为孤立并清理
/// 3. gRPC 请求是异步的，可能需要较长时间才能返回
///
/// # Arguments
/// * `state` - 应用状态
/// * `user_id` - 用户 ID
/// * `project_id` - 项目 ID
/// * `container_info` - 容器信息
/// * `request` - 聊天请求
fn ensure_project_mapping_in_state(
    state: &Arc<crate::router::AppState>,
    user_id: &str,
    project_id: &str,
    container_info: &ContainerBasicInfo,
    request: &ComputerChatRequest,
) -> Result<(), AppError> {
    // 检查是否已存在该 project_id 的记录
    if let Some(existing_project) = state.get_project(project_id) {
        // 如果记录存在，检查容器ID是否变更
        if let Some(existing_container) = existing_project.container() {
            if existing_container.container_id != container_info.container_id {
                info!(
                    "🔄 [COMPUTER_CHAT] Detected container change: project_id={}, old_cid={}, new_cid={}",
                    project_id, existing_container.container_id, container_info.container_id
                );
                // 容器变更，继续执行后续的插入/更新逻辑（insert_project 会执行 upsert）
            } else {
                debug!(
                    "🔄 [COMPUTER_CHAT] DuckDB record already exists and container unchanged: project_id={}",
                    project_id
                );
                return Ok(());
            }
        } else {
            // 现有记录没有容器信息，继续更新
        }
    }

    // 创建新的 ProjectAndContainerInfo
    let mut project_info = shared_types::ProjectAndContainerInfo::new(project_id.to_string());

    // 设置 user_id（ComputerAgentRunner 模式）
    project_info.set_user_id(Some(user_id.to_string()));
    // 设置 pod_id（共享容器模式）
    project_info.set_pod_id(request.pod_id.clone());

    // 更新容器信息
    project_info.update_extended_from_request(
        Some(container_info.clone()),
        request.model_provider.clone(),
        request.request_id.clone(),
        Some(shared_types::ServiceType::ComputerAgentRunner),
    );

    // 立即插入到 DuckDB
    state.insert_project(project_id.to_string(), Arc::new(project_info));

    info!(
        "🆕 [COMPUTER_CHAT] Inserted DuckDB record (immediately after container creation): user_id={}, project_id={}, container_id={}",
        user_id, project_id, container_info.container_id
    );

    Ok(())
}

// ============================================================================
// SSE 进度流处理器（复用现有的 agent_session_notification）
// ============================================================================