import secrets
import time
import uuid
import hashlib
import json
import httpx
import logging
from typing import AsyncGenerator, List, Dict, Union
from pydantic import BaseModel, Field
from fastapi import FastAPI, HTTPException, Header
from fastapi.responses import StreamingResponse
from collections import OrderedDict
from datetime import datetime
import random,uvicorn

# 设置日志记录
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI()

# 配置
class Config(BaseModel):
    # API 密钥
    API_KEY: str = Field(
        default="sk_gUXNcLwm0rnnEt55Mg8hq88",
        description="API key for authentication"
    )
    
    # 最大历史记录数
    MAX_HISTORY: int = Field(
        default=30,
        description="Maximum number of conversation histories to keep"
    )
    
    # API 域名
    API_DOMAIN: str = Field(
        default="https://ai-api.dangbei.net",
        description="API Domain for requests"
    )
    
    # User Agents 列表
    USER_AGENTS: List[str] = Field(
        default=[
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
            "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
            "Mozilla/5.0 (iPad; CPU OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1"
        ],
        description="List of User Agent strings for requests"
    )

    # 每个设备 ID 最大会话数
    DEVICE_CONVERSATIONS_LIMIT: int = Field(
        default=10,
        description="Number of conversations before generating new device ID"
    )

# 创建全局配置实例
config = Config()

# 辅助函数：验证 API 密钥
async def verify_api_key(authorization: str = Header(None)):
    if not authorization:
        raise HTTPException(status_code=401, detail="Missing API key")
    
    api_key = authorization.replace("Bearer ", "").strip()
    if api_key != config.API_KEY:  # 使用配置中的 API_KEY
        raise HTTPException(status_code=401, detail="Invalid API key")
    return api_key

class Message(BaseModel):
    role: str
    content: str
    
    class Config:
        # 允许额外的字段
        extra = "allow"

class ChatRequest(BaseModel):
    model: str
    messages: List[Union[dict, Message]]  # 允许字典或 Message 对象
    stream: bool = False
    
    # 添加额外的可选字段，以适应更多的客户端请求
    temperature: float | None = None
    top_p: float | None = None
    n: int | None = None
    max_tokens: int | None = None
    presence_penalty: float | None = None
    frequency_penalty: float | None = None
    user: str | None = None
    
    class Config:
        # 允许额外的字段
        extra = "allow"
        # 允许从字典直接构造
        arbitrary_types_allowed = True

    @property
    def messages_as_dicts(self) -> List[dict]:
        """将消息转换为字典格式"""
        return [
            msg if isinstance(msg, dict) else msg.dict()
            for msg in self.messages
        ]

class ChatHistory:
    def __init__(self):
        self.current_device_id = None
        self.current_conversation_id = None
        self.conversation_count = 0
        self.total_conversations = 0  # 添加总会话计数

    def get_or_create_ids(self, force_new=False) -> tuple[str, str]:
        """
        获取或创建新的 device_id 和 conversation_id
        
        Args:
            force_new (bool): 是否强制创建新会话，用于清除上下文
            
        Returns:
            tuple[str, str]: (device_id, conversation_id)
        """
        # 检查是否需要创建新的设备 ID
        if (not self.current_device_id or 
            self.total_conversations >= config.DEVICE_CONVERSATIONS_LIMIT):
            self.current_device_id = self._generate_device_id()
            self.current_conversation_id = None
            self.conversation_count = 0
            self.total_conversations = 0
            logger.info(f"Generated new device ID: {self.current_device_id}")

        # 如果强制新建会话（清除上下文）或没有当前会话 ID
        if force_new or not self.current_conversation_id:
            self.current_conversation_id = None
            self.conversation_count = 0
            logger.info("Forcing new conversation")

        return self.current_device_id, self.current_conversation_id

    def add_conversation(self, conversation_id: str):
        """
        添加新的对话记录
        
        Args:
            conversation_id (str): 新的会话 ID
        """
        if not self.current_device_id:
            return
            
        self.current_conversation_id = conversation_id
        self.conversation_count += 1
        self.total_conversations += 1
        logger.info(f"Added conversation {conversation_id} (count: {self.conversation_count}, total: {self.total_conversations})")

    def _generate_device_id(self) -> str:
        """生成新的设备ID，并随机选择新的 USER_AGENT"""
        # 随机选择新的 USER_AGENT
        user_agent = random.choice(config.USER_AGENTS)
        logger.info(f"Selected new User-Agent: {user_agent}")
        
        uuid_str = uuid.uuid4().hex
        nanoid_str = ''.join(random.choices(
            "useandom26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict",
            k=20
        ))
        return f"{uuid_str}_{nanoid_str}"

class Pipe:
    def __init__(self):
        self.data_prefix = "data:"
        self.user_agent = random.choice(config.USER_AGENTS)  # 初始化时随机选择一个 USER_AGENT
        self.chat_history = ChatHistory()
        # 添加支持联网的模型映射，保持实际请求时使用小写
        self.search_models = {
            "DeepSeek-R1-Search": "deepseek",
            "DeepSeek-V3-Search": "deepseek",
            "Doubao-Search": "doubao",    # 显示用大写，映射用小写
            "Qwen-Search": "qwen"         # 显示用大写，映射用小写
        }

    def _build_full_prompt(self, messages: List[Dict]) -> str:
        """构建完整的提示，包含系统提示、聊天历史和当前问题"""
        if not messages:
            return ''
            
        system_prompt = ''
        history = []
        last_user_message = ''
        
        # 修改消息处理逻辑，直接使用字典访问
        for msg in messages:
            if msg['role'] == 'system' and not system_prompt:
                system_prompt = msg['content']
            elif msg['role'] == 'user':
                history.append(f"user: {msg['content']}")
                last_user_message = msg['content']
            elif msg['role'] == 'assistant':
                history.append(f"assistant: {msg['content']}")
        
        # 构建最终提示
        parts = []
        if system_prompt:
            parts.append(f"[System Prompt]\n{system_prompt}")
        if len(history) > 1:  # 如果有历史对话
            parts.append(f"[Chat History]\n{chr(10).join(history[:-1])}")
        parts.append(f"[Question]\n{last_user_message}")
        
        return chr(10).join(parts)

    async def pipe(self, body: dict) -> AsyncGenerator[Dict, None]:
        thinking_state = {"thinking": -1}
        
        try:
            # 构建完整提示
            full_prompt = self._build_full_prompt(body["messages"])
            
            # 修改 force_new_context 的判断逻辑
            force_new_context = False
            messages = body["messages"]
            if len(messages) == 1:  # 只有一条消息时，说明是新对话
                force_new_context = True
            elif len(messages) >= 2:  # 检查是否清除了历史
                last_two = messages[-2:]
                if last_two[0]["role"] == "user" and last_two[1]["role"] == "user":
                    force_new_context = True
            
            # 获取或创建设备ID和会话ID
            device_id, conversation_id = self.chat_history.get_or_create_ids(force_new_context)
            
            # 添加会话信息日志
            logger.info(f"Current session - Device ID: {device_id}, Conversation ID: {conversation_id}, Force new: {force_new_context}, Messages count: {len(messages)}")

            # 如果没有会话ID，创建新的会话
            if not conversation_id:
                conversation_id = await self._create_conversation(device_id)
                if not conversation_id:
                    yield {"error": "Failed to create conversation"}
                    return
                # 保存新的对话记录
                self.chat_history.add_conversation(conversation_id)
                logger.info(f"Created new conversation: {conversation_id}")

            # 模型名称处理
            model_name = None
            is_search_model = body["model"].endswith("-Search")
            if is_search_model:
                # 如果是搜索模型，使用映射的基础模型名
                base_model = body["model"].replace("-Search", "")
                model_name = self.search_models.get(body["model"], base_model.lower())
            else:
                # 非搜索模型使用原有逻辑
                is_deepseek_model = body["model"] in ["DeepSeek-R1", "DeepSeek-V3"]
                model_name = "deepseek" if is_deepseek_model else body["model"].lower()  # 确保转换为小写

            # 确定 userAction 参数
            user_action = ""
            if "DeepSeek-R1" in body["model"]:
                user_action = "deep"
            if is_search_model:
                # 如果已经有值，添加逗号分隔
                if user_action:
                    user_action += ",online"
                else:
                    user_action = "online"  # 为联网模型设置 userAction 为 "online"

            payload = {
                "stream": True,
                "botCode": "AI_SEARCH",
                "userAction": user_action,
                "model": model_name,
                "conversationId": conversation_id,
                "question": full_prompt,
            }

            timestamp = str(int(time.time()))
            nonce = self._nanoid(21)
            sign = self._generate_sign(timestamp, payload, nonce)

            headers = {
                "Origin": "https://ai.dangbei.com",
                "Referer": "https://ai.dangbei.com/",
                "User-Agent": self.user_agent,
                "deviceId": device_id,
                "nonce": nonce,
                "sign": sign,
                "timestamp": timestamp,
            }

            api = f"{config.API_DOMAIN}/ai-search/chatApi/v1/chat"  # 使用配置中的 API_DOMAIN

            async with httpx.AsyncClient() as client:
                async with client.stream("POST", api, json=payload, headers=headers, timeout=1200) as response:
                    if response.status_code != 200:
                        error = await response.aread()
                        yield {"error": self._format_error(response.status_code, error)}
                        return

                    card_messages = []  # 用于收集卡片消息
                    
                    async for line in response.aiter_lines():
                        if not line.startswith(self.data_prefix):
                            continue

                        json_str = line[len(self.data_prefix):]

                        try:
                            data = json.loads(json_str)
                        except json.JSONDecodeError as e:
                            yield {"error": f"JSONDecodeError: {str(e)}", "data": json_str}
                            return

                        if data.get("type") == "answer":
                            content = data.get("content")
                            content_type = data.get("content_type")
                            
                            # 处理思考状态
                            if thinking_state["thinking"] == -1 and content_type == "thinking":
                                thinking_state["thinking"] = 0
                                yield {"choices": [{"delta": {"content": "<think>\n\n"}, "finish_reason": None}]}
                            elif thinking_state["thinking"] == 0 and content_type == "text":
                                thinking_state["thinking"] = 1
                                yield {"choices": [{"delta": {"content": "\n"}, "finish_reason": None}]}
                                yield {"choices": [{"delta": {"content": "</think>"}, "finish_reason": None}]}
                                yield {"choices": [{"delta": {"content": "\n\n"}, "finish_reason": None}]}
                            
                            # 处理卡片内容
                            if content_type == "card":
                                try:
                                    card_content = json.loads(content)
                                    card_items = card_content["cardInfo"]["cardItems"]
                                    markdown_output = "\n\n---\n\n"
                                    
                                    # 处理搜索关键词（type: 2001）
                                    search_keywords = next((item for item in card_items if item["type"] == "2001"), None)
                                    if search_keywords:
                                        keywords = json.loads(search_keywords["content"])
                                        markdown_output += f"搜索关键字：{'; '.join(keywords)}\n"
                                    
                                    # 处理搜索结果（type: 2002）
                                    search_results = next((item for item in card_items if item["type"] == "2002"), None)
                                    if search_results:
                                        results = json.loads(search_results["content"])
                                        markdown_output += f"共找到 {len(results)} 个搜索结果：\n"
                                        for result in results:
                                            markdown_output += f"[{result['idIndex']}] [{result['name']}]({result['url']}) 来源：{result['siteName']}\n"
                                    
                                    card_messages.append(markdown_output)
                                except Exception as e:
                                    logger.error(f"Error processing card: {str(e)}")

                            # 处理普通文本内容
                            if content and content_type in ["text", "thinking"]:
                                yield {"choices": [{"delta": {"content": content}, "finish_reason": None}]}

                    # 在最后输出所有卡片消息
                    if card_messages:
                        yield {"choices": [{"delta": {"content": "".join(card_messages)}, "finish_reason": None}]}

                    # 在最后添加元数据
                    yield {"choices": [{"delta": {"meta": {
                        "device_id": device_id,
                        "conversation_id": conversation_id
                    }}, "finish_reason": None}]}

        except Exception as e:
            logger.error(f"Error in pipe: {str(e)}")
            yield {"error": self._format_exception(e)}

    def _format_error(self, status_code: int, error: bytes) -> str:
        error_str = error.decode(errors="ignore") if isinstance(error, bytes) else error
        return json.dumps({"error": f"HTTP {status_code}: {error_str}"}, ensure_ascii=False)

    def _format_exception(self, e: Exception) -> str:
        return json.dumps({"error": f"{type(e).__name__}: {str(e)}"}, ensure_ascii=False)

    def _nanoid(self, size=21) -> str:
        url_alphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"
        random_bytes = secrets.token_bytes(size)
        return "".join([url_alphabet[b & 63] for b in reversed(random_bytes)])

    def _generate_sign(self, timestamp: str, payload: dict, nonce: str) -> str:
        payload_str = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
        sign_str = f"{timestamp}{payload_str}{nonce}"
        return hashlib.md5(sign_str.encode("utf-8")).hexdigest().upper()

    async def _create_conversation(self, device_id: str) -> str:
        """创建新的会话"""
        payload = {"botCode": "AI_SEARCH"}
        timestamp = str(int(time.time()))
        nonce = self._nanoid(21)
        sign = self._generate_sign(timestamp, payload, nonce)

        headers = {
            "Origin": "https://ai.dangbei.com",
            "Referer": "https://ai.dangbei.com/",
            "User-Agent": self.user_agent,
            "deviceId": device_id,
            "nonce": nonce,
            "sign": sign,
            "timestamp": timestamp,
        }

        api = f"{config.API_DOMAIN}/ai-search/conversationApi/v1/create"
        try:
            async with httpx.AsyncClient() as client:
                response = await client.post(api, json=payload, headers=headers)
                if response.status_code == 200:
                    data = response.json()
                    if data.get("success"):
                        return data["data"]["conversationId"]
        except Exception as e:
            logger.error(f"Error creating conversation: {str(e)}")
        return None

# 创建实例
pipe = Pipe()

@app.post("/v1/chat/completions")
async def chat(request: ChatRequest, authorization: str = Header(None)):
    """
    OpenAI API 兼容的 Chat 端点
    """
    # 添加请求日志
    logger.info(f"Received chat request: {request.model_dump()}")
    
    await verify_api_key(authorization)

    # 使用 messages_as_dicts 属性
    request_data = request.model_dump()
    request_data['messages'] = request.messages_as_dicts

    async def response_generator():
        """流式响应生成器"""
        thinking_content = []
        is_thinking = False
        
        async for chunk in pipe.pipe(request_data):
            if "choices" in chunk and chunk["choices"]:
                delta = chunk["choices"][0]["delta"]
                if "content" in delta:
                    content = delta["content"]
                    if content == "<think>\n":
                        is_thinking = True
                    elif content == "\n</think>\n\n":
                        is_thinking = False
                    if is_thinking and content != "<think>\n":
                        thinking_content.append(content)
            
            yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
        yield "data: [DONE]\n\n"

    if request.stream:
        return StreamingResponse(response_generator(), media_type="text/event-stream")

    # 非流式响应
    content = ""
    meta = None
    try:
        async for chunk in pipe.pipe(request_data):
            if "choices" in chunk and chunk["choices"]:
                delta = chunk["choices"][0]["delta"]
                if "content" in delta:
                    content += delta["content"]
                if "meta" in delta:
                    meta = delta["meta"]
    except Exception as e:
        logger.error(f"Error processing chat request: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal Server Error")

    parts = content.split("\n\n\n", 1)
    reasoning_content = parts[0] if len(parts) > 0 else ""
    content = parts[1] if len(parts) > 1 else ""

    # 处理嵌套的 think 标签和特殊字符
    if reasoning_content:
        # 先尝试找到最外层的 think 标签
        start_idx = reasoning_content.find("<think>")
        end_idx = reasoning_content.rfind("</think>")
        
        if start_idx != -1 and end_idx != -1:
            # 如果找到了完整的外层标签，提取其中的内容
            inner_content = reasoning_content[start_idx + 7:end_idx].strip()
            # 移除内部的 think 标签
            inner_content = inner_content.replace("<think>", "").replace("</think>", "").strip()
            reasoning_content = f"<think>\n{inner_content}\n</think>"
        else:
            # 如果没有找到完整的标签，则移除所有 think 标签并重新添加
            reasoning_content = reasoning_content.replace("<think>", "").replace("</think>", "").strip()
            reasoning_content = f"<think>\n{reasoning_content}\n</think>"

    return {
        "id": str(uuid.uuid4()),
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "message": {
                "role": "assistant",
                "reasoning_content": reasoning_content,
                "content": content,
                "meta": meta
            },
            "finish_reason": "stop"
        }]
    }

@app.get("/v1/models")
async def get_models(authorization: str = Header(None)):
    # 验证 API 密钥
    await verify_api_key(authorization)
    
    current_time = int(time.time())
    return {
        "object": "list",
        "data": [
            # 原始模型
            {
                "id": "DeepSeek-R1",
                "object": "model",
                "created": current_time,
                "owned_by": "library"
            },
            {
                "id": "DeepSeek-V3",
                "object": "model",
                "created": current_time,
                "owned_by": "library"
            },
            {
                "id": "Doubao",  # 改为大写开头
                "object": "model",
                "created": current_time,
                "owned_by": "library"
            },
            {
                "id": "Qwen",    # 改为大写开头
                "object": "model",
                "created": current_time,
                "owned_by": "library"
            },
            # 支持联网的模型
            {
                "id": "DeepSeek-R1-Search",
                "object": "model",
                "created": current_time,
                "owned_by": "library",
                "features": ["online_search"]
            },
            {
                "id": "DeepSeek-V3-Search",
                "object": "model",
                "created": current_time,
                "owned_by": "library",
                "features": ["online_search"]
            },
            {
                "id": "Doubao-Search",  # 改为大写开头
                "object": "model",
                "created": current_time,
                "owned_by": "library",
                "features": ["online_search"]
            },
            {
                "id": "Qwen-Search",    # 改为大写开头
                "object": "model",
                "created": current_time,
                "owned_by": "library",
                "features": ["online_search"]
            }
        ]
    }
@app.get("/")
def index():
    return "it's work!"


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)