# app.py

from flask import Flask, jsonify, request, send_from_directory, Response
from flask_cors import CORS  # 导入 CORS
import os
import logging
import json
import threading
import time
import requests  # 导入 requests 库
from flask import g  # 导入g对象，用于存储请求上下文中的数据

# 导入自定义模块
from utils import (
    setup_logging,
    get_current_timestamp,
    generate_uuid,
)  # 工具函数，如日志设置、时间戳、UUID生成
from config import get_config, set_config  # 配置管理，用于读取和写入config.ini
import file_manager  # 文件管理模块，处理角色、记忆、聊天记录等文件的读写
from gemini_client import GeminiClient  # 导入Gemini客户端，用于与Gemini API交互
import memory_manager  # 导入记忆管理模块，负责构建Prompt和处理记忆更新逻辑

# --- Flask 应用初始化 ---

# app_config 声明为全局变量，用于存储应用配置
app_config = {}
# 日志配置将在 initialize_app_data 中进行
logger = logging.getLogger(__name__)  # 获取app.py的日志器

app = Flask(__name__, static_folder="static")
CORS(app)  # 初始化 CORS，允许所有来源的跨域请求

# 全局会话状态变量
global_current_role_id: str = "default_role"
global_current_memory_id: str = "default_memory"
global_current_chat_log_id: str = ""
global_turn_counter: int = 0
global_current_chat_history: list = []
global_memory_update_status: str = "idle"  # 新增：记忆更新状态

# 初始化Gemini客户端 (全局唯一实例)
gemini_client: GeminiClient | None = None


# --- 辅助函数 ---
def error_response(message: str, status_code: int) -> Response:
    """
    标准化错误响应格式。
    :param message: 错误信息。
    :param status_code: HTTP状态码。
    :return: JSON格式的错误响应。
    """
    response = jsonify({"error": message})
    response.status_code = status_code
    return response


@app.before_request
def load_session_context():
    """
    在每个请求之前加载会话上下文到 Flask 的 g 对象。
    这确保了每个请求都有独立的会话状态。
    """
    # 直接使用全局变量来设置 g 对象，确保 g 对象中的会话信息与全局变量保持同步
    g.current_role_id = global_current_role_id
    g.current_memory_id = global_current_memory_id
    g.current_chat_log_id = global_current_chat_log_id
    g.turn_counter = global_turn_counter  # g.turn_counter 应该反映当前的全局轮次

    logger.debug(
        f"请求上下文加载：角色ID={g.current_role_id}, 记忆ID={g.current_memory_id}, 聊天记录ID={g.current_chat_log_id}, 轮次={g.turn_counter}"
    )


# --- 静态文件路由 ---


@app.route("/")
def index():
    """根路由，返回前端的index.html文件"""
    # 确保 static_folder 不为 None
    static_folder_path = (
        app.static_folder if app.static_folder is not None else "static"
    )
    return send_from_directory(static_folder_path, "index.html")


@app.route("/favicon.ico")
def favicon():
    """处理 favicon.ico 请求"""
    static_folder_path = (
        app.static_folder if app.static_folder is not None else "static"
    )
    return send_from_directory(
        static_folder_path, "favicon.ico", mimetype="image/vnd.microsoft.icon"
    )


# --- API 路由定义 ---


@app.route("/api/config", methods=["GET"])
def get_app_config():
    """
    获取当前应用程序的所有配置。
    :return: JSON格式的配置数据。
    """
    current_config = get_config()
    # 敏感信息不直接暴露给前端，例如API KEY
    api_key = current_config["API"].get("GEMINI_API_KEY", "")
    # 根据用户要求，完整显示API Key
    display_config = {
        "API": current_config["API"],
        "Application": current_config["Application"],
        "Session": current_config["Session"],
    }
    logger.debug("获取配置：成功")
    return jsonify(display_config)


@app.route("/api/config", methods=["POST"])
def update_app_config():
    """
    更新应用程序配置。
    :return: 更新后的配置信息或错误信息。
    """
    data = request.json
    if data is None:
        logger.warning("更新配置：请求数据为空或格式不正确。")
        return error_response("请求数据为空或格式不正确", 400)

    new_config = get_config()  # 获取当前配置的副本
    try:
        # 允许更新API和Application部分
        for section_name, section_data in data.items():
            if section_name == "API":
                for key, value in section_data.items():
                    if key == "GEMINI_API_KEY":
                        new_config["API"][key] = value
                    else:
                        new_config["API"][key] = value
            elif section_name == "Application":
                for key, value in section_data.items():
                    if key in [
                        "CONTEXT_WINDOW_SIZE",
                        "MEMORY_RETENTION_TURNS",
                        "MAX_SHORT_TERM_EVENTS",
                    ]:
                        try:
                            new_config["Application"][key] = int(value)
                        except ValueError:
                            logger.warning(
                                f"配置项 {key} 的值 '{value}' 不是有效数字。"
                            )
                            return error_response(
                                f"配置项 {key} 的值 '{value}' 不是有效数字", 400
                            )
                    else:
                        new_config["Application"][key] = value
            # Session 部分由 /api/active_session 控制，不在此处直接修改
            else:
                logger.warning(f"尝试更新未知配置部分: {section_name}")

        set_config(new_config)  # 保存到文件并更新内存中的全局配置
        logger.info("配置更新：成功。")

        # 重新初始化Gemini客户端以使用新的API配置
        global gemini_client
        api_key = new_config["API"].get("GEMINI_API_KEY")
        if api_key and api_key.strip():
            gemini_client = GeminiClient()
            logger.info("Gemini客户端已重新初始化。")
        else:
            logger.warning("GEMINI_API_KEY 已被移除或为空，Gemini客户端未初始化。")
            gemini_client = None

        return jsonify({"message": "配置更新成功", "config": new_config["Application"]})
    except json.JSONDecodeError:
        logger.error("更新配置失败: 请求JSON格式不正确。", exc_info=True)
        return error_response("请求JSON格式不正确。", 400)
    except KeyError as e:
        logger.error(f"更新配置失败: 缺少必要的配置键 {e}", exc_info=True)
        return error_response(f"缺少必要的配置键: {e}", 400)
    except Exception as e:
        logger.error(f"更新配置失败: {e}", exc_info=True)
        return error_response(f"更新配置失败: {str(e)}", 500)


@app.route("/api/roles", methods=["GET"])
def get_roles():
    """
    获取所有可用的角色列表。
    :return: 角色列表JSON。
    """
    roles = file_manager.list_roles()
    logger.debug(f"获取角色列表：{len(roles)} 个角色。")
    return jsonify(roles)


@app.route("/api/roles", methods=["POST"])
def create_new_role():
    """
    创建一个新角色。
    需要提供 'id' 和 'name'。
    :return: 成功或失败信息。
    """
    data = request.json or {}  # 确保 data 始终是字典
    if not data:  # 检查 data 否为空字典或 None
        return error_response("请求数据为空或格式不正确", 400)
    role_id = data.get("id")
    role_name = data.get("name")
    if not role_id or not role_name:
        logger.warning("创建角色失败: 缺少 'id' 或 'name'。")
        return error_response("需要提供 'id' 和 'name' 来创建角色。", 400)

    try:
        if file_manager.create_role(role_id, role_name):
            logger.info(f"创建角色 '{role_name}' ({role_id}) 成功。")
            return jsonify({"message": "角色创建成功", "role_id": role_id})
        else:
            logger.error(f"创建角色 '{role_name}' ({role_id}) 失败，可能ID已存在。")
            return error_response("创建角色失败，可能ID已存在。", 409)  # Conflict
    except Exception as e:
        logger.error(f"创建角色时发生异常: {e}", exc_info=True)
        return error_response(f"创建角色失败: {str(e)}", 500)


@app.route("/api/roles/<string:role_id>", methods=["DELETE"])
def delete_existing_role(role_id):
    """
    删除指定ID的角色。
    :return: 成功或失败信息。
    """
    # 检查是否是当前活跃角色，不允许删除
    if role_id == g.current_role_id:
        logger.warning(f"尝试删除当前活跃角色 '{role_id}'。")
        return error_response("不能删除当前活跃的角色。", 403)  # Forbidden

    try:
        if file_manager.delete_role(role_id):
            logger.info(f"删除角色 '{role_id}' 成功。")
            return jsonify({"message": "角色删除成功", "role_id": role_id})
        else:
            logger.error(f"删除角色 '{role_id}' 失败，可能角色不存在或文件操作失败。")
            return error_response("删除角色失败，可能角色不存在或文件操作失败。", 404)
    except Exception as e:
        logger.error(f"删除角色时发生异常: {e}", exc_info=True)
        return error_response(f"删除角色失败: {str(e)}", 500)


@app.route("/api/memories", methods=["GET"])
def get_memories():
    """
    获取所有可用的记忆集列表。
    :return: 记忆集列表JSON。
    """
    memories = file_manager.list_memories()
    logger.debug(f"获取记忆列表：{len(memories)} 个记忆集。")
    return jsonify(memories)


@app.route("/api/memories", methods=["POST"])
def create_new_memory():
    """
    创建一个新记忆集。
    需要提供 'id' 和 'name'。
    :return: 成功或失败信息。
    """
    data = request.json or {}  # 确保 data 始终是字典
    if not data:  # 检查 data 是否为空字典或 None
        return error_response("请求数据为空或格式不正确", 400)
    memory_id = data.get("id")
    memory_name = data.get("name")
    if not memory_id or not memory_name:
        logger.warning("创建记忆集失败: 缺少 'id' 或 'name'。")
        return error_response("需要提供 'id' 和 'name' 来创建记忆集。", 400)

    try:
        if file_manager.create_memory(memory_id, memory_name):
            logger.info(f"创建记忆集 '{memory_name}' ({memory_id}) 成功。")
            return jsonify({"message": "记忆集创建成功", "memory_id": memory_id})
        else:
            logger.error(
                f"创建记忆集 '{memory_name}' ({memory_id}) 失败，可能ID已存在。"
            )
            return error_response("创建记忆集失败，可能ID已存在。", 409)
    except Exception as e:
        logger.error(f"创建记忆集时发生异常: {e}", exc_info=True)
        return error_response(f"创建记忆集失败: {str(e)}", 500)


@app.route("/api/memories/<string:memory_id>", methods=["DELETE"])
def delete_existing_memory(memory_id):
    """
    删除指定ID的记忆集。
    :return: 成功或失败信息。
    """
    # 检查是否是当前活跃记忆集，不允许删除
    if memory_id == g.current_memory_id:
        logger.warning(f"尝试删除当前活跃记忆集 '{memory_id}'。")
        return error_response("不能删除当前活跃的记忆集。", 403)  # Forbidden

    try:
        if file_manager.delete_memory(memory_id):
            logger.info(f"删除记忆集 '{memory_id}' 成功。")
            return jsonify({"message": "记忆集删除成功", "memory_id": memory_id})
        else:
            logger.error(
                f"删除记忆集 '{memory_id}' 失败，可能记忆集不存在或文件操作失败。"
            )
            return error_response("删记忆集失败，可能记忆集不存在或文件操作失败。", 404)
    except Exception as e:
        logger.error(f"删除记忆集时发生异常: {e}", exc_info=True)
        return error_response(f"删除记忆集失败: {str(e)}", 500)


@app.route("/api/active_session", methods=["GET"])
def get_active_session():
    """
    获取当前活跃的会话信息，包括角色ID、记忆ID和聊天记录ID。
    :return: JSON格式的会话信息。
    """
    global global_current_role_id, global_current_memory_id, global_current_chat_log_id, global_turn_counter
    logger.debug("获取当前活跃会话：成功。")
    return jsonify(
        {
            "role_id": global_current_role_id,
            "memory_id": global_current_memory_id,
            "chat_log_id": global_current_chat_log_id,
            "turn_counter": global_turn_counter,
            "memory_status": global_memory_update_status,  # 新增：返回记忆更新状态
        }
    )


@app.route("/api/active_session", methods=["POST"])
def set_active_session():
    """
    设置当前活跃的会话（角色和记忆）。
    如果提供了新的role_id或memory_id，则更新并重置聊天上下文和轮次。
    :return: 更新后的会话信息。
    """
    global global_current_role_id, global_current_memory_id, global_current_chat_log_id, global_turn_counter, global_current_chat_history
    data = request.json or {}  # 确保 data 始终是字典

    new_role_id = data.get("role_id", global_current_role_id)
    new_memory_id = data.get("memory_id", global_current_memory_id)

    # 检查新ID是否存在
    if not file_manager.role_exists(new_role_id):
        logger.warning(f"设置活跃会话失败: 角色ID '{new_role_id}' 不存在。")
        return error_response(f"角色ID '{new_role_id}' 不存在。", 404)
    if not file_manager.memory_exists(new_memory_id):
        logger.warning(f"设置活跃会话失败: 记忆ID '{new_memory_id}' 不存在。")
        return error_response(f"记忆ID '{new_memory_id}' 不存在。", 404)

    # 只有当角色或记忆发生变化时才重置会话
    if (
        new_role_id != global_current_role_id
        or new_memory_id != global_current_memory_id
    ):
        old_chat_log_id = global_current_chat_log_id  # 保存旧的聊天记录ID

        global_current_role_id = new_role_id
        global_current_memory_id = new_memory_id
        global_current_chat_log_id = (
            f"{global_current_role_id}_{global_current_memory_id}_{generate_uuid()}"
        )

        global_turn_counter = 0
        global_current_chat_history = []  # 清空聊天历史

        # 更新config.ini中的当前激活会话
        current_app_config = get_config()
        current_app_config["Session"]["CURRENT_ROLE_ID"] = global_current_role_id
        current_app_config["Session"]["CURRENT_MEMORY_ID"] = global_current_memory_id
        set_config(current_app_config)  # 保存到文件

        # 删除旧的聊天记录文件（如果存在且与新的不同）
        if old_chat_log_id and old_chat_log_id != global_current_chat_log_id:
            if file_manager.delete_chat_log(old_chat_log_id):
                logger.info(f"旧聊天记录 '{old_chat_log_id}' 已成功删除。")
            else:
                logger.warning(f"删除旧聊天记录 '{old_chat_log_id}' 失败或文件不存在。")

        logger.info(
            f"活跃会话已切换至角色 '{global_current_role_id}' 和记忆集 '{global_current_memory_id}'。新聊天记录ID: {global_current_chat_log_id}"
        )
    else:
        logger.info(
            f"活跃会话保持不变 (角色: {global_current_role_id}, 记忆: {global_current_memory_id})。"
        )

    return jsonify(
        {
            "message": "活跃会话已更新",
            "role_id": global_current_role_id,
            "memory_id": global_current_memory_id,
            "chat_log_id": global_current_chat_log_id,
            "turn_counter": global_turn_counter,
        }
    )


@app.route("/api/features_content", methods=["GET"])
def get_features_content():
    """
    获取当前活跃角色的特征文件内容。
    :return: JSON格式的特征内容。
    """
    features_data = file_manager.load_active_features(global_current_role_id)
    if features_data:
        logger.debug(f"获取角色 '{global_current_role_id}' 的特征内容：成功。")
        return jsonify(features_data)
    else:
        logger.error(f"获取角色 '{global_current_role_id}' 的特征内容失败。")
        return error_response("未能加载角色特征内容。", 500)


@app.route("/api/features_content", methods=["POST"])
def update_features_content():
    """
    更新当前活跃角色的特征文内容。
    :return: 成功或失败信息。
    """
    data = request.json
    if data is None:
        return error_response("请求数据为空或格式不正确", 400)

    # 确保保存的JSON中包含"角色名称"字段，并与实际角色名称一致
    # 从文件管理器获取所有角色，找到当前角色的名称
    roles = file_manager.list_roles()
    current_role_name = next(
        (r["name"] for r in roles if r["id"] == global_current_role_id),
        global_current_role_id,
    )
    data["角色名称"] = current_role_name

    if file_manager.save_active_features(global_current_role_id, data):
        logger.info(f"角色 '{global_current_role_id}' 的特征内容更新成功。")
        return jsonify({"message": "特征内容更新成功"})
    else:
        logger.error(f"角色 '{global_current_role_id}' 的特征内容更新失败。")
        return error_response("特征内容更新失败。", 500)


@app.route("/api/memory_content", methods=["GET"])
def get_memory_content():
    """
    获取当前活跃记忆集的记忆文件内容。
    :return: JSON格式的记忆内容。
    """
    memory_data = file_manager.load_active_memory(global_current_memory_id)
    if memory_data:
        logger.debug(f"获取记忆集 '{global_current_memory_id}' 的记忆内容：成功。")
        return jsonify(memory_data)
    else:
        logger.error(f"获取记忆集 '{global_current_memory_id}' 的记忆内容失败。")
        return error_response("未能加载记忆内容。", 500)


@app.route("/api/memory_content", methods=["POST"])
def update_memory_content():
    """
    更新当前活跃记忆集的记忆文件内容。
    :return: 成功或失败信息。
    """
    data = request.json
    if data is None:
        return error_response("请求数据为空或格式不正确", 400)

    # 确保保存的JSON中包含'long_term_facts'和'short_term_events'字段
    if "long_term_facts" not in data or "short_term_events" not in data:
        return error_response(
            "记忆内容需要包含 'long_term_facts' 和 'short_term_events' 字段。", 400
        )

    if file_manager.save_active_memory(global_current_memory_id, data):
        logger.info(f"记忆集 '{global_current_memory_id}' 的记忆内容更新成功。")
        return jsonify({"message": "记忆内容更新成功"})
    else:
        logger.error(f"记忆集 '{global_current_memory_id}' 的记忆内容更新失败。")
        return error_response("记忆内容更新失败。", 500)


@app.route("/api/chat_log", methods=["GET"])
def get_chat_log():
    """
    获取当前活跃会话的聊天记录。
    :param limit: 可选，限制返回的记录数量。
    :return: JSON格式聊天记录列表。
    """
    limit = request.args.get("limit", type=int)
    logs = file_manager.read_chat_log(global_current_chat_log_id, limit=limit)
    logger.debug(f"获取聊天记录：{len(logs)} 条。")
    return jsonify(logs)


@app.route("/api/chat_log", methods=["DELETE"])
def delete_chat_log_route():
    """
    删除当前活跃会话的聊天记录文件。
    :return: 成功或失败信息。
    """
    # 这里我们只删除当前 session 对应的聊天记录文件
    if file_manager.delete_chat_log(global_current_chat_log_id):
        # 删除后，清空内存中的聊天历史
        global global_current_chat_history, global_turn_counter
        global_current_chat_history = []
        global_turn_counter = 0
        logger.info(
            f"聊天记录 '{global_current_chat_log_id}' 删除成功，内存历史已清空。"
        )
        return jsonify({"message": "聊天记录删除成功，会话历史已清空"})
    else:
        logger.error(f"聊天记录 '{global_current_chat_log_id}' 删除失败。")
        return error_response("聊天记录删除失败。", 500)


@app.route("/api/proxy_models", methods=["GET"])
def proxy_get_available_models():
    """
    通过后端代理获取Gemini API可用的模型列表。
    :return: JSON格式的模型列表。
    """
    current_config = get_config()
    gemini_api_base_url = current_config["API"].get("GEMINI_API_BASE_URL")

    if not gemini_api_base_url:
        logger.warning("GEMINI_API_BASE_URL 未配置，无法获取模型列表。")
        return jsonify({"models": [], "error": "GEMINI_API_BASE_URL 未配置。"})

    # 确保 GEMINI_API_BASE_URL 以 /v1beta 结尾，并拼接 /models
    # 移除末尾的斜杠，然后添加 /v1beta/models
    base_url_cleaned = gemini_api_base_url.rstrip("/")
    if not base_url_cleaned.endswith("/v1beta"):
        base_url_cleaned += "/v1beta"
    models_url = f"{base_url_cleaned}/models"

    headers = {}
    # 如果有API Key，也传递给上游API
    api_key = current_config["API"].get("GEMINI_API_KEY")
    if api_key and api_key.strip():
        headers["x-goog-api-key"] = api_key  # 根据Gemini API的要求添加API Key头

    try:
        response = requests.get(models_url, headers=headers, timeout=10)  # 设置超时

        response.raise_for_status()  # 如果状态码不是2xx，则抛出HTTPError

        models_data = response.json()
        logger.debug("通过代理成功获取模型列表。")
        return jsonify(models_data)

    except requests.exceptions.Timeout:
        logger.error(f"获取模型列表超时: {models_url}")
        return error_response("获取模型列表超时。", 504)  # Gateway Timeout
    except requests.exceptions.RequestException as e:
        logger.error(f"通过代理获取模型列表失败: {e}", exc_info=True)
        return error_response(f"获取模型列表失败: {str(e)}", 500)
    except json.JSONDecodeError:
        logger.error(f"无法解析模型列表响应为JSON: {response.text}", exc_info=True)
        return error_response("无法解析模型列表响应。", 500)


@app.route("/api/logs", methods=["GET"])
def get_app_logs():
    """
    获取应用程序的日志内容。
    :return: 日志文件内容或错误信息。
    """
    log_file_path = get_config()["Application"]["APP_LOG_FILE_PATH"]
    try:
        if not os.path.exists(log_file_path):
            logger.warning(f"日志文件不存在: {log_file_path}")
            return error_response("日志文件不存在。", 404)
        with open(log_file_path, "r", encoding="utf-8") as f:
            logs = f.read()
        return Response(logs, mimetype="text/plain")
    except Exception as e:
        logger.error(f"读取日志文件失败: {e}", exc_info=True)
        return error_response(f"读取日志文件失败: {str(e)}", 500)


# --- 主对话路由 ---
@app.route("/api/chat", methods=["POST"])
def chat_with_gemini():
    """
    与Gemini模型进行对话。
    :return: AI回复和当前的会话状态。
    """
    global global_turn_counter, global_current_chat_history, global_current_role_id, global_current_memory_id

    # 检查是否请求流式响应
    use_stream = request.args.get("stream", "false").lower() == "true"

    data = request.json
    if data is None:
        return error_response("请求数据为空或格式不正确", 400)
    user_message = data.get("message")
    if not user_message:
        return error_response("消息内容不能为空。", 400)

    # 1. 记录用户消息并更新全局聊天历史
    user_entry = {
        "timestamp": get_current_timestamp(),
        "role": "user",
        "content": user_message,
        "id": f"user-{time.time()}-{generate_uuid()[:8]}",  # 添加消息ID
    }
    file_manager.append_chat_log(g.current_chat_log_id, user_entry)
    global_current_chat_history.append(
        {"role": "user", "parts": [{"text": user_message}]}
    )
    logger.info(f"用户消息已记录。当前轮次: {g.turn_counter}")

    # 2. 构建系统提示词 (包含特征和记忆)
    system_instruction = memory_manager.build_system_prompt(
        g.current_role_id,
        g.current_memory_id,
        g.turn_counter,  # 传递当前轮次给Prompt
    )

    # 3. 管理上下文长度：只保留最近 CONTEXT_WINDOW_SIZE * 2 条消息 (用户+AI)
    context_window_size = app_config["Application"]["CONTEXT_WINDOW_SIZE"]
    # 从全局聊天历史中获取用于API调用的部分
    chat_history_for_api = global_current_chat_history[-context_window_size * 2 :]

    # 4. 调用 Gemini API 进行对话
    if gemini_client is None:
        logger.error("Gemini客户端未初始化，无法进行对话。")
        return error_response("AI助手未初始化，请检查API配置。", 500)

    model_name = app_config["API"]["DEFAULT_GEMINI_MODEL"]

    # 创建AI回复的消息ID
    ai_message_id = f"assistant-{time.time()}-{generate_uuid()[:8]}"

    # 根据请求类型选择处理方式
    if use_stream:
        # 流式响应处理
        def generate_stream():
            try:
                # 确保gemini_client不为None
                if gemini_client is None:
                    logger.error("Gemini客户端未初始化，无法进行流式对话。")
                    yield f"data: {json.dumps({'error': 'AI助手未初始化，请检查API配置。'})}\n\n"
                    return

                # 调用流式API
                stream_response = gemini_client.generate_content(
                    model_name=model_name,
                    contents=chat_history_for_api,
                    system_instruction=system_instruction,
                    stream=True,  # 启用流式响应
                )

                full_response = ""

                if isinstance(stream_response, tuple) and len(stream_response) == 2:
                    # 如果返回错误信息
                    error_message, status_code = stream_response
                    logger.error(
                        f"Gemini API 流式响应返回错误: {error_message} (状态码: {status_code})"
                    )
                    yield f"data: {json.dumps({'error': error_message})}\n\n"
                    return

                # 处理流式响应
                for chunk in stream_response:
                    if chunk:
                        full_response += chunk
                        # 发送数据块
                        yield f"data: {json.dumps({'chunk': chunk, 'id': ai_message_id})}\n\n"

                # 流结束后，保存完整回复到数据库
                # 获取当前请求中的聊天记录ID(避免使用g对象)
                current_chat_log_id = global_current_chat_log_id

                assistant_entry = {
                    "timestamp": get_current_timestamp(),
                    "role": "assistant",
                    "content": full_response,
                    "id": ai_message_id,
                }
                # 使用全局变量而不是g对象
                file_manager.append_chat_log(current_chat_log_id, assistant_entry)
                global_current_chat_history.append(
                    {"role": "assistant", "parts": [{"text": full_response}]}
                )

                # 更新全局对话轮次
                global global_turn_counter
                global_turn_counter += 1

                # 发送结束标记
                yield f"data: {json.dumps({'end': True, 'turn_counter': global_turn_counter})}\n\n"

                # 在另一个线程中检查并触发记忆更新，避免阻塞流式响应
                def delayed_memory_update():
                    try:
                        with app.app_context():  # 创建应用上下文
                            logger.info("在新线程中触发记忆更新")
                            check_and_trigger_memory_update()
                    except Exception as e:
                        logger.error(f"延迟记忆更新失败: {e}", exc_info=True)

                # 启动延迟更新线程
                threading.Thread(target=delayed_memory_update).start()

            except Exception as e:
                logger.error(f"流式生成内容时发生错误: {e}", exc_info=True)
                yield f"data: {json.dumps({'error': str(e)})}\n\n"

        return Response(generate_stream(), mimetype="text/event-stream")
    else:
        # 标准响应处理
        try:
            ai_response = gemini_client.generate_content(
                model_name=model_name,
                contents=chat_history_for_api,
                system_instruction=system_instruction,
            )

            # 检查 ai_response 是否为元组 (错误信息, 状态码)
            if isinstance(ai_response, tuple) and len(ai_response) == 2:
                error_message: str = ai_response[0]
                status_code: int = ai_response[1]
                logger.error(
                    f"Gemini API 返回错误: {error_message} (状态码: {status_code})"
                )
                return error_response(error_message, status_code)

            # 如果不是元组，则预期它是一个字符串
            if not isinstance(ai_response, str):
                logger.error(
                    f"Gemini API 返回了非字符串/元组类型结果: {type(ai_response)} - {ai_response}"
                )
                return error_response("AI助手返回了非预期的结果类型。", 500)

            ai_response_text: str = ai_response
        except Exception as e:
            logger.error(f"调用Gemini API失败: {e}", exc_info=True)
            return error_response(f"AI助手调用失败: {str(e)}", 500)

        logger.info(f"Gemini API 回复: {ai_response_text[:100]}...")

        # 5. 记录AI回复并更新全局聊天历史
        assistant_entry = {
            "timestamp": get_current_timestamp(),
            "role": "assistant",
            "content": ai_response_text,
            "id": ai_message_id,
        }
        file_manager.append_chat_log(g.current_chat_log_id, assistant_entry)
        global_current_chat_history.append(
            {"role": "assistant", "parts": [{"text": ai_response_text}]}
        )

        # 6. 更新全局对话轮次
        global global_turn_counter
        global_turn_counter += 1

        # 7. 检查并触发记忆更新 (异步)
        check_and_trigger_memory_update()

        # 8. 返回AI回复和当前会话状态
        response_data = {
            "success": True,
            "response": ai_response_text,
            "turn_counter": global_turn_counter,
            "active_session": {
                "role_id": g.current_role_id,
                "memory_id": g.current_memory_id,
                "chat_log_id": g.current_chat_log_id,
            },
            "id": ai_message_id,  # 返回消息ID，便于前端追踪
        }
        # 如果触发记忆更新，则在响应中添加状态
        if global_turn_counter > 0 and global_turn_counter % context_window_size == 0:
            response_data["memory_status"] = (
                "memory_updating"  # 保持与 /api/active_session 一致
            )

        return jsonify(response_data)


def check_and_trigger_memory_update():
    """检查是否需要触发记忆更新，如果需要则在后台线程中执行"""
    global global_turn_counter, global_current_chat_history, global_current_role_id, global_current_memory_id

    context_window_size = app_config["Application"]["CONTEXT_WINDOW_SIZE"]
    if global_turn_counter > 0 and global_turn_counter % context_window_size == 0:
        logger.info(f"对话轮次达到 {global_turn_counter}，触发异步记忆更新。")
        # 使用全局变量而不是g对象
        try:
            recent_chat_for_memory_update = global_current_chat_history[
                -context_window_size * 2 :
            ]

            current_memory_data_for_update = file_manager.load_active_memory(
                global_current_memory_id  # 使用全局变量替代g.current_memory_id
            )

            if current_memory_data_for_update:
                update_thread = threading.Thread(
                    target=_async_memory_update_task,
                    args=(
                        current_memory_data_for_update,
                        recent_chat_for_memory_update,
                        global_turn_counter,
                        global_current_role_id,  # 使用全局变量替代g.current_role_id
                        global_current_memory_id,  # 使用全局变量替代g.current_memory_id
                    ),
                )
                update_thread.start()
                logger.info(
                    f"记忆更新线程已启动，角色ID: {global_current_role_id}, 记忆ID: {global_current_memory_id}"
                )
            else:
                logger.error(f"无法加载记忆数据，记忆ID: {global_current_memory_id}")
        except Exception as e:
            logger.error(f"触发记忆更新时发生错误: {e}", exc_info=True)


def _async_memory_update_task(
    initial_memory_data,
    recent_chat_history,
    current_trigger_turn_count,
    role_id: str,
    memory_id: str,
):
    """
    异步执行记忆更新任务。
    :param initial_memory_data: 触发更新时的原始记忆数据。
    :param recent_chat_history: 最近 N 轮对话历史。
    :param current_trigger_turn_count: 触发本次更新时的全局对话轮次。
    :param role_id: 当前活跃的角色ID。
    :param memory_id: 当前活跃的记忆ID。
    """
    global global_memory_update_status  # 声明使用全局变量
    # 在新线程中手动创建应用上下文
    with app.app_context():
        logger.info(
            f"异步记忆更新任务开始，角色: {role_id}, 记忆: {memory_id}, 触发轮次: {current_trigger_turn_count}"
        )
        global_memory_update_status = "updating"  # 设置状态为更新中
        try:
            # 1. 构建记忆更新的Prompt
            update_prompt = memory_manager.build_memory_update_prompt(
                recent_chat_history, initial_memory_data, current_trigger_turn_count
            )

            # 2. 调用Gemini API进行记忆更新
            if gemini_client is None:
                logger.error("Gemini客户端未初始化，无法执行记忆更新。请检查API配置。")
                return

            # 确保 app_config 在上下文中可用，或者重新获取
            current_app_config = get_config()  # 重新获取配置，确保在上下文中
            update_model_name = current_app_config["API"]["MEMORY_UPDATE_MODEL"]
            try:
                # 构造一个符合Gemini API预期的请求体
                # 使用单条消息，将prompt作为文本内容
                gemini_response = gemini_client.generate_content(
                    model_name=update_model_name,
                    contents=[{"role": "user", "parts": [{"text": update_prompt}]}],
                    system_instruction=None,  # 不使用system_instruction，直接在contents中包含prompt
                )

                # 检查 gemini_response 是否为元组 (错误信息, 状态码)
                if isinstance(gemini_response, tuple) and len(gemini_response) == 2:
                    error_message: str = gemini_response[0]
                    status_code: int = gemini_response[1]
                    logger.error(
                        f"Gemini模型在记忆更新时返回错误: {error_message} (状态码: {status_code})"
                    )
                    return  # 无法继续，直接返回

                # 如果不是元组，则预期它是一个字符串
                if not isinstance(gemini_response, str):
                    logger.error(
                        f"Gemini模型在记忆更新时返回了非字符串/元组类型结果: {type(gemini_response)} - {gemini_response}"
                    )
                    return  # 无法继续，直接返回

                gemini_response_text: str = gemini_response
            except Exception as e:
                logger.error(f"调用Gemini API进行记忆更新失败: {e}", exc_info=True)
                return

            # 3. 处理模型返回的记忆更新JSON
            updated_memory_data = memory_manager.process_memory_update_response(
                gemini_response_text,
                initial_memory_data,
                current_trigger_turn_count,
            )

            # 4. 保存更新后的记忆数据
            if file_manager.save_active_memory(memory_id, updated_memory_data):
                logger.info(f"记忆集 '{memory_id}' (角色 '{role_id}') 记忆更新成功。")
                global_memory_update_status = "completed"  # 更新成功
            else:
                logger.error(f"记忆集 '{memory_id}' (角色 '{role_id}') 记忆保存失败。")
                global_memory_update_status = "error"  # 保存失败
        except Exception as e:
            logger.error(f"异步记忆更新任务发生致命错误: {e}", exc_info=True)
            global_memory_update_status = "error"  # 发生错误
        finally:
            # 无论成功或失败，最终都将状态设置为 idle，除非有其他更新正在进行
            # 这里需要更复杂的逻辑来判断是否真的空闲，暂时简化处理
            if global_memory_update_status != "updating":  # 避免覆盖正在进行的更新
                global_memory_update_status = "idle"


# --- 主运行部分 ---
# --- 应用启动前处理 ---
def initialize_app_data():
    """
    在Flask应用启动时执行。
    用于确保必要的默认数据（如默认角色和记忆）存在，并初始化会话状态。
    """
    global app_config, gemini_client
    global global_current_role_id, global_current_memory_id, global_current_chat_log_id, global_turn_counter, global_current_chat_history

    # 在所有模块加载和配置读取完成后配置日志
    app_config = get_config()  # 确保获取到最新的配置
    setup_logging(app_config["Application"]["APP_LOG_FILE_PATH"])
    logger.info("应用数据初始化开始...")

    file_manager.ensure_initial_data()

    # 从 config.ini 加载初始会话状态
    session_config = app_config["Session"]

    # 检查并设置当前角色ID和记忆ID，并更新config.ini（如果需要）
    configured_role_id = session_config.get("CURRENT_ROLE_ID", "default_role")
    configured_memory_id = session_config.get("CURRENT_MEMORY_ID", "default_memory")

    # 确保配置中的角色和记忆ID是有效的，如果无效则回退到默认值
    if not file_manager.role_exists(configured_role_id):
        logger.warning(
            f"配置的角色ID '{configured_role_id}' 不存在，回退到 'default_role'。"
        )
        global_current_role_id = "default_role"
    else:
        global_current_role_id = configured_role_id

    if not file_manager.memory_exists(configured_memory_id):
        logger.warning(
            f"配置的记忆ID '{configured_memory_id}' 不存在，回退到 'default_memory'。"
        )
        global_current_memory_id = "default_memory"
    else:
        global_current_memory_id = configured_memory_id

    # 如果回退了，需要更新config.ini
    if (
        configured_role_id != global_current_role_id
        or configured_memory_id != global_current_memory_id
    ):
        current_app_config = get_config()
        current_app_config["Session"]["CURRENT_ROLE_ID"] = global_current_role_id
        current_app_config["Session"]["CURRENT_MEMORY_ID"] = global_current_memory_id
        set_config(current_app_config)
        logger.info("config.ini 中的会话配置已更新为有效值。")
        app_config = get_config()  # 重新加载配置到 app_config

    # 聊天记录ID：每次应用启动时生成一个新的唯一ID
    global_current_chat_log_id = (
        f"{global_current_role_id}_{global_current_memory_id}_{generate_uuid()}"
    )
    global_turn_counter = 0
    global_current_chat_history = []  # 清空聊天历史

    logger.info(f"应用启动，已创建新的聊天记录ID: {global_current_chat_log_id}。")
    logger.info("应用数据初始化完成。")

    # 初始化Gemini客户端
    api_key = app_config["API"].get("GEMINI_API_KEY")
    if api_key and api_key.strip():  # 确保API Key不为空或只包含空格
        gemini_client = GeminiClient()
        logger.info("Gemini客户端已初始化。")
    else:
        logger.warning("未配置或API KEY为空，Gemini客户端未初始化。")
        gemini_client = None


@app.route("/api/memory/trigger_update", methods=["POST"])
def trigger_memory_update_route():
    """
    手动触发记忆更新的API接口。
    """
    global global_current_role_id, global_current_memory_id, global_turn_counter, global_current_chat_history
    logger.info("收到手动触发记忆更新的请求。")

    # 获取当前记忆数据和最近的聊天历史
    current_memory_data_for_update = file_manager.load_active_memory(
        global_current_memory_id
    )
    # 记忆更新通常需要最近的对话历史，这里可以根据需要调整截取长度
    context_window_size = app_config["Application"]["CONTEXT_WINDOW_SIZE"]
    recent_chat_for_memory_update = global_current_chat_history[
        -context_window_size * 2 :
    ]

    if not current_memory_data_for_update:
        return error_response("无法加载当前记忆数据，无法触发更新。", 500)

    # 异步执行记忆更新任务
    update_thread = threading.Thread(
        target=_async_memory_update_task,
        args=(
            current_memory_data_for_update,
            recent_chat_for_memory_update,
            global_turn_counter,
            global_current_role_id,  # 传递当前角色ID
            global_current_memory_id,  # 传递当前记忆ID
        ),
    )
    update_thread.start()

    return jsonify({"message": "记忆更新任务已在后台触发。"})


if __name__ == "__main__":
    # 应用启动时初始化数据
    initialize_app_data()
    # 运行Flask应用
    # debug=True 仅用于开发环境，生产环境请勿使用
    app.run(debug=True, host="0.0.0.0", port=5000)