from flask import Flask, request, make_response
import hashlib
import time
import xml.etree.ElementTree as ET
import os
import json
from openai import OpenAI
from dotenv import load_dotenv
from markdown import markdown
import re
import threading
import logging
from datetime import datetime
import asyncio
from concurrent.futures import ThreadPoolExecutor
import queue
import uuid
import base64
from Crypto.Cipher import AES
import struct
import random
import string
import requests

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('wechat_service.log'),
        logging.StreamHandler()
    ]
)

load_dotenv()

app = Flask(__name__)

# Configuration
TOKEN = os.getenv('TOKEN')
ENCODING_AES_KEY = os.getenv('ENCODING_AES_KEY')
APPID = os.getenv('APPID')
APPSECRET = os.getenv('APPSECRET')  # 新增 AppSecret
API_KEY = os.getenv("API_KEY")
BASE_URL = os.getenv("OPENAI_BASE_URL")
IMAGE_MODEL_URL = os.getenv("IMAGE_MODEL_URL")
IMAGE_MODEL_KEY = os.getenv("IMAGE_MODEL_KEY")

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
executor = ThreadPoolExecutor(max_workers=10)


# Define tools for image generation
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "generate_image",
            "description": "Generate an image based on text description",
            "parameters": {
                "type": "object",
                "properties": {
                    "prompt": {
                        "type": "string",
                        "description": "The description of the image to generate"
                    }
                },
                "required": ["prompt"]
            }
        }
    }
]
class AccessTokenManager:
    def __init__(self):
        self._access_token = None
        self._expires_at = 0
        self._lock = threading.Lock()

    def get_token(self):
        with self._lock:
            now = time.time()
            # 提前5分钟刷新token，确保在调用时token都是有效的
            if self._access_token and now < (self._expires_at - 300):
                return self._access_token

            try:
                url = "https://api.weixin.qq.com/cgi-bin/token"
                params = {
                    "grant_type": "client_credential",
                    "appid": APPID,
                    "secret": APPSECRET
                }
                
                logging.info("开始获取新的access_token")
                response = requests.get(url, params=params)
                response.raise_for_status()
                result = response.json()
                
                if "access_token" not in result:
                    error_msg = f"获取access_token失败: {result}"
                    logging.error(error_msg)
                    raise ValueError(error_msg)
                
                self._access_token = result["access_token"]
                self._expires_at = now + result["expires_in"]
                logging.info("成功获取新的access_token")
                
                return self._access_token
                
            except Exception as e:
                error_msg = f"获取access_token时发生错误: {str(e)}"
                logging.error(error_msg)
                raise

    def refresh_token(self):
        with self._lock:
            self._access_token = None
            return self.get_token()
            
class WeChatCrypto:
    def __init__(self, key, app_id):
        self.key = base64.b64decode(key + '=')
        self.app_id = app_id

    def encrypt(self, text):
        random_str = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
        text_bytes = text.encode('utf-8')
        msg_len = struct.pack('>I', len(text_bytes))
        message = random_str.encode('utf-8') + msg_len + text_bytes + self.app_id.encode('utf-8')
        pad_len = 32 - (len(message) % 32)
        message += chr(pad_len).encode('utf-8') * pad_len
        cipher = AES.new(self.key, AES.MODE_CBC, self.key[:16])
        encrypted = cipher.encrypt(message)
        return base64.b64encode(encrypted).decode('utf-8')

    def decrypt(self, encrypted_text):
        encrypted_data = base64.b64decode(encrypted_text)
        cipher = AES.new(self.key, AES.MODE_CBC, self.key[:16])
        decrypted = cipher.decrypt(encrypted_data)
        pad_len = decrypted[-1]
        if not isinstance(pad_len, int):
            pad_len = ord(pad_len)
        content = decrypted[16:-pad_len]
        msg_len = struct.unpack('>I', content[:4])[0]
        xml_content = content[4:msg_len + 4].decode('utf-8')
        app_id = content[msg_len + 4:].decode('utf-8')
        if app_id != self.app_id:
            raise ValueError('Invalid AppID')
        return xml_content

class AsyncResponse:
    def __init__(self):
        self.status = "processing"
        self.result = None
        self.error = None
        self.create_time = time.time()
        self.timeout = 3600
        self.response_type = "text"  # Can be "text" or "image"
        self.media_id = None  # For image responses

    def is_expired(self):
        return time.time() - self.create_time > self.timeout

class UserSession:
    def __init__(self):
        self.messages = [{"role": "system", "content": "你是HXIAO公众号的智能助手，这一个用来分享与学习人工智能的公众号，我们的目标是专注AI应用的简单研究与实践。致力于分享切实可行的技术方案，希望让复杂的技术变得简单易懂。也喜欢用通俗的语言来解释专业概念，让技术真正服务于每个学习者"}]
        self.pending_parts = []
        self.last_active = time.time()
        self.current_task = None
        self.response_queue = {}
        self.session_timeout = 3600

    def is_expired(self):
        return time.time() - self.last_active > self.session_timeout

    def cleanup_expired_tasks(self):
        expired_tasks = [
            task_id for task_id, response in self.response_queue.items()
            if response.is_expired()
        ]
        for task_id in expired_tasks:
            del self.response_queue[task_id]
            if self.current_task == task_id:
                self.current_task = None

class SessionManager:
    def __init__(self):
        self.sessions = {}
        self._lock = threading.Lock()
        self.crypto = WeChatCrypto(ENCODING_AES_KEY, APPID)

    def get_session(self, user_id):
        with self._lock:
            current_time = time.time()
            if user_id in self.sessions:
                session = self.sessions[user_id]
                if session.is_expired():
                    session = UserSession()
                else:
                    session.cleanup_expired_tasks()
            else:
                session = UserSession()
            session.last_active = current_time
            self.sessions[user_id] = session
            return session

    def clear_session(self, user_id):
        with self._lock:
            if user_id in self.sessions:
                self.sessions[user_id] = UserSession()

    def cleanup_expired_sessions(self):
        with self._lock:
            current_time = time.time()
            expired_users = [
                user_id for user_id, session in self.sessions.items()
                if session.is_expired()
            ]
            for user_id in expired_users:
                del self.sessions[user_id]
                logging.info(f"已清理过期会话: {user_id}")

def convert_markdown_to_wechat(md_text):
    if not md_text:
        return md_text
        
    md_text = re.sub(r'^# (.*?)$', r'【标题】\1', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'^## (.*?)$', r'【子标题】\1', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'^### (.*?)$', r'【小标题】\1', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'\*\*(.*?)\*\*', r'『\1』', md_text)
    md_text = re.sub(r'\*(.*?)\*', r'「\1」', md_text)
    md_text = re.sub(r'`(.*?)`', r'「\1」', md_text)
    md_text = re.sub(r'^\- ', '• ', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'^\d\. ', '○ ', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'```[\w]*\n(.*?)```', r'【代码开始】\n\1\n【代码结束】', md_text, flags=re.DOTALL)
    md_text = re.sub(r'^> (.*?)$', r'▎\1', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'^-{3,}$', r'—————————', md_text, flags=re.MULTILINE)
    md_text = re.sub(r'\[(.*?)\]\((.*?)\)', r'\1（\2）', md_text)
    md_text = re.sub(r'\n{3,}', '\n\n', md_text)
    
    return md_text

def verify_signature(signature, timestamp, nonce, token):
    items = [token, timestamp, nonce]
    items.sort()
    temp_str = ''.join(items)
    hash_sha1 = hashlib.sha1(temp_str.encode('utf-8')).hexdigest()
    return hash_sha1 == signature

def verify_msg_signature(msg_signature, timestamp, nonce, token, encrypt_msg):
    """
    验证消息签名
    Args:
        msg_signature: 消息签名
        timestamp: 时间戳
        nonce: 随机数
        token: 验证令牌
        encrypt_msg: 加密的消息内容
    Returns:
        bool: 签名是否有效
    """
    items = [token, timestamp, nonce, encrypt_msg]
    items.sort()
    temp_str = ''.join(items)
    hash_sha1 = hashlib.sha1(temp_str.encode('utf-8')).hexdigest()
    return hash_sha1 == msg_signature


def parse_xml_message(xml_content):
    """
    解析微信XML消息，支持文本和图片消息类型
    """
    root = ET.fromstring(xml_content)
    message = {
        'from_user': root.find('FromUserName').text,
        'to_user': root.find('ToUserName').text,
        'create_time': root.find('CreateTime').text,
        'msg_type': root.find('MsgType').text,
        'msg_id': root.find('MsgId').text if root.find('MsgId') is not None else '',
        'msg_data_id': root.find('MsgDataId').text if root.find('MsgDataId') is not None else '',
        'idx': root.find('Idx').text if root.find('Idx') is not None else ''
    }
    
    if message['msg_type'] == 'text':
        message['content'] = root.find('Content').text if root.find('Content') is not None else ''
    elif message['msg_type'] == 'image':
        message['pic_url'] = root.find('PicUrl').text
        message['media_id'] = root.find('MediaId').text
    
    return message

def get_image_content(media_id):
    """
    通过微信接口获取图片内容
    """
    try:
        access_token = token_manager.get_token()
        url = f'https://api.weixin.qq.com/cgi-bin/media/get?access_token={access_token}&media_id={media_id}'
        
        logging.info(f"开始下载图片，media_id: {media_id}")
        response = requests.get(url)
        
        if response.headers.get('Content-Type') == 'text/plain':
            # 如果返回JSON错误信息
            error_info = response.json()
            if error_info.get('errcode') == 40001:
                # access_token过期，刷新后重试
                logging.info("access_token已过期，正在刷新并重试")
                access_token = token_manager.refresh_token()
                url = f'https://api.weixin.qq.com/cgi-bin/media/get?access_token={access_token}&media_id={media_id}'
                response = requests.get(url)
        
        response.raise_for_status()
        return response.content
        
    except Exception as e:
        logging.error(f"获取图片内容失败: {str(e)}")
        raise


def generate_response_xml(to_user, from_user, content, response_type='text', media_id=None, encrypt_type='aes'):
    timestamp = str(int(time.time()))
    nonce = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
    
    if response_type == 'image' and media_id:
        xml_content = f'''
        <xml>
            <ToUserName><![CDATA[{to_user}]]></ToUserName>
            <FromUserName><![CDATA[{from_user}]]></FromUserName>
            <CreateTime>{timestamp}</CreateTime>
            <MsgType><![CDATA[image]]></MsgType>
            <Image>
                <MediaId><![CDATA[{media_id}]]></MediaId>
            </Image>
        </xml>
        '''
    else:
        formatted_content = convert_markdown_to_wechat(content)
        xml_content = f'''
        <xml>
            <ToUserName><![CDATA[{to_user}]]></ToUserName>
            <FromUserName><![CDATA[{from_user}]]></FromUserName>
            <CreateTime>{timestamp}</CreateTime>
            <MsgType><![CDATA[text]]></MsgType>
            <Content><![CDATA[{formatted_content}]]></Content>
        </xml>
        '''
    
    if encrypt_type == 'aes':
        encrypted = session_manager.crypto.encrypt(xml_content)
        signature_list = [TOKEN, timestamp, nonce, encrypted]
        signature_list.sort()
        msg_signature = hashlib.sha1(''.join(signature_list).encode('utf-8')).hexdigest()
        
        response_xml = f'''
        <xml>
            <Encrypt><![CDATA[{encrypted}]]></Encrypt>
            <MsgSignature><![CDATA[{msg_signature}]]></MsgSignature>
            <TimeStamp>{timestamp}</TimeStamp>
            <Nonce><![CDATA[{nonce}]]></Nonce>
        </xml>
        '''
    else:
        response_xml = xml_content
    
    response = make_response(response_xml)
    response.content_type = 'application/xml'
    return response
    
# 创建全局的token管理器实例
token_manager = AccessTokenManager()
def upload_image_to_wechat(image_data):
    """上传图片到微信服务器并获取media_id"""
    try:
        access_token = token_manager.get_token()
        upload_url = f'https://api.weixin.qq.com/cgi-bin/media/upload?access_token={access_token}&type=image'
        files = {'media': ('image.jpg', image_data, 'image/jpeg')}
        
        logging.info("开始上传图片到微信服务器")
        response = requests.post(upload_url, files=files)
        response.raise_for_status()
        result = response.json()
        
        if 'media_id' not in result:
            if 'errcode' in result and result['errcode'] == 40001:
                # access_token 可能过期，尝试刷新并重试
                logging.info("access_token已过期，正在刷新并重试")
                access_token = token_manager.refresh_token()
                upload_url = f'https://api.weixin.qq.com/cgi-bin/media/upload?access_token={access_token}&type=image'
                response = requests.post(upload_url, files=files)
                response.raise_for_status()
                result = response.json()
            
            if 'media_id' not in result:
                error_msg = f"上传图片失败: {result}"
                logging.error(error_msg)
                raise ValueError(error_msg)
        
        logging.info(f"图片上传成功，获取到media_id")
        return result['media_id']
        
    except Exception as e:
        error_msg = f"上传图片过程中发生错误: {str(e)}"
        logging.error(error_msg)
        raise

# def process_long_running_task(messages, message_type='text', image_data=None):
#     """
#     处理长时间运行的任务，支持文本对话和图片识别
#     Args:
#         messages: 消息历史记录列表
#         message_type: 消息类型，'text'或'image'
#         image_data: 图片相关数据，包含media_id等信息
#     Returns:
#         dict: 包含处理结果的字典
#     """
#     try:
#         logging.info(f"开始调用AI服务，消息类型: {message_type}")
        
#         if message_type == 'image':
#             try:
#                 # 获取图片内容
#                 image_content = get_image_content(image_data['media_id'])
#                 # 将图片内容转换为base64
#                 image_base64 = base64.b64encode(image_content).decode('utf-8')
                
#                 # 构建图像识别请求
#                 image_messages = [
#                     {
#                         "role": "user",
#                         "content": [
#                             {"type": "text", "text": "请详细描述这张图片中的内容，包括主要对象、场景、活动等关键信息"},
#                             {
#                                 "type": "image_url",
#                                 "image_url": {
#                                     "url": f"data:image/jpeg;base64,{image_base64}"
#                                 }
#                             }
#                         ]
#                     }
#                 ]
                
#                 logging.info("开始调用图像识别模型")
#                 image_response = client.chat.completions.create(
#                     model="gpt-4o-mini",
#                     messages=image_messages,
#                     max_tokens=300,
#                     timeout=60
#                 )
#                 logging.info("图像识别完成")
                
#                 # 检查响应是否成功
#                 if not image_response.choices:
#                     raise Exception("图像识别服务未返回有效结果")
                    
#                 return {
#                     "type": "text",
#                     "content": image_response.choices[0].message.content
#                 }
                
#             except requests.exceptions.RequestException as e:
#                 logging.error(f"获取或处理图片时发生网络错误: {str(e)}")
#                 raise
#             except Exception as e:
#                 logging.error(f"图像识别过程中发生错误: {str(e)}")
#                 raise
                
#         else:
#             # 处理文本消息
#             try:
#                 logging.info("开始处理文本消息")
#                 response = client.chat.completions.create(
#                     model="o3-mini",
#                     messages=messages,
#                     tools=TOOLS,
#                     tool_choice="auto",
#                     timeout=60
#                 )
                
#                 # 检查是否需要生成图片
#                 if response.choices[0].message.tool_calls:
#                     tool_call = response.choices[0].message.tool_calls[0]
#                     if tool_call.function.name == "generate_image":
#                         try:
#                             logging.info("检测到图片生成请求")
#                             args = json.loads(tool_call.function.arguments)
                            
#                             # 调用图片生成服务
#                             image_generation_response = requests.post(
#                                 IMAGE_MODEL_URL,
#                                 headers={
#                                     'Content-Type': 'application/json',
#                                     'Authorization': f'Bearer {IMAGE_MODEL_KEY}'
#                                 },
#                                 json={
#                                     "model": "grok-2-imageGen",
#                                     "messages": [{
#                                         "role": "user",
#                                         "content": args['prompt']
#                                     }]
#                                 },
#                                 timeout=60
#                             )
#                             image_generation_response.raise_for_status()
#                             generation_result = image_generation_response.json()
                            
#                             if 'choices' not in generation_result or not generation_result['choices']:
#                                 raise Exception("图片生成服务未返回有效结果")
                                
#                             # 从markdown格式中提取URL
#                             markdown_content = generation_result['choices'][0]['message']['content']
#                             image_url_match = re.search(r'\!\[image\]\((.*?)\)', markdown_content)
#                             if not image_url_match:
#                                 raise Exception("无法从响应中提取图片URL")
                                
#                             image_url = image_url_match.group(1)
                            
#                             # 下载生成的图片
#                             img_response = requests.get(image_url, timeout=30)
#                             img_response.raise_for_status()
                            
#                             # 上传图片到微信服务器
#                             media_id = upload_image_to_wechat(img_response.content)
                            
#                             return {
#                                 "type": "image",
#                                 "media_id": media_id
#                             }
                            
#                         except requests.exceptions.RequestException as e:
#                             logging.error(f"图片生成过程中发生网络错误: {str(e)}")
#                             raise
#                         except Exception as e:
#                             logging.error(f"图片生成过程中发生错误: {str(e)}")
#                             raise
                
#                 # 返回文本响应
#                 return {
#                     "type": "text",
#                     "content": response.choices[0].message.content
#                 }
                
#             except requests.exceptions.RequestException as e:
#                 logging.error(f"处理文本消息时发生网络错误: {str(e)}")
#                 raise
#             except Exception as e:
#                 logging.error(f"处理文本消息时发生错误: {str(e)}")
#                 raise
                
#     except Exception as e:
#         logging.error(f"API调用错误: {str(e)}")
#         raise
def process_long_running_task(messages, message_type='text', image_data=None):
    """
    处理长时间运行的任务，支持文本对话和图片识别
    """
    try:
        logging.info(f"开始调用AI服务，消息类型: {message_type}")
        
        if message_type == 'image':
            # 图片识别逻辑保持不变
            try:
                image_content = get_image_content(image_data['media_id'])
                image_base64 = base64.b64encode(image_content).decode('utf-8')
                
                image_messages = [
                    {
                        "role": "user",
                        "content": [
                            {"type": "text", "text": "请详细描述这张图片中的内容，包括主要对象、场景、活动等关键信息"},
                            {
                                "type": "image_url",
                                "image_url": {
                                    "url": f"data:image/jpeg;base64,{image_base64}"
                                }
                            }
                        ]
                    }
                ]
                
                logging.info("开始调用图像识别模型")
                image_response = client.chat.completions.create(
                    model="gpt-4o-mini",
                    messages=image_messages,
                    max_tokens=300,
                    timeout=60
                )
                logging.info("图像识别完成")
                
                if not image_response.choices:
                    raise Exception("图像识别服务未返回有效结果")
                    
                return {
                    "type": "text",
                    "content": image_response.choices[0].message.content
                }
                
            except Exception as e:
                logging.error(f"图像识别过程中发生错误: {str(e)}")
                raise
                
        else:
            # 处理文本消息
            try:
                logging.info("开始处理文本消息")
                response = client.chat.completions.create(
                    model="o3-mini",
                    messages=messages,
                    tools=TOOLS,
                    tool_choice="auto",
                    timeout=60
                )
                
                # 检查是否需要生成图片
                if response.choices[0].message.tool_calls:
                    tool_call = response.choices[0].message.tool_calls[0]
                    if tool_call.function.name == "generate_image":
                        try:
                            logging.info("检测到图片生成请求")
                            args = json.loads(tool_call.function.arguments)
                            
                            # 使用新的DALL-E 3 API进行图片生成
                            image_generation_response = requests.post(
                                "https://api1.oaipro.com/v1/images/generations",
                                headers={
                                    'Content-Type': 'application/json',
                                    'Authorization': f'Bearer {API_KEY}'
                                },
                                json={
                                    "model": "dall-e-3",
                                    "prompt": args['prompt'],
                                    "n": 1,
                                    "size": "1024x1024"
                                },
                                timeout=60
                            )
                            image_generation_response.raise_for_status()
                            generation_result = image_generation_response.json()
                            
                            if 'data' not in generation_result or not generation_result['data']:
                                raise Exception("图片生成服务未返回有效结果")
                            
                            # 获取生成的图片URL
                            image_url = generation_result['data'][0]['url']
                            
                            # 下载生成的图片
                            img_response = requests.get(image_url, timeout=30)
                            img_response.raise_for_status()
                            
                            # 上传图片到微信服务器
                            media_id = upload_image_to_wechat(img_response.content)
                            
                            return {
                                "type": "image",
                                "media_id": media_id
                            }
                            
                        except requests.exceptions.RequestException as e:
                            logging.error(f"图片生成过程中发生网络错误: {str(e)}")
                            raise
                        except Exception as e:
                            logging.error(f"图片生成过程中发生错误: {str(e)}")
                            raise
                
                # 返回文本响应
                return {
                    "type": "text",
                    "content": response.choices[0].message.content
                }
                
            except requests.exceptions.RequestException as e:
                logging.error(f"处理文本消息时发生网络错误: {str(e)}")
                raise
            except Exception as e:
                logging.error(f"处理文本消息时发生错误: {str(e)}")
                raise
                
    except Exception as e:
        logging.error(f"API调用错误: {str(e)}")
        raise

def handle_async_task(session, task_id, messages=None, message_type='text', message_data=None):
    """
    处理异步任务，支持文本对话和图片识别
    """
    try:
        logging.info(f"开始处理异步任务: {task_id}, 类型: {message_type}")
        
        if task_id not in session.response_queue:
            return
            
        if message_type == 'image':
            result = process_long_running_task(None, 'image', message_data)
        else:
            result = process_long_running_task(messages)
            
        if task_id in session.response_queue and not session.response_queue[task_id].is_expired():
            session.response_queue[task_id].status = "completed"
            session.response_queue[task_id].response_type = result.get("type", "text")
            
            if result["type"] == "image":
                session.response_queue[task_id].media_id = result["media_id"]
                session.response_queue[task_id].result = None
            else:
                session.response_queue[task_id].result = result["content"]
                
            if messages and result["type"] == "text":
                messages.append({"role": "assistant", "content": result["content"]})
                
    except Exception as e:
        logging.error(f"异步任务处理失败: {str(e)}")
        if task_id in session.response_queue:
            session.response_queue[task_id].status = "failed"
            session.response_queue[task_id].error = str(e)


def generate_initial_response():
    return "您的请求正在处理中，请回复'查询'获取结果（生图需要时间）"

def split_message(message, max_length=500):
    """
    将长消息分割成多个部分
    Args:
        message: 需要分割的消息
        max_length: 每部分的最大长度
    Returns:
        list: 分割后的消息部分列表
    """
    return [message[i:i+max_length] for i in range(0, len(message), max_length)]

def append_status_message(content, has_pending_parts=False, is_processing=False):
    """
    添加状态消息到响应内容
    Args:
        content: 原始内容
        has_pending_parts: 是否有待发送的部分
        is_processing: 是否正在处理中
    Returns:
        str: 添加了状态信息的内容
    """
    if "您的请求正在处理中" in content:
        return content + "\n\n-------------------\n发送'新对话'开始新的对话"
        
    status_message = "\n\n-------------------"
    if is_processing:
        status_message += "\n请回复'查询'获取结果"
    elif has_pending_parts:
        status_message += "\n当前消息已截断，发送'继续'查看后续内容"
    status_message += "\n发送'新对话'开始新的对话"
    return content + status_message

session_manager = SessionManager()

@app.route('/api/wx', methods=['GET', 'POST'])
def wechatai():
    """
    处理微信公众号请求的主要路由函数
    """
    if request.method == 'GET':
        signature = request.args.get('signature')
        timestamp = request.args.get('timestamp')
        nonce = request.args.get('nonce')
        echostr = request.args.get('echostr')
        
        if verify_signature(signature, timestamp, nonce, TOKEN):
            return echostr
        return 'error', 403
    
    try:
        encrypt_type = request.args.get('encrypt_type', '')
        current_time = int(time.time())
        
        if encrypt_type == 'aes':
            msg_signature = request.args.get('msg_signature')
            timestamp = request.args.get('timestamp')
            nonce = request.args.get('nonce')
            
            # 解析加密消息
            xml_tree = ET.fromstring(request.data)
            encrypted_text = xml_tree.find('Encrypt').text
            
            # 验证消息签名
            if not verify_msg_signature(msg_signature, timestamp, nonce, TOKEN, encrypted_text):
                logging.error("消息签名验证失败")
                return 'Invalid signature', 403
            
            try:
                # 解密消息
                decrypted_xml = session_manager.crypto.decrypt(encrypted_text)
                message_data = parse_xml_message(decrypted_xml)
            except Exception as e:
                logging.error(f"消息解密失败: {str(e)}")
                return 'Decryption failed', 403
        else:
            # 处理未加密的消息
            try:
                message_data = parse_xml_message(request.data)
            except Exception as e:
                logging.error(f"解析XML消息失败: {str(e)}")
                return 'Invalid XML', 400
        
        from_user = message_data['from_user']
        to_user = message_data['to_user']
        msg_type = message_data['msg_type']
        
        logging.info(f"收到用户({from_user})消息类型: {msg_type}")
        
        # 获取或创建用户会话
        try:
            session = session_manager.get_session(from_user)
        except Exception as e:
            logging.error(f"获取用户会话失败: {str(e)}")
            return generate_response_xml(
                from_user,
                to_user,
                append_status_message('系统错误，请稍后重试。'),
                encrypt_type=encrypt_type
            )

        if msg_type == 'image':
            try:
                logging.info(f"收到图片消息: MediaId={message_data.get('media_id')}")
                
                # 创建新的异步任务
                task_id = str(uuid.uuid4())
                session.current_task = task_id
                session.response_queue[task_id] = AsyncResponse()
                
                # 启动异步图片识别任务
                executor.submit(
                    handle_async_task, 
                    session, 
                    task_id, 
                    None,
                    'image',
                    message_data
                )
                
                return generate_response_xml(
                    from_user,
                    to_user,
                    append_status_message("正在分析图片，请稍候...\n回复'查询'获取分析结果", is_processing=True),
                    encrypt_type=encrypt_type
                )
            except Exception as e:
                logging.error(f"处理图片消息时发生错误: {str(e)}")
                return generate_response_xml(
                    from_user,
                    to_user,
                    append_status_message('处理图片时出现错误，请稍后重试。'),
                    encrypt_type=encrypt_type
                )
        else:
            # 处理文本消息
            try:
                user_content = message_data['content'].strip()
                
                # 处理特殊命令
                if user_content == '新对话':
                    session_manager.clear_session(from_user)
                    return generate_response_xml(
                        from_user,
                        to_user,
                        append_status_message('已开始新的对话。请描述您的问题。'),
                        encrypt_type=encrypt_type
                    )

                if user_content == '继续':
                    if session.pending_parts:
                        next_part = session.pending_parts.pop(0)
                        has_more = bool(session.pending_parts)
                        return generate_response_xml(
                            from_user,
                            to_user,
                            append_status_message(next_part, has_more),
                            encrypt_type=encrypt_type
                        )
                    return generate_response_xml(
                        from_user,
                        to_user,
                        append_status_message('没有更多内容了。请继续您的问题。'),
                        encrypt_type=encrypt_type
                    )

                if user_content == '查询':
                    if session.current_task:
                        task_response = session.response_queue.get(session.current_task)
                        if task_response:
                            if task_response.is_expired():
                                del session.response_queue[session.current_task]
                                session.current_task = None
                                return generate_response_xml(
                                    from_user,
                                    to_user,
                                    append_status_message('请求已过期，请重新提问。'),
                                    encrypt_type=encrypt_type
                                )
                            
                            if task_response.status == "completed":
                                if task_response.response_type == "image":
                                    logging.info("返回图片响应")
                                    del session.response_queue[session.current_task]
                                    session.current_task = None
                                    return generate_response_xml(
                                        from_user,
                                        to_user,
                                        "",
                                        response_type="image",
                                        media_id=task_response.media_id,
                                        encrypt_type=encrypt_type
                                    )
                                else:
                                    response = task_response.result
                                    del session.response_queue[session.current_task]
                                    session.current_task = None
                                    
                                    if len(response) > 500:
                                        parts = split_message(response)
                                        first_part = parts.pop(0)
                                        session.pending_parts = parts
                                        return generate_response_xml(
                                            from_user,
                                            to_user,
                                            append_status_message(first_part, True),
                                            encrypt_type=encrypt_type
                                        )
                                    return generate_response_xml(
                                        from_user,
                                        to_user,
                                        append_status_message(response),
                                        encrypt_type=encrypt_type
                                    )
                            elif task_response.status == "failed":
                                error_message = '处理过程中出现错误，请重新提问。'
                                del session.response_queue[session.current_task]
                                session.current_task = None
                                return generate_response_xml(
                                    from_user,
                                    to_user,
                                    append_status_message(error_message),
                                    encrypt_type=encrypt_type
                                )
                            else:
                                return generate_response_xml(
                                    from_user,
                                    to_user,
                                    append_status_message('正在处理中，请稍后再次查询。', is_processing=True),
                                    encrypt_type=encrypt_type
                                )
                    return generate_response_xml(
                        from_user,
                        to_user,
                        append_status_message('没有正在处理的请求。'),
                        encrypt_type=encrypt_type
                    )

                # 处理普通文本消息
                session.messages.append({"role": "user", "content": user_content})
                
                # 创建新的异步任务
                task_id = str(uuid.uuid4())
                session.current_task = task_id
                session.response_queue[task_id] = AsyncResponse()
                
                # 启动异步处理
                executor.submit(handle_async_task, session, task_id, session.messages.copy())
                
                return generate_response_xml(
                    from_user,
                    to_user,
                    append_status_message(generate_initial_response(), is_processing=True),
                    encrypt_type=encrypt_type
                )
                
            except Exception as e:
                logging.error(f"处理文本消息时发生错误: {str(e)}")
                return generate_response_xml(
                    from_user,
                    to_user,
                    append_status_message('处理消息时出现错误，请稍后重试。'),
                    encrypt_type=encrypt_type
                )

    except Exception as e:
        logging.error(f"处理请求时出错: {str(e)}")
        return generate_response_xml(
            message_data['from_user'] if 'message_data' in locals() else 'unknown',
            message_data['to_user'] if 'message_data' in locals() else 'unknown',
            append_status_message('抱歉，系统暂时出现问题，请稍后重试。'),
            encrypt_type if 'encrypt_type' in locals() else ''
        )
    
def cleanup_sessions():
    while True:
        time.sleep(3600)  # 每小时清理一次
        try:
            session_manager.cleanup_expired_sessions()
        except Exception as e:
            logging.error(f"清理会话时出错: {str(e)}")

if __name__ == '__main__':
    cleanup_thread = threading.Thread(target=cleanup_sessions, daemon=True)
    cleanup_thread.start()
    
    app.run(host='0.0.0.0', port=7860, debug=True)