"""
API 路由定义（阿里云百炼 / DashScope 平台）
所有 DashScope 相关逻辑均集中在此文件，main.py 无感知任何平台细节。
"""

import json
import os
import uuid
from datetime import datetime
from pathlib import Path
from typing import Dict, List

import dashscope
from dashscope import Generation, MultiModalConversation
from fastapi import File, HTTPException, UploadFile
from fastapi.responses import JSONResponse, StreamingResponse


def init():
    """
    初始化百炼后端：设置 DashScope API Key。
    由 main.py 在启动时调用（若 LLM_BACKEND=dashscope）。
    """
    api_key = os.getenv("ALIYUN_API_KEY")
    if not api_key:
        raise ValueError("dashscope 模式需要设置环境变量 ALIYUN_API_KEY")
    dashscope.api_key = api_key
    print(f"[DashScope] 初始化完成，ALIYUN_API_KEY 已配置")


# 导入模型和工具函数（使用绝对路径）
import sys
from pathlib import Path

sys.path.append(str(Path(__file__).parent.parent))

from models.chat_models import ChatRequest, ModelInfo
from utils.helpers import (
    extract_delta_content,
    format_api_response,
    generate_unique_id,
    get_current_timestamp,
)
from utils.logger import log_error, log_exception, log_info

# 模拟数据库 - 实际应用中应使用持久化存储
conversations_db: Dict[str, dict] = {}

# 配置上传目录
upload_dir = Path("uploads")
upload_dir.mkdir(exist_ok=True)


def _extract_text_from_docmind(obj, depth: int = 0) -> str:
    """
    递归提取 DocMind JSON 结构中的可读文本。
    DashScopeParse 返回的 text 字段是 JSON 字符串，内部为文档智能解析的树形结构。
    """
    if depth > 15:
        return ""

    if isinstance(obj, str):
        s = obj.strip()
        # 过滤极短、URL、base64 等非正文字符串
        if len(s) > 3 and not s.startswith(("http://", "https://", "data:", "oss://")):
            return s
        return ""

    if isinstance(obj, list):
        parts = [_extract_text_from_docmind(item, depth + 1) for item in obj]
        return "\n".join(p for p in parts if p)

    if isinstance(obj, dict):
        # 优先处理文本相关字段
        priority_keys = ["content", "text", "paragraph", "caption", "value", "title"]
        # 跳过纯元数据字段
        skip_keys = {
            "backlink",
            "pos",
            "index",
            "style",
            "font",
            "color",
            "size",
            "hash",
            "id_",
            "id",
            "layouts",
            "type",
            "link",
        }
        parts = []
        for key in priority_keys:
            if key in obj:
                t = _extract_text_from_docmind(obj[key], depth + 1)
                if t:
                    parts.append(t)
        for key, val in obj.items():
            if key not in priority_keys and key not in skip_keys:
                t = _extract_text_from_docmind(val, depth + 1)
                if t:
                    parts.append(t)
        return "\n".join(parts)

    return ""


def _read_file_content(file_url: str):
    """
    【路线一：本地文本提取】对纯文本格式文件，直接读取内容注入消息。
    【路线二：DashScopeParse】对 doc/docx/pdf 文件，返回 (local_path, suffix) 供异步调用。

    返回值：
    - str：文本内容（路线一成功）
    - tuple(Path, str)：(本地路径, 扩展名)，需异步调用 DashScopeParse（路线二）
    - None：不支持的文件类型
    """
    try:
        from urllib.parse import urlparse

        parsed = urlparse(file_url)
        relative_path = parsed.path.lstrip("/")
        local_path = Path(relative_path)

        if not local_path.exists():
            return f"[文件不存在: {local_path}]"

        suffix = local_path.suffix.lower()

        # 路线一：纯文本格式直接读取
        text_extensions = {
            ".txt",
            ".md",
            ".csv",
            ".json",
            ".xml",
            ".yaml",
            ".yml",
            ".log",
            ".py",
            ".js",
            ".ts",
            ".html",
            ".css",
        }
        if suffix in text_extensions:
            with open(local_path, "r", encoding="utf-8", errors="replace") as f:
                content = f.read()
            max_len = 8000
            if len(content) > max_len:
                content = (
                    content[:max_len]
                    + f"\n\n[...文件内容过长，已截断，共 {len(content)} 字符]"
                )
            return content

        # 路线二：doc/docx/pdf 使用 DashScopeParse 云端解析
        dashscope_extensions = {".doc", ".docx", ".pdf"}
        if suffix in dashscope_extensions:
            return (local_path, suffix)  # 交给异步函数处理

        # 其余格式（xlsx、pptx 等）暂不支持内容读取
        return None

    except Exception as e:
        print(f"[WARNING] 读取文件内容失败: {e}")
        return f"[文件读取失败: {str(e)}]"


async def _parse_with_dashscope(local_path: Path) -> str:
    """
    【路线二：DashScopeParse】使用阿里云文档智能解析 doc/docx/pdf 文件。
    在线程池中运行（避免阻塞 FastAPI 事件循环）。
    仅支持 .doc/.docx/.pdf，文件大小 ≤100MB，页数 ≤1000 页。
    """
    import asyncio

    def _sync_parse():
        try:
            import json

            from llama_index.readers.dashscope.base import DashScopeParse
            from llama_index.readers.dashscope.utils import ResultType

            api_key = os.getenv("ALIYUN_API_KEY")
            parser = DashScopeParse(
                result_type=ResultType.DASHSCOPE_DOCMIND,
                api_key=api_key,
                num_workers=1,
            )
            print(f"[INFO] DashScopeParse: 开始解析 {local_path.name} ...")
            documents = parser.load_data(file_path=[str(local_path)])

            if not documents:
                return f"[DashScopeParse: {local_path.name} 解析结果为空]"

            texts = []
            for doc in documents:
                try:
                    content = json.loads(doc.text)
                    extracted = _extract_text_from_docmind(content)
                    texts.append(extracted if extracted else doc.text[:6000])
                except Exception:
                    texts.append(doc.text[:6000] if doc.text else "")

            result = "\n\n".join(t for t in texts if t)
            print(
                f"[INFO] DashScopeParse: {local_path.name} 解析完成，提取 {len(result)} 字符"
            )
            return result or f"[DashScopeParse: {local_path.name} 未能提取到文本内容]"

        except ImportError:
            return "[错误：DashScopeParse 未安装，请运行: pip install llama-index-core llama-index-readers-dashscope]"
        except Exception as e:
            print(f"[ERROR] DashScopeParse 解析失败: {e}")
            return f"[DashScopeParse 解析失败: {str(e)}]"

    loop = asyncio.get_event_loop()
    return await loop.run_in_executor(None, _sync_parse)


async def _inject_files_into_messages(messages: list, files: list) -> list:
    """
    将文件内容异步注入到消息列表中。
    - 文本类文件（路线一）：读取内容并追加到最后一条 user 消息中
    - doc/docx/pdf（路线二）：调用 DashScopeParse 云端解析后注入
    - 其他二进制文件：仅告知 AI 文件名和类型
    """
    if not files:
        return messages

    file_context_parts = []
    for file_url in files:
        from urllib.parse import urlparse

        parsed = urlparse(file_url)
        filename = parsed.path.split("/")[-1]
        suffix = Path(filename).suffix.lower()

        result = _read_file_content(file_url)

        if isinstance(result, str):
            # 路线一：文本内容，直接嵌入
            file_context_parts.append(
                f"--- 附件文件内容（{filename}）---\n{result}\n--- 附件结束 ---"
            )
        elif isinstance(result, tuple):
            # 路线二：doc/docx/pdf → 调用 DashScopeParse
            local_path, _ = result
            print(f"[INFO] 路线二：调用 DashScopeParse 解析 {filename}")
            parsed_text = await _parse_with_dashscope(local_path)
            file_context_parts.append(
                f"--- 附件文件内容（{filename}，阿里云文档智能解析）---\n"
                f"{parsed_text}\n--- 附件结束 ---"
            )
        else:
            # 其他不支持的格式：仅告知文件信息
            file_context_parts.append(
                f"[用户上传了一个文件: {filename}，类型: {suffix}，暂不支持自动读取内容，请告知用户。]"
            )

    if not file_context_parts:
        return messages

    file_context_text = "\n\n" + "\n\n".join(file_context_parts)

    # 把文件内容追加到最后一条 user 消息
    messages = list(messages)  # 复制，避免修改原始列表
    for i in range(len(messages) - 1, -1, -1):
        msg = messages[i]
        if isinstance(msg, dict) and msg.get("role") == "user":
            content = msg.get("content", "")
            if isinstance(content, str):
                messages[i] = dict(msg, content=content + file_context_text)
            elif isinstance(content, list):
                # 找到现有的 text 项，追加内容
                new_content = list(content)
                appended = False
                for j, item in enumerate(new_content):
                    if isinstance(item, dict) and item.get("type") == "text":
                        new_content[j] = dict(
                            item, text=item["text"] + file_context_text
                        )
                        appended = True
                        break
                if not appended:
                    new_content.append({"type": "text", "text": file_context_text})
                messages[i] = dict(msg, content=new_content)
            break

    return messages


async def chat_endpoint_handler(body: dict):
    """
    聊天接口处理器 - 与阿里云百炼API兼容的接口
    这个端点会接收前端的聊天请求并转发到阿里云百炼API
    """
    try:
        # 确保 body 是字典类型
        if not isinstance(body, dict):
            print(f"[ERROR] Request body is not a dictionary: {type(body)}")
            raise HTTPException(
                status_code=400,
                detail=f"Request body must be a JSON object, got {type(body).__name__}: {body}",
            )

        # 检查请求格式并适配
        # 如果是OpenAI兼容格式 (来自streamChat)
        if "messages" in body:
            messages = body.get("messages", [])
            model = body.get("model", "qwen-plus")
            stream = body.get("stream", True)
            temperature = body.get("temperature", 0.7)
            max_tokens = body.get("max_tokens", 2000)
            deepSearch = body.get("deepSearch", False)
            webSearch = body.get("webSearch", False)
            deepThinking = body.get("deepThinking", False)

            log_info(
                f"POST /api/chat-ui/chat | 模型: {model} | 流式: {stream} | 联网搜索: {webSearch} | 深度搜索: {deepSearch} | 深度思考: {deepThinking}"
            )

            # 处理 files 附件：将文件内容注入到最后一条 user 消息中
            files = body.get("files", [])
            if files:
                messages = await _inject_files_into_messages(messages, files)
                # 调试：打印注入后最后一条 user 消息的内容（截断显示 500 字）
                for msg in reversed(messages):
                    if isinstance(msg, dict) and msg.get("role") == "user":
                        content_preview = str(msg.get("content", ""))[:500]
                        print(
                            f"[DEBUG] 注入文件后 user 消息内容预览: {content_preview}"
                        )
                        break
        else:
            # 否则是前端简化格式 (来自chat函数)
            message_text = body.get("message", "")

            # 检查message是否已经是格式化的列表（带图片的情况）
            if isinstance(message_text, list):
                user_content = message_text
            else:
                user_content = [{"type": "text", "text": message_text}]

            messages = [
                {
                    "role": "system",
                    "content": body.get(
                        "systemPrompt",
                        "你是一个智能助手，可以分析用户发送的文本和文件内容。",
                    ),
                },
                {"role": "user", "content": user_content},
            ]
            model = body.get("model", "qwen-plus")
            stream = body.get("stream", False)
            temperature = body.get("temperature", 0.7)
            max_tokens = body.get("maxTokens", 2000)
            deepSearch = body.get("deepSearch", False)
            webSearch = body.get("webSearch", False)
            deepThinking = body.get("deepThinking", False)

        # 检查是否包含图像内容，如果是多模态请求，使用MultiModalConversation
        has_images = any(
            isinstance(msg, dict)
            and isinstance(msg.get("content"), list)
            and any(
                isinstance(item, dict) and item.get("type") == "image_url"
                for item in msg.get("content", [])
            )
            for msg in messages
            if isinstance(msg, dict)
        )

        if has_images:
            # 使用多模态API处理图像
            return await multimodal_chat_handler(
                messages, model, stream, temperature, max_tokens
            )
        else:
            # 构建 DashScope 额外参数
            dashscope_kwargs = {}
            if deepSearch:
                dashscope_kwargs["enable_search"] = True
                dashscope_kwargs["search_options"] = {"search_strategy": "max"}
                # 只有特定的思考模型版本支持部分高级 agent，但目前我们保持使用基础模型 + max 策略
            elif webSearch:
                dashscope_kwargs["enable_search"] = True
                dashscope_kwargs["search_options"] = {"search_strategy": "turbo"}

            if deepThinking:
                dashscope_kwargs["enable_thinking"] = True
                dashscope_kwargs["result_format"] = (
                    "message"  # enable_thinking 必须配合 result_format=message
                )
                dashscope_kwargs["incremental_output"] = (
                    True  # 流式模式下 enable_thinking 还必须配合 incremental_output=True
                )

            # 使用常规聊天API
            if stream:
                # 流式响应
                async def event_generator():
                    try:
                        responses = Generation.call(
                            model=model,
                            messages=messages,
                            stream=True,
                            max_tokens=max_tokens,
                            temperature=temperature,
                            **dashscope_kwargs,
                        )

                        full_content = ""  # 用于累计完整内容
                        full_reasoning_content = ""  # 用于累计完整思考内容

                        for idx, response in enumerate(responses):
                            if response.status_code == 200:
                                content = None

                                # 尝试从 output.choices 获取内容
                                if (
                                    hasattr(response, "output")
                                    and response.output
                                    and hasattr(response.output, "choices")
                                    and response.output.choices is not None
                                    and len(response.output.choices) > 0
                                    and "message" in response.output.choices[0]
                                ):

                                    msg_dict = response.output.choices[0]["message"]
                                    # incremental_output=True 时，每个 chunk 的 content/reasoning_content 已是增量片段
                                    # 直接使用，无需与 full_* 做对比
                                    content = msg_dict.get("content") or ""
                                    reasoning_content = (
                                        msg_dict.get("reasoning_content") or ""
                                    )

                                    delta_str = ""

                                    # 处理思考过程片段
                                    if reasoning_content:
                                        if not full_reasoning_content:
                                            # 第一个思考片段，添加 <think> 开始标签
                                            delta_str += "<think>"
                                        full_reasoning_content += reasoning_content
                                        delta_str += reasoning_content

                                    # 处理正式回复片段
                                    if content:
                                        if not full_content and full_reasoning_content:
                                            # 思考结束后首个正式回复，关闭 </think> 标签
                                            delta_str += "</think>\n\n"
                                        full_content += content
                                        delta_str += content

                                    if delta_str:
                                        data = {
                                            "id": f"chatcmpl-{generate_unique_id()}",
                                            "object": "chat.completion.chunk",
                                            "created": get_current_timestamp(),
                                            "model": model,
                                            "choices": [
                                                {
                                                    "index": 0,
                                                    "delta": {"content": delta_str},
                                                    "finish_reason": None,
                                                }
                                            ],
                                        }

                                        yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
                                # 否则尝试从 output.text 获取内容（DashScope特定格式）
                                elif (
                                    hasattr(response, "output")
                                    and response.output
                                    and "text" in response.output
                                ):

                                    content = response.output.get("text")

                                    # 只有当内容发生变化时才发送增量
                                    if len(content) > len(full_content):
                                        delta_content = extract_delta_content(
                                            content, full_content
                                        )
                                        full_content = content

                                        if (
                                            delta_content.strip()
                                        ):  # 只有当有非空白新内容时才发送
                                            # 构建 SSE 数据块
                                            data = {
                                                "id": f"chatcmpl-{generate_unique_id()}",
                                                "object": "chat.completion.chunk",
                                                "created": get_current_timestamp(),
                                                "model": model,
                                                "choices": [
                                                    {
                                                        "index": 0,
                                                        "delta": {
                                                            "content": delta_content
                                                        },
                                                        "finish_reason": None,
                                                    }
                                                ],
                                            }

                                            yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
                            else:
                                # 错误处理：写入 logger，方便排查
                                log_error(
                                    f"DashScope API 返回错误: chunk status={response.status_code}, code={response.code}, msg={response.message}"
                                )
                                error_data = {
                                    "error": {
                                        "message": f"API Error: {response.code} - {response.message}",
                                        "type": "api_error",
                                        "param": None,
                                        "code": response.code,
                                    }
                                }
                                yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
                                break

                        # 发送结束信号
                        finish_data = {
                            "id": f"chatcmpl-{generate_unique_id()}",
                            "object": "chat.completion.chunk",
                            "created": get_current_timestamp(),
                            "model": model,
                            "choices": [
                                {"index": 0, "delta": {}, "finish_reason": "stop"}
                            ],
                        }
                        yield f"data: {json.dumps(finish_data, ensure_ascii=False)}\n\n"
                        yield "data: [DONE]\n\n"
                    except Exception as e:
                        log_exception(f"流式生成器异常: {e}")
                        error_data = {
                            "error": {"message": str(e), "type": "server_error"}
                        }
                        yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"

                return StreamingResponse(
                    event_generator(), media_type="text/event-stream"
                )
            else:
                # 非流式响应
                response = Generation.call(
                    model=model,
                    messages=messages,
                    stream=False,
                    max_tokens=max_tokens,
                    temperature=temperature,
                    **dashscope_kwargs,
                )

                if response.status_code == 200:
                    # 检查响应是否包含预期的内容
                    # DashScope API的响应结构可能是 output.choices 或 output.text
                    content = None

                    # 尝试从 output.choices 获取内容
                    if (
                        hasattr(response, "output")
                        and response.output
                        and hasattr(response.output, "choices")
                        and response.output.choices is not None
                        and len(response.output.choices) > 0
                        and "message" in response.output.choices[0]
                    ):

                        msg_dict = response.output.choices[0]["message"]
                        content = msg_dict.get("content", "")
                        rc = msg_dict.get("reasoning_content", "")
                        if rc:
                            content = f"<think>{rc}</think>\n\n{content}"
                    # 否则尝试从 output.text 获取内容（DashScope特定格式）
                    elif (
                        hasattr(response, "output")
                        and response.output
                        and "text" in response.output
                    ):

                        content = response.output.get("text")

                    if content:
                        # 构建前端期望的响应格式
                        chat_response = format_api_response(
                            content=content,
                            conversation_id=body.get("conversationId"),
                            model=model,
                        )

                        if hasattr(response, "usage") and response.usage:
                            chat_response["usage"] = {
                                "promptTokens": response.usage.input_tokens,
                                "completionTokens": response.usage.output_tokens,
                                "totalTokens": response.usage.total_tokens,
                            }

                        return JSONResponse(content=chat_response, ensure_ascii=False)
                    else:
                        raise HTTPException(
                            status_code=500,
                            detail="API Response does not contain expected content",
                        )
                else:
                    raise HTTPException(
                        status_code=500,
                        detail=f"API Error: {response.code} - {response.message}",
                    )

    except Exception as e:
        print(f"[ERROR] Error in chat endpoint: {str(e)}")
        import traceback

        print(f"[ERROR] Traceback: {traceback.format_exc()}")
        raise HTTPException(status_code=500, detail=str(e))


async def multimodal_chat_handler(messages, model, stream, temperature, max_tokens):
    """
    多模态聊天处理器 - 处理包含图像的消息
    """
    try:
        # 将OpenAI格式的消息转换为DashScope MultiModalConversation格式
        dashscope_messages = []
        for i, msg in enumerate(messages):
            # 验证 msg 是否为字典类型，如果不是则跳过或处理为字符串
            if not isinstance(msg, dict):
                # 如果消息不是字典，将其作为纯文本处理
                dashscope_content = [{"text": str(msg)}]
                dashscope_messages.append(
                    {"role": "user", "content": dashscope_content}
                )
                continue

            role = msg.get("role", "user")
            content = msg.get("content", "")

            if isinstance(content, str):
                # 纯文本内容
                dashscope_content = [{"text": content}]
            elif isinstance(content, list):
                # 包含图像和文本的内容
                dashscope_content = []
                for j, item in enumerate(content):
                    if isinstance(item, dict):
                        if item.get("type") == "text":
                            dashscope_content.append({"text": item.get("text", "")})
                        elif item.get("type") == "image_url":
                            # 处理 image_url 可能是字符串或字典两种情况
                            image_url_value = item.get("image_url", "")
                            if isinstance(image_url_value, str):
                                # 如果 image_url 是字符串，直接使用
                                img_url = image_url_value
                            elif (
                                isinstance(image_url_value, dict)
                                and "url" in image_url_value
                            ):
                                # 如果 image_url 是字典，从中获取 url
                                img_url = image_url_value.get("url", "")
                            else:
                                # 其他情况视为错误或空值
                                img_url = ""

                            # 如果URL是http格式，提取文件名并转换为file://格式
                            if img_url.startswith("http://") or img_url.startswith(
                                "https://"
                            ):
                                # 提取URL中的文件名部分 (例如从 http://localhost:8000/uploads/filename.jpg 提取 uploads/filename.jpg)
                                from urllib.parse import urlparse

                                parsed_url = urlparse(img_url)
                                path_parts = parsed_url.path.split("/")

                                # 从路径中找到uploads部分及后面的文件名
                                try:
                                    uploads_index = path_parts.index("uploads")
                                    filename = "/".join(
                                        path_parts[uploads_index:]
                                    )  # 例如: uploads/filename.jpg
                                    img_url = f"file://{filename}"
                                except ValueError:
                                    # 如果路径中没有uploads部分，使用原始路径
                                    img_url = f"file://{parsed_url.path.lstrip('/')}"
                            elif not img_url.startswith("file://"):
                                # 如果既不是网络URL也不是file://协议，假设是相对路径
                                img_url = f"file://{img_url}"

                            if img_url.startswith("file://"):
                                # 确保本地文件存在
                                import os

                                local_path = img_url[7:]  # 移除 "file://" 前缀
                                if not os.path.exists(local_path):
                                    print(
                                        f"[WARNING] Image file does not exist: {local_path}"
                                    )

                            dashscope_content.append({"image": img_url})
                    else:
                        # 将非字典内容转换为文本
                        dashscope_content.append({"text": str(item)})
            else:
                # 其他情况转换为文本
                dashscope_content = [{"text": str(content)}]

            dashscope_messages.append({"role": role, "content": dashscope_content})

        if stream:
            # 多模态流式响应
            async def multimodal_event_generator():
                try:
                    responses = MultiModalConversation.call(
                        model=(
                            model.replace("qwen-", "qwen-vl-")
                            if "qwen-" in model
                            else "qwen-vl-max"
                        ),
                        messages=dashscope_messages,
                        stream=True,
                        max_tokens=max_tokens,
                        temperature=temperature,
                    )

                    full_content = ""

                    for response in responses:
                        if response.status_code == 200:
                            content = None

                            # 从多模态响应中提取内容
                            if (
                                hasattr(response, "output")
                                and response.output
                                and hasattr(response.output, "choices")
                                and response.output.choices is not None
                                and len(response.output.choices) > 0
                                and "message" in response.output.choices[0]
                            ):

                                message = response.output.choices[0]["message"]
                                if "content" in message:
                                    content_items = message["content"]

                                    # 从内容项中提取文本
                                    extracted_text = ""
                                    for item in content_items:
                                        if isinstance(item, dict) and "text" in item:
                                            extracted_text += item["text"]

                                    content = extracted_text

                                    # 只有当内容发生变化时才发送增量
                                    if len(content) > len(full_content):
                                        delta_content = extract_delta_content(
                                            content, full_content
                                        )
                                        full_content = content

                                        if delta_content.strip():
                                            data = {
                                                "id": f"chatcmpl-{generate_unique_id()}",
                                                "object": "chat.completion.chunk",
                                                "created": get_current_timestamp(),
                                                "model": model,
                                                "choices": [
                                                    {
                                                        "index": 0,
                                                        "delta": {
                                                            "content": delta_content
                                                        },
                                                        "finish_reason": None,
                                                    }
                                                ],
                                            }

                                            yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
                        else:
                            error_data = {
                                "error": {
                                    "message": f"Multimodal API Error: {response.code} - {response.message}",
                                    "type": "api_error",
                                    "param": None,
                                    "code": response.code,
                                }
                            }
                            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
                            break

                    finish_data = {
                        "id": f"chatcmpl-{generate_unique_id()}",
                        "object": "chat.completion.chunk",
                        "created": get_current_timestamp(),
                        "model": model,
                        "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
                    }
                    yield f"data: {json.dumps(finish_data, ensure_ascii=False)}\n\n"
                    yield "data: [DONE]\n\n"
                except Exception as e:
                    error_data = {"error": {"message": str(e), "type": "server_error"}}
                    yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"

            return StreamingResponse(
                multimodal_event_generator(), media_type="text/event-stream"
            )
        else:
            # 多模态非流式响应
            response = MultiModalConversation.call(
                model=(
                    model.replace("qwen-", "qwen-vl-")
                    if "qwen-" in model
                    else "qwen-vl-max"
                ),
                messages=dashscope_messages,
                stream=False,
                max_tokens=max_tokens,
                temperature=temperature,
            )

            if response.status_code == 200:
                content = None

                if (
                    hasattr(response, "output")
                    and response.output
                    and hasattr(response.output, "choices")
                    and response.output.choices is not None
                    and len(response.output.choices) > 0
                    and "message" in response.output.choices[0]
                ):

                    message = response.output.choices[0]["message"]
                    if "content" in message:
                        content_items = message["content"]

                        # 从内容项中提取文本
                        extracted_text = ""
                        for item in content_items:
                            if isinstance(item, dict) and "text" in item:
                                extracted_text += item["text"]

                        content = extracted_text

                if content:
                    return JSONResponse(content={"result": content}, ensure_ascii=False)
                else:
                    raise HTTPException(
                        status_code=500,
                        detail="Multimodal API Response does not contain expected content",
                    )
            else:
                raise HTTPException(
                    status_code=500,
                    detail=f"Multimodal API Error: {response.code} - {response.message}",
                )

    except Exception as e:
        print(f"[ERROR] Error in multimodal chat handler: {str(e)}")
        import traceback

        print(f"[ERROR] Traceback: {traceback.format_exc()}")
        raise HTTPException(status_code=500, detail=str(e))


async def get_models_handler():
    """获取模型列表处理器"""
    models = [
        ModelInfo(
            id="qwen-max",
            name="通义千问 Max",
            description="最强大的模型",
            maxTokens=8192,
            provider="Aliyun",
        ),
        ModelInfo(
            id="qwen-plus",
            name="通义千问 Plus",
            description="能力均衡",
            maxTokens=8192,
            provider="Aliyun",
        ),
        ModelInfo(
            id="qwen-turbo",
            name="通义千问 Turbo",
            description="速度更快、成本更低",
            maxTokens=8192,
            provider="Aliyun",
        ),
        ModelInfo(
            id="qwen-vl-max",
            name="通义万相 VL-Max",
            description="支持视觉理解的多模态模型",
            maxTokens=8192,
            provider="Aliyun",
        ),
        ModelInfo(
            id="qwen-vl-plus",
            name="通义万相 VL-Plus",
            description="支持视觉理解的多模态模型",
            maxTokens=8192,
            provider="Aliyun",
        ),
    ]
    return [model.dict() for model in models]


async def get_conversations_handler():
    """获取所有对话处理器"""
    return list(conversations_db.values())


async def get_conversation_handler(conversation_id: str):
    """获取特定对话处理器"""
    conversation = conversations_db.get(conversation_id)
    if not conversation:
        raise HTTPException(status_code=404, detail="对话不存在")
    return conversation


async def save_conversation_handler(data: dict):
    """保存或更新对话处理器"""
    try:
        conversation_id = data.get("id") or generate_unique_id()

        conversation = {
            "id": conversation_id,
            "title": data.get("title", "新对话"),
            "messages": data.get("messages", []),
            "updatedAt": datetime.utcnow().isoformat(),
            "createdAt": data.get("createdAt", datetime.utcnow().isoformat()),
        }

        conversations_db[conversation_id] = conversation
        return conversation

    except Exception as e:
        print(f"[ERROR] Error saving conversation: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


async def delete_conversation_handler(conversation_id: str):
    """删除对话处理器"""
    if conversation_id in conversations_db:
        del conversations_db[conversation_id]
        return {"success": True, "message": "删除成功"}
    else:
        raise HTTPException(status_code=404, detail="对话不存在")


async def upload_file_handler(file: UploadFile = File(...)):
    """文件上传处理器"""
    try:
        # 允许的 MIME 类型（宽松策略）
        allowed_types = {
            # 图片
            "image/jpeg",
            "image/png",
            "image/gif",
            "image/webp",
            "image/bmp",
            "image/svg+xml",
            # 文本类
            "text/plain",
            "text/csv",
            "text/markdown",
            "text/html",
            "text/xml",
            "application/json",
            "application/xml",
            # PDF
            "application/pdf",
            # Office 文档
            "application/msword",
            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            "application/vnd.ms-excel",
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "application/vnd.ms-powerpoint",
            "application/vnd.openxmlformats-officedocument.presentationml.presentation",
        }

        # 允许的扩展名（兜底：MIME 类型可能被浏览器误判）
        allowed_extensions = {
            ".jpg",
            ".jpeg",
            ".png",
            ".gif",
            ".webp",
            ".bmp",
            ".txt",
            ".md",
            ".csv",
            ".json",
            ".xml",
            ".yaml",
            ".yml",
            ".log",
            ".pdf",
            ".doc",
            ".docx",
            ".xls",
            ".xlsx",
            ".ppt",
            ".pptx",
            ".py",
            ".js",
            ".ts",
            ".html",
            ".css",
        }

        file_extension = Path(file.filename).suffix.lower()

        if (
            file.content_type not in allowed_types
            and file_extension not in allowed_extensions
        ):
            raise HTTPException(
                status_code=400,
                detail=f"不支持的文件类型: {file.content_type}（{file_extension}）",
            )

        # 生成唯一文件名
        unique_filename = f"{int(datetime.utcnow().timestamp())}_{generate_unique_id()}{file_extension}"
        file_path = upload_dir / unique_filename

        # 保存文件到本地（临时缓存）
        content = await file.read()
        with open(file_path, "wb") as f:
            f.write(content)

        # 文件关闭后再上传到 OSS
        from utils.oss_uploader import upload_file as oss_upload

        oss_result = oss_upload(str(file_path))
        file_url = oss_result["url"]

        # 返回文件信息
        result = {
            "url": file_url,
            "name": file.filename,
            "size": len(content),
            "mimeType": file.content_type,
        }

        print(f"[INFO] File uploaded: {result}")
        return result

    except Exception as e:
        print(f"[ERROR] Upload error: {str(e)}")
        raise HTTPException(status_code=500, detail=f"上传失败: {str(e)}")


def serve_upload_handler(filename: str):
    """提供上传文件访问处理器"""
    file_path = upload_dir / filename
    if not file_path.exists():
        raise HTTPException(status_code=404, detail="文件不存在")

    from fastapi.responses import FileResponse

    return FileResponse(str(file_path))


async def stop_generation_handler(message_id: str = None):
    """停止生成处理器"""
    message = (
        f"已发出停止指令，消息ID: {message_id}" if message_id else "已发出停止指令"
    )
    return {"success": True, "message": message}


# ── 平台统一接口别名（供 main.py 的 _platform 动态调用）─────────────
# main.py 通过 _platform.chat_handler / _platform.models_handler 调用，
# 各平台模块需暴露相同名称的函数。
chat_handler = chat_endpoint_handler  # 聊天接口别名
models_handler = get_models_handler  # 模型列表别名