chatProgram/run_client_gui.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
P2P Chat Client GUI 启动脚本

用法:
    python run_client_gui.py [--server HOST] [--port PORT]

示例:
    python run_client_gui.py
    python run_client_gui.py --server 192.168.1.100 --port 8888
"""

import asyncio
import argparse
import logging
import sys
import os
from typing import Optional, List

# 确保能找到模块
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from PyQt6.QtWidgets import QApplication, QMessageBox, QSplashScreen
from PyQt6.QtCore import Qt, QTimer, QThread, pyqtSignal, QObject
from PyQt6.QtGui import QPixmap, QFont

from client.app import P2PClientApp
from client.connection_manager import ConnectionState
from client.ui import (
    MainWindow, LoginDialog, ChatWidget, ContactListWidget,
    FileTransferWidget, MediaPlayerWidget, VoiceCallWidget, SystemTrayManager
)
from shared.models import UserInfo, UserStatus, Message, MessageType
from config import load_client_config, ClientConfig


# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler('client_gui.log', encoding='utf-8')
    ]
)
logger = logging.getLogger(__name__)


class AsyncWorker(QThread):
    """异步工作线程，用于运行 asyncio 事件循环"""
    
    connected = pyqtSignal(bool, str)  # (success, message)
    disconnected = pyqtSignal(str)  # reason
    message_received = pyqtSignal(object)  # Message
    user_list_updated = pyqtSignal(list)  # List[UserInfo]
    state_changed = pyqtSignal(str, str)  # (state, reason)
    
    def __init__(self, client: P2PClientApp, user_info: UserInfo):
        super().__init__()
        self.client = client
        self.user_info = user_info
        self._running = False
        self._loop: Optional[asyncio.AbstractEventLoop] = None
    
    def run(self):
        """运行异步事件循环"""
        self._loop = asyncio.new_event_loop()
        asyncio.set_event_loop(self._loop)
        self._running = True
        
        try:
            # 连接到服务器
            success = self._loop.run_until_complete(
                self.client.start(self.user_info)
            )
            
            if success:
                self.connected.emit(True, "连接成功")
                
                # 设置回调
                self.client.add_message_callback(self._on_message)
                self.client.add_state_callback(self._on_state_change)
                self.client.add_user_list_callback(self._on_user_list)
                
                # 保持运行
                while self._running:
                    self._loop.run_until_complete(asyncio.sleep(0.1))
            else:
                self.connected.emit(False, "连接失败")
                
        except Exception as e:
            logger.error(f"Worker error: {e}")
            self.connected.emit(False, str(e))
        finally:
            self._loop.close()
    
    def stop(self):
        """停止工作线程"""
        self._running = False
        if self._loop and self._loop.is_running():
            self._loop.call_soon_threadsafe(self._loop.stop)
    
    def _on_message(self, message: Message):
        """消息回调"""
        self.message_received.emit(message)
    
    def _on_state_change(self, state: ConnectionState, reason: Optional[str]):
        """状态变化回调"""
        self.state_changed.emit(state.value, reason or "")
        if state == ConnectionState.DISCONNECTED:
            self.disconnected.emit(reason or "连接断开")
    
    def _on_user_list(self, users: List[UserInfo]):
        """用户列表更新回调"""
        self.user_list_updated.emit(users)
    
    def send_message(self, peer_id: str, content: str) -> bool:
        """发送消息（线程安全）"""
        if self._loop and self._running:
            future = asyncio.run_coroutine_threadsafe(
                self.client.send_text_message(peer_id, content),
                self._loop
            )
            try:
                return future.result(timeout=5.0)
            except Exception as e:
                logger.error(f"Send message error: {e}")
                return False
        return False
    
    def send_file(self, peer_id: str, file_path: str) -> bool:
        """发送文件（线程安全）"""
        if self._loop and self._running:
            future = asyncio.run_coroutine_threadsafe(
                self.client.send_file(peer_id, file_path),
                self._loop
            )
            try:
                return future.result(timeout=300.0)  # 5分钟超时
            except Exception as e:
                logger.error(f"Send file error: {e}")
                return False
        return False
    
    def send_image(self, peer_id: str, image_path: str) -> bool:
        """发送图片（线程安全）"""
        if self._loop and self._running:
            future = asyncio.run_coroutine_threadsafe(
                self.client.send_image(peer_id, image_path),
                self._loop
            )
            try:
                return future.result(timeout=300.0)
            except Exception as e:
                logger.error(f"Send image error: {e}")
                return False
        return False
    
    def start_voice_call(self, peer_id: str) -> bool:
        """发起语音通话（线程安全）"""
        if self._loop and self._running:
            future = asyncio.run_coroutine_threadsafe(
                self.client.start_voice_call(peer_id),
                self._loop
            )
            try:
                return future.result(timeout=30.0)
            except Exception as e:
                logger.error(f"Start voice call error: {e}")
                return False
        return False
    
    def end_voice_call(self):
        """结束语音通话（线程安全）"""
        if self._loop and self._running:
            self.client.end_voice_call()
    
    def accept_voice_call(self, peer_id: str) -> bool:
        """接听语音通话（线程安全）"""
        if self._loop and self._running:
            future = asyncio.run_coroutine_threadsafe(
                self.client.accept_voice_call(peer_id),
                self._loop
            )
            try:
                return future.result(timeout=10.0)
            except Exception as e:
                logger.error(f"Accept voice call error: {e}")
                return False
        return False
    
    def reject_voice_call(self, peer_id: str):
        """拒绝语音通话（线程安全）"""
        if self._loop and self._running:
            self.client.reject_voice_call(peer_id)
    
    def refresh_users(self):
        """刷新用户列表（线程安全）"""
        if self._loop and self._running:
            asyncio.run_coroutine_threadsafe(
                self.client.refresh_online_users(),
                self._loop
            )


class P2PChatGUI(QObject):
    """P2P 聊天 GUI 应用程序"""
    
    # 信号定义 - 用于跨线程通信
    file_received_signal = pyqtSignal(str, str, str)  # sender_id, file_name, file_path
    
    def __init__(self, config: ClientConfig):
        super().__init__()
        self.config = config
        self.app: Optional[QApplication] = None
        self.main_window: Optional[MainWindow] = None
        self.client: Optional[P2PClientApp] = None
        self.worker: Optional[AsyncWorker] = None
        self._current_user: Optional[UserInfo] = None
        self._current_chat_peer: Optional[str] = None
        
        # 连接信号到槽
        self.file_received_signal.connect(self._handle_file_received_ui)
    
    def run(self) -> int:
        """运行 GUI 应用程序"""
        # 创建 Qt 应用
        self.app = QApplication(sys.argv)
        self.app.setApplicationName("P2P Chat")
        self.app.setApplicationVersion("0.1.0")
        
        # 设置默认字体
        font = QFont("Microsoft YaHei", 10)
        self.app.setFont(font)
        
        # 设置样式
        self.app.setStyle("Fusion")
        
        # 应用退出时清理资源
        self.app.aboutToQuit.connect(self.cleanup)
        
        # 显示登录对话框
        if not self._show_login():
            return 0
        
        # 创建主窗口
        self._create_main_window()
        
        # 连接到服务器
        self._connect_to_server()
        
        # 运行应用
        return self.app.exec()
    
    def _show_login(self) -> bool:
        """显示登录对话框"""
        dialog = LoginDialog()
        
        # 设置服务器地址
        dialog._login_server_input.setText(
            f"{self.config.server_host}:{self.config.server_port}"
        )
        dialog._reg_server_input.setText(
            f"{self.config.server_host}:{self.config.server_port}"
        )
        
        if dialog.exec():
            self._current_user = dialog.get_user_info()
            host, port = dialog.get_server_address()
            self.config.server_host = host
            self.config.server_port = port
            return True
        return False
    
    def _create_main_window(self):
        """创建主窗口"""
        self.main_window = MainWindow(self.config)
        
        if self._current_user:
            self.main_window.set_current_user(self._current_user)
        
        # 创建并设置联系人列表组件
        self._contact_list_widget = ContactListWidget()
        self.main_window.set_contact_list_widget(self._contact_list_widget)
        
        # 创建并设置聊天组件
        self._chat_widget = ChatWidget()
        self.main_window.set_chat_widget(self._chat_widget)
        
        # 连接聊天组件信号
        self._chat_widget.message_sent.connect(self._on_send_message)
        self._chat_widget.file_send_requested.connect(lambda peer_id: self._on_send_file())
        self._chat_widget.image_send_requested.connect(lambda peer_id: self._on_send_image())
        self._chat_widget.voice_call_requested.connect(lambda peer_id: self._on_voice_call())
        self._chat_widget.voice_call_end_requested.connect(self._on_end_voice_call)
        
        # 连接联系人列表信号
        self._contact_list_widget.contact_selected.connect(self._on_contact_selected)
        self._contact_list_widget.contact_double_clicked.connect(self._on_contact_double_clicked)
        self._contact_list_widget.refresh_requested.connect(self._refresh_users)
        self._contact_list_widget.lan_discovery_requested.connect(self._on_lan_discovery)
        
        # 设置系统托盘
        try:
            tray = SystemTrayManager(self.main_window)
            self.main_window.set_system_tray(tray)
        except Exception as e:
            logger.warning(f"Failed to create system tray: {e}")
        
        # 连接菜单动作
        self._connect_menu_actions()
        
        self.main_window.show()
    
    def _connect_menu_actions(self):
        """连接菜单动作"""
        # 发送文件
        self.main_window._send_file_action.triggered.connect(self._on_send_file)
        # 发送图片
        self.main_window._send_image_action.triggered.connect(self._on_send_image)
        # 语音通话
        self.main_window._voice_call_action.triggered.connect(self._on_voice_call)
    
    def _connect_to_server(self):
        """连接到服务器"""
        if not self._current_user:
            return
        
        # 更新状态
        self.main_window.connection_state_changed.emit("连接中...")
        
        # 创建客户端
        self.client = P2PClientApp(self.config)
        
        # 添加文件接收回调
        self.client.add_file_received_callback(self._on_file_received)
        
        # 创建工作线程
        self.worker = AsyncWorker(self.client, self._current_user)
        self.worker.connected.connect(self._on_connected)
        self.worker.disconnected.connect(self._on_disconnected)
        self.worker.message_received.connect(self._on_message_received)
        self.worker.user_list_updated.connect(self._on_user_list_updated)
        self.worker.state_changed.connect(self._on_state_changed)
        
        # 启动工作线程
        self.worker.start()
    
    def _on_connected(self, success: bool, message: str):
        """连接结果回调"""
        if success:
            self.main_window.connection_state_changed.emit("已连接")
            self.main_window._statusbar.showMessage(f"已连接到服务器")
            logger.info("Connected to server")
            
            # 刷新用户列表
            QTimer.singleShot(500, self._refresh_users)
        else:
            self.main_window.connection_state_changed.emit("连接失败")
            QMessageBox.critical(
                self.main_window,
                "连接失败",
                f"无法连接到服务器: {message}"
            )
    
    def _on_disconnected(self, reason: str):
        """断开连接回调"""
        self.main_window.connection_state_changed.emit("已断开")
        self.main_window._statusbar.showMessage(f"连接断开: {reason}")
        
        # 询问是否重连
        reply = QMessageBox.question(
            self.main_window,
            "连接断开",
            f"与服务器的连接已断开: {reason}\n\n是否尝试重新连接？",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )
        
        if reply == QMessageBox.StandardButton.Yes:
            self._connect_to_server()
    
    def _on_message_received(self, message: Message):
        """消息接收回调"""
        if message.msg_type == MessageType.TEXT:
            content = message.payload.decode('utf-8')
            sender = message.sender_id
            
            # 显示通知
            if self.main_window.isMinimized() or not self.main_window.isActiveWindow():
                self.main_window.show_notification(
                    f"来自 {sender} 的消息",
                    content[:50] + ("..." if len(content) > 50 else "")
                )
            
            # 更新状态栏
            self.main_window._statusbar.showMessage(
                f"收到来自 {sender} 的消息", 3000
            )
            
            # 将消息添加到聊天窗口显示
            from datetime import datetime
            from shared.models import ChatMessage
            
            msg = ChatMessage(
                message_id=message.message_id,
                sender_id=sender,
                receiver_id=message.receiver_id,
                content_type=MessageType.TEXT,
                content=content,
                timestamp=datetime.fromtimestamp(message.timestamp),
                is_sent=True,
                is_read=False
            )
            
            # 如果当前正在和发送者聊天，直接显示消息
            if hasattr(self, '_chat_widget') and self._chat_widget:
                if self._current_chat_peer == sender:
                    self._chat_widget.add_message(msg, is_self=False)
            
            logger.info(f"Message from {sender}: {content[:50]}...")
        
        elif message.msg_type == MessageType.VOICE_CALL_REQUEST:
            sender = message.sender_id
            logger.info(f"Voice call request from {sender}")
            self.main_window.show_notification(
                "来电",
                f"{sender} 正在呼叫你"
            )
            # 显示来电对话框
            self._show_incoming_call_dialog(sender)
        
        elif message.msg_type == MessageType.VOICE_CALL_ACCEPT:
            sender = message.sender_id
            logger.info(f"Voice call accepted by {sender}")
            self.main_window._statusbar.showMessage(f"通话已接通 - {sender}", 5000)
            self.main_window.show_notification("通话已接通", f"与 {sender} 的通话已建立")
            # 更新UI状态为通话中
            if hasattr(self, '_chat_widget') and self._chat_widget:
                self._chat_widget.set_call_state(True, "通话中...")
        
        elif message.msg_type == MessageType.VOICE_CALL_REJECT:
            sender = message.sender_id
            reason = message.payload.decode('utf-8') if message.payload else "对方拒绝"
            logger.info(f"Voice call rejected by {sender}: {reason}")
            self.main_window._statusbar.showMessage(f"呼叫被拒绝: {reason}", 5000)
            self.main_window.show_notification("呼叫被拒绝", f"{sender} 拒绝了你的通话请求")
            # 恢复UI状态
            if hasattr(self, '_chat_widget') and self._chat_widget:
                self._chat_widget.set_call_state(False)
        
        elif message.msg_type == MessageType.VOICE_CALL_END:
            sender = message.sender_id
            logger.info(f"Voice call ended by {sender}")
            self.main_window._statusbar.showMessage("通话已结束", 3000)
            self.main_window.show_notification("通话结束", f"与 {sender} 的通话已结束")
            # 恢复UI状态
            if hasattr(self, '_chat_widget') and self._chat_widget:
                self._chat_widget.set_call_state(False)
    
    def _on_user_list_updated(self, users: List[UserInfo]):
        """用户列表更新回调"""
        logger.info(f"Online users: {len(users)}")
        self.main_window._statusbar.showMessage(
            f"在线用户: {len(users)}", 3000
        )
        
        # 更新联系人列表（排除自己）
        if hasattr(self, '_contact_list_widget') and self._contact_list_widget:
            # 过滤掉当前用户自己
            other_users = [
                user for user in users 
                if self._current_user is None or user.user_id != self._current_user.user_id
            ]
            self._contact_list_widget.set_contacts(other_users)
            logger.info(f"Contact list updated: {len(other_users)} contacts")
            
            # 更新连接模式显示
            self._update_connection_modes()
    
    def _on_state_changed(self, state: str, reason: str):
        """状态变化回调"""
        state_text = {
            "disconnected": "已断开",
            "connecting": "连接中...",
            "connected": "已连接",
            "reconnecting": "重连中..."
        }.get(state, state)
        
        self.main_window.connection_state_changed.emit(state_text)
    
    def _refresh_users(self):
        """刷新用户列表"""
        if self.worker:
            self.worker.refresh_users()
    
    def _on_lan_discovery(self):
        """发现局域网用户"""
        self.main_window._statusbar.showMessage("正在发现局域网用户...", 5000)
        
        if self.worker and self.worker._loop and self.worker._running:
            future = asyncio.run_coroutine_threadsafe(
                self._discover_lan_peers_async(),
                self.worker._loop
            )
            try:
                peers = future.result(timeout=5.0)
                if peers:
                    self.main_window._statusbar.showMessage(f"发现 {len(peers)} 个局域网用户", 3000)
                    self.main_window.show_notification("局域网发现", f"发现 {len(peers)} 个局域网用户")
                    # 更新联系人列表中的连接模式
                    self._update_connection_modes()
                else:
                    self.main_window._statusbar.showMessage("未发现局域网用户", 3000)
            except Exception as e:
                logger.error(f"LAN discovery error: {e}")
                self.main_window._statusbar.showMessage("局域网发现失败", 3000)
    
    async def _discover_lan_peers_async(self):
        """异步发现局域网用户"""
        if self.client:
            return await self.client.discover_lan_peers()
        return []
    
    def _update_connection_modes(self):
        """更新联系人列表中的连接模式显示"""
        if not self.client or not hasattr(self, '_contact_list_widget'):
            return
        
        # 获取所有连接模式
        connection_manager = self.client.connection_manager
        
        # 更新每个联系人的连接模式
        for user_id in list(self._contact_list_widget._contacts.keys()):
            mode = connection_manager.get_connection_mode(user_id)
            mode_str = "p2p" if mode.value == "p2p" else "relay"
            self._contact_list_widget.update_connection_mode(user_id, mode_str)
    
    def _on_send_file(self):
        """发送文件"""
        from PyQt6.QtWidgets import QFileDialog, QMessageBox
        import os
        
        if not self._current_chat_peer:
            QMessageBox.warning(self.main_window, "提示", "请先选择一个联系人")
            return
        
        file_path, _ = QFileDialog.getOpenFileName(
            self.main_window,
            "选择文件",
            "",
            "所有文件 (*.*)"
        )
        
        if file_path and self._current_chat_peer:
            self.main_window._statusbar.showMessage(f"正在发送文件...")
            if self.worker:
                success = self.worker.send_file(self._current_chat_peer, file_path)
                if success:
                    self.main_window._statusbar.showMessage("文件发送成功", 3000)
                    # 在聊天窗口显示发送的文件
                    self._add_sent_file_message(file_path, is_image=False)
                else:
                    self.main_window._statusbar.showMessage("文件发送失败", 3000)
    
    def _on_send_image(self):
        """发送图片"""
        from PyQt6.QtWidgets import QFileDialog, QMessageBox
        import os
        
        if not self._current_chat_peer:
            QMessageBox.warning(self.main_window, "提示", "请先选择一个联系人")
            return
        
        file_path, _ = QFileDialog.getOpenFileName(
            self.main_window,
            "选择图片",
            "",
            "图片文件 (*.png *.jpg *.jpeg *.gif *.bmp)"
        )
        
        if file_path and self._current_chat_peer:
            self.main_window._statusbar.showMessage(f"正在发送图片...")
            if self.worker:
                success = self.worker.send_image(self._current_chat_peer, file_path)
                if success:
                    self.main_window._statusbar.showMessage("图片发送成功", 3000)
                    # 在聊天窗口显示发送的图片
                    self._add_sent_file_message(file_path, is_image=True)
                else:
                    self.main_window._statusbar.showMessage("图片发送失败", 3000)
    
    def _add_sent_file_message(self, file_path: str, is_image: bool):
        """在聊天窗口添加发送的文件/图片消息"""
        from datetime import datetime
        from shared.models import ChatMessage
        
        content_type = MessageType.IMAGE if is_image else MessageType.FILE_REQUEST
        
        msg = ChatMessage(
            message_id=f"sent_file_{datetime.now().timestamp()}",
            sender_id=self._current_user.user_id if self._current_user else "",
            receiver_id=self._current_chat_peer,
            content_type=content_type,
            content=file_path,
            timestamp=datetime.now(),
            is_sent=True,
            is_read=False
        )
        
        if hasattr(self, '_chat_widget') and self._chat_widget:
            self._chat_widget.add_message(msg, is_self=True)
    
    def _on_voice_call(self):
        """发起语音通话"""
        from PyQt6.QtWidgets import QMessageBox
        
        if not self._current_chat_peer:
            QMessageBox.warning(self.main_window, "提示", "请先选择一个联系人")
            return
        
        self.main_window._statusbar.showMessage(f"正在呼叫 {self._current_chat_peer}...")
        
        # 更新UI状态为呼叫中
        if hasattr(self, '_chat_widget') and self._chat_widget:
            self._chat_widget.set_call_state(True, "正在呼叫...")
        
        if self.worker:
            success = self.worker.start_voice_call(self._current_chat_peer)
            if success:
                self.main_window._statusbar.showMessage("正在等待对方接听...", 30000)
            else:
                self.main_window._statusbar.showMessage("呼叫失败", 3000)
                QMessageBox.warning(self.main_window, "呼叫失败", "无法发起语音通话，请检查网络连接")
                # 恢复UI状态
                if hasattr(self, '_chat_widget') and self._chat_widget:
                    self._chat_widget.set_call_state(False)
    
    def _on_end_voice_call(self):
        """结束语音通话"""
        logger.info("Ending voice call from GUI")
        if self.worker:
            self.worker.end_voice_call()
        self.main_window._statusbar.showMessage("通话已结束", 3000)
        
        # 更新UI状态
        if hasattr(self, '_chat_widget') and self._chat_widget:
            self._chat_widget.set_call_state(False)
    
    def _show_incoming_call_dialog(self, caller_id: str):
        """显示来电对话框"""
        from PyQt6.QtWidgets import QMessageBox
        
        logger.info(f"Showing incoming call dialog for {caller_id}")
        
        reply = QMessageBox.question(
            self.main_window,
            "来电",
            f"{caller_id} 正在呼叫你，是否接听？",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
            QMessageBox.StandardButton.Yes  # 默认选择接听
        )
        
        if reply == QMessageBox.StandardButton.Yes:
            # 接听
            logger.info(f"Accepting call from {caller_id}")
            if self.worker and self.worker._loop and self.worker._running:
                future = asyncio.run_coroutine_threadsafe(
                    self.client.accept_voice_call(caller_id),
                    self.worker._loop
                )
                try:
                    success = future.result(timeout=10.0)
                    if success:
                        self.main_window._statusbar.showMessage("通话已接通", 3000)
                        logger.info(f"Call accepted successfully with {caller_id}")
                        # 更新UI状态为通话中
                        if hasattr(self, '_chat_widget') and self._chat_widget:
                            self._chat_widget.set_call_state(True, "通话中...")
                    else:
                        self.main_window._statusbar.showMessage("接听失败", 3000)
                        logger.error(f"Failed to accept call from {caller_id}")
                except Exception as e:
                    logger.error(f"Accept call error: {e}")
                    self.main_window._statusbar.showMessage(f"接听失败: {e}", 3000)
        else:
            # 拒绝
            logger.info(f"Rejecting call from {caller_id}")
            if self.client:
                self.client.reject_voice_call(caller_id)
                self.main_window._statusbar.showMessage("已拒绝来电", 3000)
    
    def _on_file_received(self, sender_id: str, file_name: str, file_path: str):
        """文件接收完成回调 - 使用信号在主线程中更新GUI"""
        logger.info(f"GUI: File received callback triggered - {sender_id}, {file_name}, {file_path}")
        # 使用信号在主线程中执行 GUI 更新
        self.file_received_signal.emit(sender_id, file_name, file_path)
    
    def _handle_file_received_ui(self, sender_id: str, file_name: str, file_path: str):
        """在主线程中处理文件接收的UI更新"""
        import os
        from datetime import datetime
        from shared.models import ChatMessage
        
        logger.info(f"GUI: _handle_file_received_ui called - sender: {sender_id}, current_peer: {self._current_chat_peer}")
        
        # 判断是否是图片
        image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'}
        ext = os.path.splitext(file_name)[1].lower()
        is_image = ext in image_extensions
        
        # 显示通知
        if is_image:
            self.main_window.show_notification("收到图片", f"来自 {sender_id}: {file_name}")
        else:
            self.main_window.show_notification("收到文件", f"来自 {sender_id}: {file_name}")
        
        self.main_window._statusbar.showMessage(f"收到文件: {file_name}，已保存到 {file_path}", 5000)
        
        # 创建消息对象
        content_type = MessageType.IMAGE if is_image else MessageType.FILE_REQUEST
        
        msg = ChatMessage(
            message_id=f"file_{datetime.now().timestamp()}",
            sender_id=sender_id,
            receiver_id=self._current_user.user_id if self._current_user else "",
            content_type=content_type,
            content=file_path,
            timestamp=datetime.now(),
            is_sent=True,
            is_read=False
        )
        
        # 如果当前没有打开聊天窗口或不是和发送者聊天，自动切换到发送者
        if self._current_chat_peer != sender_id:
            logger.info(f"GUI: Switching to chat with {sender_id}")
            self._current_chat_peer = sender_id
            if hasattr(self, '_chat_widget') and self._chat_widget:
                # 获取发送者信息
                peer_info = None
                if hasattr(self, '_contact_list_widget') and self._contact_list_widget:
                    peer_info = self._contact_list_widget.get_contact(sender_id)
                self._chat_widget.set_peer(sender_id, peer_info)
                self.main_window.set_current_chat_peer(sender_id)
        
        # 在聊天窗口显示
        if hasattr(self, '_chat_widget') and self._chat_widget:
            logger.info(f"GUI: Adding file message to chat widget")
            self._chat_widget.add_message(msg, is_self=False)
    
    def _on_contact_selected(self, user_id: str):
        """联系人选中回调 - 打开聊天窗口"""
        self._current_chat_peer = user_id
        logger.debug(f"Contact selected: {user_id}")
        
        # 获取联系人信息并打开聊天窗口
        if hasattr(self, '_contact_list_widget') and self._contact_list_widget:
            peer_info = self._contact_list_widget.get_contact(user_id)
            if hasattr(self, '_chat_widget') and self._chat_widget:
                self._chat_widget.set_peer(user_id, peer_info)
                self.main_window.set_current_chat_peer(user_id)
    
    def _on_contact_double_clicked(self, user_id: str):
        """联系人双击回调 - 打开聊天"""
        self._current_chat_peer = user_id
        logger.info(f"Opening chat with: {user_id}")
        
        # 获取联系人信息并打开聊天窗口
        if hasattr(self, '_contact_list_widget') and self._contact_list_widget:
            peer_info = self._contact_list_widget.get_contact(user_id)
            if hasattr(self, '_chat_widget') and self._chat_widget:
                self._chat_widget.set_peer(user_id, peer_info)
                self.main_window.set_current_chat_peer(user_id)
        
        self.main_window._statusbar.showMessage(f"与 {user_id} 聊天", 3000)
    
    def _on_send_message(self, peer_id: str, content: str):
        """发送消息回调"""
        if self.worker:
            success = self.worker.send_message(peer_id, content)
            if success:
                # 添加消息到聊天窗口显示
                from datetime import datetime
                from shared.models import ChatMessage
                
                msg = ChatMessage(
                    message_id=f"msg_{datetime.now().timestamp()}",
                    sender_id=self._current_user.user_id if self._current_user else "",
                    receiver_id=peer_id,
                    content_type=MessageType.TEXT,
                    content=content,
                    timestamp=datetime.now(),
                    is_sent=True
                )
                if hasattr(self, '_chat_widget') and self._chat_widget:
                    self._chat_widget.add_message(msg, is_self=True)
                
                logger.info(f"Message sent to {peer_id}")
            else:
                self.main_window._statusbar.showMessage("消息发送失败", 3000)
    
    def cleanup(self):
        """清理资源"""
        logger.info("Cleaning up resources...")
        
        if self.worker:
            self.worker.stop()
            self.worker.wait(3000)
            self.worker = None
        
        if self.client:
            # 在新的事件循环中停止客户端
            loop = asyncio.new_event_loop()
            try:
                loop.run_until_complete(self.client.stop())
            except Exception as e:
                logger.error(f"Error stopping client: {e}")
            finally:
                loop.close()
            self.client = None
        
        logger.info("Cleanup completed")


def parse_args() -> argparse.Namespace:
    """解析命令行参数"""
    parser = argparse.ArgumentParser(
        description='P2P Chat Client (GUI)',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        '--server', '-s',
        type=str,
        default=None,
        help='服务器地址 (默认: 127.0.0.1)'
    )
    parser.add_argument(
        '--port', '-p',
        type=int,
        default=None,
        help='服务器端口 (默认: 8888)'
    )
    parser.add_argument(
        '--debug',
        action='store_true',
        help='启用调试模式'
    )
    return parser.parse_args()


def main() -> int:
    """主函数"""
    args = parse_args()
    
    # 设置日志级别
    if args.debug:
        logging.getLogger().setLevel(logging.DEBUG)
    
    # 加载配置
    config = load_client_config()
    
    # 命令行参数覆盖配置
    if args.server:
        config.server_host = args.server
    if args.port:
        config.server_port = args.port
    
    # 创建并运行 GUI
    gui = P2PChatGUI(config)
    
    try:
        exit_code = gui.run()
        return exit_code
    except KeyboardInterrupt:
        logger.info("Application interrupted")
        gui.cleanup()
        return 0
    except Exception as e:
        logger.error(f"Application error: {e}")
        gui.cleanup()
        return 1


if __name__ == "__main__":
    sys.exit(main())