@app.route('/openclaw/feishu/webhook', methods=['POST'])
def feishu_webhook():
    """飞书 Webhook 处理"""
    
    request_body = request.json
    challenge = request_body.get('challenge')
    
    # 验证请求
    if challenge:
        # 返回 challenge 完成验证
        return jsonify({'challenge': challenge})
    
    # 处理正常事件
    return handle_event(request_body)

def get_feishu_token() -> str:
    """获取飞书访问 Token"""
    
    cache_key = 'feishu:access_token'
    
    # 1. 尝试从缓存获取
    cached_token = redis.get(cache_key)
    if cached_token:
        return cached_token
    
    # 2. 请求新 Token
    url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal'
    payload = {
        'app_id': os.environ['FEISHU_APP_ID'],
        'app_secret': os.environ['FEISHU_APP_SECRET']
    }
    
    response = requests.post(url, json=payload)
    response.raise_for_status()
    
    data = response.json()
    token = data['tenant_access_token']
    expires_in = data['expire'] - 300  # 提前 5 分钟过期
    
    # 3. 缓存 Token
    redis.setex(cache_key, expires_in, token)
    
    return token

def verify_pairing(self, user_id: str, pairing_code: str) -> bool:
    """验证配对"""
    
    # 1. 检查配对码有效性
    pairing_request = self.pairing_cache.get(pairing_code)
    if not pairing_request:
        return False
    
    # 2. 检查是否过期
    if time.time() - pairing_request.timestamp > 600:  # 10 分钟
        self.pairing_cache.delete(pairing_code)
        return False
    
    # 3. 绑定用户
    self.user_mapping[user_id] = pairing_request.session_id
    
    # 4. 记录到记忆
    self.memory.write_l1(
        user_id=user_id,
        key='feishu_pairing',
        value={
            'paired_at': datetime.now().isoformat(),
            'chat_id': user_id
        }
    )
    
    # 5. 清理配对码
    self.pairing_cache.delete(pairing_code)
    
    return True

@app.route('/openclaw/feishu/webhook', methods=['POST'])
def feishu_webhook():
    """飞书消息 Webhook"""
    
    # 1. 验证签名
    signature = request.headers.get('X-Feishu-Signature')
    if not verify_signature(request.data, signature):
        return jsonify({'code': 401}), 401
    
    # 2. 解析事件
    event = request.json
    event_type = event.get('header', {}).get('event_type')
    
    # 3. 路由处理
    if event_type == 'im.message.receive_v1':
        return handle_message(event)
    elif event_type == 'im.chat.member.join_v1':
        return handle_member_join(event)
    else:
        return jsonify({'code': 0})

def parse_feishu_message(self, event: dict) -> Message:
    """解析飞书消息"""
    
    message_data = event.get('event', {}).get('message', {})
    sender_data = event.get('event', {}).get('sender', {})
    
    return Message(
        id=message_data.get('message_id'),
        chat_id=sender_data.get('id'),
        chat_type=message_data.get('chat_type'),  # 'group' or 'p2p'
        content=self._parse_content(message_data),
        sender=Sender(
            id=sender_data.get('id'),
            name=sender_data.get('name'),
            avatar=sender_data.get('avatar', {}).get('avatar_72')
        ),
        timestamp=message_data.get('create_time'),
        mentions=self._parse_mentions(message_data)
    )
    
def _parse_content(self, message_data: dict) -> str:
    """解析消息内容"""
    
    content_type = message_data.get('message_type')
    content = json.loads(message_data.get('content', '{}'))
    
    if content_type == 'text':
        return content.get('text', '')
    elif content_type == 'post':
        # 富文本消息
        return self._parse_post_content(content)
    else:
        return str(content)

def send_feishu_message(self, chat_id: str, content: str, **options):
    """发送飞书消息"""
    
    url = 'https://open.feishu.cn/open-apis/im/v1/messages'
    headers = {
        'Authorization': f'Bearer {get_feishu_token()}',
        'Content-Type': 'application/json'
    }
    
    # 构建消息体
    payload = {
        'receive_id': chat_id,
        'msg_type': 'text',
        'content': json.dumps({'text': content})
    }
    
    # 添加可选参数
    if options.get('reply_to'):
        payload['reply_id'] = options['reply_to']
    
    if options.get('uuid'):
        payload['uuid'] = options['uuid']
    
    # 发送请求
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()

@app.route('/openclaw/feishu/card_callback', methods=['POST'])
def feishu_card_callback():
    """飞书卡片回调处理"""
    
    callback_data = request.json
    action = callback_data.get('action', {}).get('value')
    user_id = callback_data.get('user', {}).get('user_id')
    
    if action.get('action') == 'start_task':
        task_id = action.get('task_id')
        return handle_start_task(user_id, task_id)
    
    elif action.get('action') == 'cancel_task':
        task_id = action.get('task_id')
        return handle_cancel_task(user_id, task_id)
    
    elif action.get('action') == 'submit_task':
        form_data = callback_data.get('action', {}).get('form_value')
        return handle_submit_task(user_id, form_data)
    
    return jsonify({'code': 0})

# 定时任务配置
@cron.schedule('0 7:30 * * *')
def morning_report():
    """晨间工作汇报"""
    
    # 1. 获取昨日工作日志
    yesterday = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
    daily_log = memory.read(f'memory/{yesterday}.md')
    
    # 2. 获取今日待办
    todos = memory.get_todos(date='today')
    
    # 3. 生成汇报内容
    report = generate_report(daily_log, todos)
    
    # 4. 发送到飞书
    for user_id in get_subscribed_users():
        send_feishu_message(
            chat_id=user_id,
            content=report,
            msg_type='post'
        )

def handle_group_task_assignment(self, message: Message):
    """处理群聊任务分配"""
    
    # 1. 检查是否@机器人
    if not self._is_mentioned(message):
        return
    
    # 2. 解析任务
    task = self._parse_task(message.content)
    
    # 3. 创建任务卡片
    card = self._create_task_card(task)
    
    # 4. 发送到群聊
    self.send_card(message.chat_id, card)
    
    # 5. 记录到项目记忆
    self.memory.write_l3(
        project=task.project,
        key='task_assigned',
        value={
            'task': task,
            'assigned_by': message.sender.id,
            'assigned_at': datetime.now().isoformat()
        }
    )

async def create_feishu_doc(self, user_id: str, title: str, content: str):
    """创建飞书文档"""
    
    # 1. 调用飞书文档 API
    url = 'https://open.feishu.cn/open-apis/docx/v1/documents'
    headers = {
        'Authorization': f'Bearer {get_feishu_token()}',
        'Content-Type': 'application/json'
    }
    
    payload = {
        'title': title,
        'folder_token': 'xxxxx',  # 目标文件夹
        'doc_type': 1  # 1 = 文档
    }
    
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    
    doc_token = response.json()['data']['document']['token']
    
    # 2. 写入内容
    await self._write_doc_content(doc_token, content)
    
    # 3. 发送分享链接
    doc_url = f'https://your-company.feishu.cn/docx/{doc_token}'
    send_feishu_message(
        chat_id=user_id,
        content=f"✅ 文档已创建：{title}\n\n📄 {doc_url}",
        msg_type='text'
    )
    
    return doc_token

async def handle_file_upload(self, message: Message):
    """处理文件上传"""
    
    # 1. 下载文件
    file_key = message.attachments[0].file_key
    file_url = await self._get_file_url(file_key)
    file_content = await self._download_file(file_url)
    
    # 2. 识别文件类型
    file_type = self._detect_file_type(file_content)
    
    # 3. 根据类型处理
    if file_type == 'image':
        # 图片 → XMind
        xmind_content = await self._image_to_xmind(file_content)
        xmind_file = await self._generate_xmind(xmind_content)
        
        # 上传结果
        result_url = await self._upload_to_minio(xmind_file)
        
        # 发送结果
        send_feishu_message(
            chat_id=message.chat_id,
            content=f"✅ XMind 已生成：{result_url}",
            msg_type='text',
            reply_to=message.id
        )
    
    elif file_type == 'document':
        # 文档 → Markdown
        md_content = await self._document_to_markdown(file_content)
        
        # 发送结果
        send_feishu_message(
            chat_id=message.chat_id,
            content=f"✅ Markdown 已生成：\n\n```{md_content[:1000]}...```",
            msg_type='text',
            reply_to=message.id
        )

def get_feishu_token_with_retry(self, max_retries: int = 3):
    """获取 Token（带重试）"""
    
    for attempt in range(max_retries):
        try:
            token = self._request_token()
            return token
        except TokenExpiredError:
            # Token 过期，清除缓存重新获取
            redis.delete('feishu:access_token')
            
            if attempt == max_retries - 1:
                raise
            
            time.sleep(2 ** attempt)  # 指数退避

def validate_card(self, card: dict) -> ValidationResult:
    """验证卡片格式"""
    
    errors = []
    
    # 1. 检查必需字段
    if 'header' not in card:
        errors.append("缺少 header 字段")
    
    if 'elements' not in card:
        errors.append("缺少 elements 字段")
    
    # 2. 检查字段类型
    for element in card.get('elements', []):
        if element.get('tag') not in SUPPORTED_TAGS:
            errors.append(f"不支持的元素类型：{element.get('tag')}")
    
    # 3. 使用飞书验证工具
    validation_response = requests.post(
        'https://open.feishu.cn/open-apis/card/validation',
        json={'card': card},
        headers={'Authorization': f'Bearer {get_feishu_token()}'}
    )
    
    if validation_response.status_code != 200:
        errors.extend(validation_response.json().get('errors', []))
    
    return ValidationResult(
        valid=len(errors) == 0,
        errors=errors
    )

class FeishuMessageQueue:
    """飞书消息队列"""
    
    def __init__(self, max_concurrent: int = 10):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.queue = asyncio.Queue()
        
    async def send_message(self, chat_id: str, content: str):
        """发送消息（带限流）"""
        
        async with self.semaphore:
            await self.queue.put((chat_id, content))
            
            # 异步处理
            asyncio.create_task(self._process_queue())
    
    async def _process_queue(self):
        """处理队列"""
        
        while not self.queue.empty():
            chat_id, content = await self.queue.get()
            
            try:
                await self._send(chat_id, content)
            except RateLimitError:
                # 限流，延迟重试
                await asyncio.sleep(1)
                await self.queue.put((chat_id, content))

def cache_response(self, query_hash: str, response: str, ttl: int = 300):
    """缓存响应"""
    
    cache_key = f'feishu:response:{query_hash}'
    redis.setex(cache_key, ttl, response)

def get_cached_response(self, query_hash: str) -> Optional[str]:
    """获取缓存响应"""
    
    cache_key = f'feishu:response:{query_hash}'
    return redis.get(cache_key)

def batch_send_messages(self, messages: List[Message]):
    """批量发送消息"""
    
    # 分组（同一群聊的消息合并）
    grouped = defaultdict(list)
    for msg in messages:
        grouped[msg.chat_id].append(msg.content)
    
    # 批量发送
    for chat_id, contents in grouped.items():
        merged_content = '\n\n---\n\n'.join(contents)
        send_feishu_message(chat_id, merged_content)

@app.route('/openclaw/feishu/webhook', methods=['POST'])
def feishu_webhook():
    """飞书 Webhook 处理"""
    
    request_body = request.json
    challenge = request_body.get('challenge')
    
    # 验证请求
    if challenge:
        # 返回 challenge 完成验证
        return jsonify({'challenge': challenge})
    
    # 处理正常事件
    return handle_event(request_body)

def get_feishu_token() -> str:
    """获取飞书访问 Token"""
    
    cache_key = 'feishu:access_token'
    
    # 1. 尝试从缓存获取
    cached_token = redis.get(cache_key)
    if cached_token:
        return cached_token
    
    # 2. 请求新 Token
    url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal'
    payload = {
        'app_id': os.environ['FEISHU_APP_ID'],
        'app_secret': os.environ['FEISHU_APP_SECRET']
    }
    
    response = requests.post(url, json=payload)
    response.raise_for_status()
    
    data = response.json()
    token = data['tenant_access_token']
    expires_in = data['expire'] - 300  # 提前 5 分钟过期
    
    # 3. 缓存 Token
    redis.setex(cache_key, expires_in, token)
    
    return token

def verify_pairing(self, user_id: str, pairing_code: str) -> bool:
    """验证配对"""
    
    # 1. 检查配对码有效性
    pairing_request = self.pairing_cache.get(pairing_code)
    if not pairing_request:
        return False
    
    # 2. 检查是否过期
    if time.time() - pairing_request.timestamp > 600:  # 10 分钟
        self.pairing_cache.delete(pairing_code)
        return False
    
    # 3. 绑定用户
    self.user_mapping[user_id] = pairing_request.session_id
    
    # 4. 记录到记忆
    self.memory.write_l1(
        user_id=user_id,
        key='feishu_pairing',
        value={
            'paired_at': datetime.now().isoformat(),
            'chat_id': user_id
        }
    )
    
    # 5. 清理配对码
    self.pairing_cache.delete(pairing_code)
    
    return True

@app.route('/openclaw/feishu/webhook', methods=['POST'])
def feishu_webhook():
    """飞书消息 Webhook"""
    
    # 1. 验证签名
    signature = request.headers.get('X-Feishu-Signature')
    if not verify_signature(request.data, signature):
        return jsonify({'code': 401}), 401
    
    # 2. 解析事件
    event = request.json
    event_type = event.get('header', {}).get('event_type')
    
    # 3. 路由处理
    if event_type == 'im.message.receive_v1':
        return handle_message(event)
    elif event_type == 'im.chat.member.join_v1':
        return handle_member_join(event)
    else:
        return jsonify({'code': 0})

def parse_feishu_message(self, event: dict) -> Message:
    """解析飞书消息"""
    
    message_data = event.get('event', {}).get('message', {})
    sender_data = event.get('event', {}).get('sender', {})
    
    return Message(
        id=message_data.get('message_id'),
        chat_id=sender_data.get('id'),
        chat_type=message_data.get('chat_type'),  # 'group' or 'p2p'
        content=self._parse_content(message_data),
        sender=Sender(
            id=sender_data.get('id'),
            name=sender_data.get('name'),
            avatar=sender_data.get('avatar', {}).get('avatar_72')
        ),
        timestamp=message_data.get('create_time'),
        mentions=self._parse_mentions(message_data)
    )
    
def _parse_content(self, message_data: dict) -> str:
    """解析消息内容"""
    
    content_type = message_data.get('message_type')
    content = json.loads(message_data.get('content', '{}'))
    
    if content_type == 'text':
        return content.get('text', '')
    elif content_type == 'post':
        # 富文本消息
        return self._parse_post_content(content)
    else:
        return str(content)

def send_feishu_message(self, chat_id: str, content: str, **options):
    """发送飞书消息"""
    
    url = 'https://open.feishu.cn/open-apis/im/v1/messages'
    headers = {
        'Authorization': f'Bearer {get_feishu_token()}',
        'Content-Type': 'application/json'
    }
    
    # 构建消息体
    payload = {
        'receive_id': chat_id,
        'msg_type': 'text',
        'content': json.dumps({'text': content})
    }
    
    # 添加可选参数
    if options.get('reply_to'):
        payload['reply_id'] = options['reply_to']
    
    if options.get('uuid'):
        payload['uuid'] = options['uuid']
    
    # 发送请求
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()