websocket_gui.py

import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import threading
import time
import json
import websocket
import ssl
import urllib.parse
from datetime import datetime
import traceback  # 修复：添加traceback模块
import certifi
import os
import sys  # 修复：添加sys模块

class WebSocketTester:
    def __init__(self, root):
        self.root = root
        self.root.title("专业WebSocket测试工具 v2.0")
        self.root.geometry("950x750")
        self.root.resizable(True, True)
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)
        
        # 初始化变量
        self.websocket_url = tk.StringVar(value="wss://echo.websocket.org")
        self.proxy_url = tk.StringVar(value="127.0.0.1:8080")
        self.message_to_send = tk.StringVar(value='{"message": "Hello, WebSocket!"}')
        self.ignore_ssl = tk.BooleanVar(value=False)
        self.use_proxy = tk.BooleanVar(value=False)
        self.is_connected = False
        self.ws = None
        self.message_count = 0
        self.sent_count = 0
        self.received_count = 0
        self.connection_times = []
        self.receive_thread = None
        self.running = True
        self.response_times = []
        self.ssl_log = []  # SSL诊断日志
        
        # 创建UI组件
        self.create_ui()
        
        # 状态栏
        self.status_bar = ttk.Label(root, text="就绪", relief=tk.SUNKEN, anchor=tk.W)
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
        # SSL日志窗口（隐藏）
        self.ssl_window = None

    def create_ui(self):
        # 主框架
        main_frame = ttk.Frame(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 顶部操作面板
        top_frame = ttk.Frame(main_frame)
        top_frame.pack(fill=tk.X, pady=(0, 10))
        
        # URL输入区域
        url_frame = ttk.LabelFrame(top_frame, text="WebSocket URL")
        url_frame.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
        
        url_entry = ttk.Entry(url_frame, textvariable=self.websocket_url, width=80)
        url_entry.pack(fill=tk.X, padx=5, pady=5)
        
        # SSL选项框架
        ssl_frame = ttk.LabelFrame(top_frame, text="SSL设置")
        ssl_frame.pack(side=tk.LEFT, padx=5)
        
        # 增强SSL选项
        ssl_opt_frame = ttk.Frame(ssl_frame)
        ssl_opt_frame.pack(fill=tk.X, pady=5)
        
        ttk.Checkbutton(ssl_opt_frame, text="忽略SSL证书验证", variable=self.ignore_ssl).pack(side=tk.LEFT, padx=(5, 0))
        
        # SSL诊断按钮
        ttk.Button(ssl_opt_frame, text="SSL诊断", command=self.show_ssl_diagnostics, width=10).pack(side=tk.LEFT, padx=(10, 5))
        
        # 连接按钮区域
        conn_frame = ttk.LabelFrame(top_frame, text="连接")
        conn_frame.pack(side=tk.LEFT, padx=5)
        
        btn_frame = ttk.Frame(conn_frame)
        btn_frame.pack(padx=10, pady=5)
        
        self.connect_btn = ttk.Button(btn_frame, text="连接", command=self.connect_websocket, width=10)
        self.connect_btn.pack(side=tk.LEFT, padx=5)
        
        self.disconnect_btn = ttk.Button(btn_frame, text="断开", command=self.disconnect_websocket, 
                                       state=tk.DISABLED, width=10)
        self.disconnect_btn.pack(side=tk.LEFT, padx=5)
        
        # 中间区域：消息发送和上下文信息
        mid_frame = ttk.Frame(main_frame)
        mid_frame.pack(fill=tk.BOTH, expand=True)
        
        # 左侧控制面板
        left_frame = ttk.Frame(mid_frame)
        left_frame.pack(side=tk.LEFT, fill=tk.BOTH, padx=(0, 10), pady=5)
        
        # 消息发送区域
        send_frame = ttk.LabelFrame(left_frame, text="消息发送")
        send_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 消息输入框
        msg_entry = ttk.Entry(send_frame, textvariable=self.message_to_send)
        msg_entry.pack(fill=tk.X, padx=5, pady=(5, 0))
        
        # 发送按钮
        btn_frame = ttk.Frame(send_frame)
        btn_frame.pack(fill=tk.X, padx=5, pady=5)
        
        ttk.Button(btn_frame, text="发送消息", command=self.send_message).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="发送JSON", command=self.send_json).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="格式化JSON", command=self.format_json).pack(side=tk.LEFT, padx=5)
        
        # 功能按钮
        func_frame = ttk.Frame(send_frame)
        func_frame.pack(fill=tk.X, padx=5, pady=5)
        
        self.perf_test_btn = ttk.Button(func_frame, text="性能测试", command=self.start_performance_test)
        self.perf_test_btn.pack(side=tk.LEFT, padx=5)
        
        # 性能测试信息
        perf_info_frame = ttk.LabelFrame(left_frame, text="连接状态")
        perf_info_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 性能指标
        metrics_frame = ttk.Frame(perf_info_frame)
        metrics_frame.pack(fill=tk.X, padx=10, pady=5)
        
        # 状态标签
        ttk.Label(metrics_frame, text="状态:").grid(row=0, column=0, sticky=tk.W, padx=(0, 5))
        self.conn_status_label = ttk.Label(metrics_frame, text="未连接", foreground="red")
        self.conn_status_label.grid(row=0, column=1, sticky=tk.W)
        
        # 消息计数
        ttk.Label(metrics_frame, text="消息总数:").grid(row=1, column=0, sticky=tk.W, padx=(0, 5))
        self.total_msg_var = tk.StringVar(value="0")
        ttk.Label(metrics_frame, textvariable=self.total_msg_var).grid(row=1, column=1, sticky=tk.W)
        
        # 响应时间
        ttk.Label(metrics_frame, text="平均响应时间:").grid(row=0, column=2, sticky=tk.W, padx=(15, 5))
        self.avg_response_var = tk.StringVar(value="N/A")
        ttk.Label(metrics_frame, textvariable=self.avg_response_var).grid(row=0, column=3, sticky=tk.W)
        
        # 右面板：消息显示区域
        right_frame = ttk.LabelFrame(mid_frame, text="消息监控")
        right_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
        
        # 消息文本区域
        self.msg_text = scrolledtext.ScrolledText(right_frame, wrap=tk.WORD, state=tk.DISABLED, height=25)
        self.msg_text.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # 底部的消息控制区域
        msg_control_frame = ttk.Frame(right_frame)
        msg_control_frame.pack(fill=tk.X, padx=5, pady=(0, 5))
        
        # 消息控制按钮
        self.clear_btn = ttk.Button(msg_control_frame, text="清除消息", 
                                  command=self.clear_messages, state=tk.DISABLED)
        self.clear_btn.pack(side=tk.LEFT)
        
        ttk.Button(msg_control_frame, text="保存日志", command=self.save_log).pack(side=tk.RIGHT)
        
        # 配置标签颜色
        self.msg_text.tag_config("info", foreground="#000000")
        self.msg_text.tag_config("error", foreground="#FF0000")
        self.msg_text.tag_config("success", foreground="#008000")
        self.msg_text.tag_config("sent", foreground="#0000FF")
        self.msg_text.tag_config("received", foreground="#009000")
        self.msg_text.tag_config("ssl_debug", foreground="#600080")
        
        # 添加初始消息
        self.add_message("WebSocket测试工具已启动", "info")
        self.add_message("默认URL: wss://echo.websocket.org (浏览器服务)", "info")
        self.add_message("如果需要测试本地服务, 可使用 ws://localhost:port 格式", "info")
        self.add_message("连接时勾选'忽略SSL证书验证'可绕过证书错误", "info")

    def get_ssl_context(self):
        """创建适当的SSL上下文"""
        try:
            if self.ignore_ssl.get():
                # 创建不验证任何证书的上下文
                ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
                ssl_context.check_hostname = False
                ssl_context.verify_mode = ssl.CERT_NONE
                self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 配置SSL: 无验证模式")
                return ssl_context
            else:
                # 完整验证模式 - 使用certifi的证书包
                try:
                    ssl_context = ssl.create_default_context(cafile=certifi.where())
                    self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 配置SSL: 启用了完整验证 (证书路径: {certifi.where()})")
                    return ssl_context
                except Exception as e:
                    self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] certifi证书加载失败: {str(e)}")
                    # 尝试系统默认证书
                    ssl_context = ssl.create_default_context()
                    self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 回退到系统默认信任库")
                    return ssl_context
        except Exception as e:
            self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] SSL上下文创建失败: {str(e)}")
            self.root.after(0, lambda: self.add_message(f"SSL配置错误: {str(e)}", "error"))
            return None

    def connect_websocket(self):
        """连接WebSocket"""
        if self.is_connected:
            self.add_message("已经连接到服务器", "info")
            return
            
        url = self.websocket_url.get().strip()
        if not url:
            messagebox.showerror("错误", "请输入WebSocket URL")
            return
            
        # 添加开始连接日志
        self.add_message(f"尝试连接到: {url}", "info")
        self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 连接到: {url}")
        
        # 更新UI状态
        self.connect_btn.config(state=tk.DISABLED)
        self.disconnect_btn.config(state=tk.NORMAL)
        self.conn_status_label.config(text="连接中...", foreground="orange")
        self.status_bar.config(text=f"正在连接到 {url}")
        
        # 启动新线程连接WebSocket
        self.receive_thread = threading.Thread(target=self._connect_thread, args=(url,), daemon=True)
        self.receive_thread.start()

    def _connect_thread(self, url):
        """在新线程中处理WebSocket连接"""
        try:
            # 检查代理设置
            proxy_host = None
            proxy_port = None
            if self.use_proxy.get():
                self.add_message("使用代理连接", "info")
                proxy_url = self.proxy_url.get().strip()
                if "://" in proxy_url:
                    parsed = urllib.parse.urlparse(proxy_url)
                    proxy_host = parsed.hostname
                    proxy_port = parsed.port
                else:
                    # 直接处理 host:port 格式
                    parts = proxy_url.split(":")
                    proxy_host = parts[0]
                    proxy_port = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 8080
            
            # 设置头部
            headers = {
                "User-Agent": "WebSocket Tester/2.0",
                "Origin": "https://websockettester.app"
            }
            
            # 创建连接选项
            sslopt = {}
            if self.ignore_ssl.get():
                # 完全禁用SSL验证
                sslopt = {'cert_reqs': ssl.CERT_NONE, 'check_hostname': False}
                self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] SSL选项: 完全禁用SSL验证")
            else:
                # 使用默认SSL设置
                self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] SSL选项: 启用标准SSL验证")
            
            # 记录连接参数
            self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] SSL选项: {str(sslopt)}")
            self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 代理配置: host={proxy_host}, port={proxy_port}")
            
            try:
                # 创建连接
                start_time = time.time()
                
                # 使用新API创建连接
                self.ws = websocket.create_connection(
                    url, 
                    header=headers,
                    http_proxy_host=proxy_host,
                    http_proxy_port=proxy_port,
                    sslopt=sslopt,
                    timeout=10
                )
                
                # 记录连接时间
                connect_time = (time.time() - start_time) * 1000
                self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 连接成功 ({int(connect_time)}ms)")
                
                # 更新UI状态
                self.is_connected = True
                self.root.after(0, self._update_ui_on_connect)
                self.root.after(0, lambda: self.add_message("连接成功!", "success"))
                
                # 记录连接时间
                conn_time = time.time()
                self.connection_times.append(conn_time)
                self.root.after(0, lambda: self.conn_count_var.set(str(len(self.connection_times))))
                
                # 开始接收消息
                threading.Thread(target=self._receive_messages, daemon=True).start()
                
            except Exception as e:
                self.root.after(0, lambda: self._handle_connection_error(f"连接失败: {str(e)}"))
                self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] create_connection失败: {str(e)}")
        
        except Exception as e:
            error_msg = f"连接过程中发生错误: {str(e)}"
            stack_trace = traceback.format_exc()
            self.ssl_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 连接失败: {str(e)}")
            self.ssl_log.extend(stack_trace.splitlines())
            self.root.after(0, lambda: self._handle_connection_error(error_msg))

    def _update_ui_on_connect(self):
        """成功连接后更新UI"""
        self.conn_status_label.config(text="已连接", foreground="green")
        self.status_bar.config(text=f"已连接到服务器: {self.websocket_url.get()}")
        
    def _handle_connection_error(self, error):
        """处理连接错误"""
        try:
            self.is_connected = False
            self.root.after(0, lambda: self.connect_btn.config(state=tk.NORMAL))
            self.root.after(0, lambda: self.disconnect_btn.config(state=tk.DISABLED))
            self.root.after(0, lambda: self.conn_status_label.config(text="未连接", foreground="red"))
            self.root.after(0, lambda: self.status_bar.config(text=error))
            self.root.after(0, lambda: self.add_message(error, "error"))
            
            # 特定诊断
            if "SSL" in error.upper() or "CERT" in error.upper():
                self.root.after(0, lambda: self.add_message("SSL证书问题可能导致此错误", "error"))
                self.root.after(0, lambda: self.add_message("请尝试勾选'忽略SSL证书验证'选项", "info"))
                self.root.after(0, lambda: self.add_message("或查看SSL诊断信息获得更多帮助", "info"))
        except Exception as ui_error:
            print(f"UI错误处理失败: {str(ui_error)}")

    def disconnect_websocket(self):
        """断开WebSocket连接"""
        if not self.is_connected:
            return self.root.after(0, lambda: self.add_message("当前无活动连接", "info"))
            
        try:
            self.is_connected = False
            self.root.after(0, lambda: self.connect_btn.config(state=tk.NORMAL))
            self.root.after(0, lambda: self.disconnect_btn.config(state=tk.DISABLED))
            self.root.after(0, lambda: self.conn_status_label.config(text="未连接", foreground="red"))
            self.root.after(0, lambda: self.status_bar.config(text="已断开连接"))
            self.root.after(0, lambda: self.add_message("已断开连接", "info"))
            
            if self.ws:
                try:
                    self.ws.close()
                    self.root.after(0, lambda: self.add_message("连接已安全关闭", "success"))
                    self.ws = None
                except Exception as e:
                    self.root.after(0, lambda: self.add_message(f"关闭连接时出错: {str(e)}", "error"))
                    self.ws = None
        except Exception as e:
            self.root.after(0, lambda: self.add_message(f"断开连接时出错: {str(e)}", "error"))

    def send_message(self):
        """发送普通消息"""
        try:
            if not self.is_connected:
                self.root.after(0, lambda: self.add_message("错误: 未连接到服务器", "error"))
                return
                
            message = self.message_to_send.get().strip()
            if not message:
                self.root.after(0, lambda: self.add_message("请输入要发送的消息", "error"))
                return
                
            try:
                self.ws.send(message)
                self.sent_count += 1
                self.message_count += 1
                timestamp = datetime.now().strftime("%H:%M:%S")
                self.root.after(0, lambda: self.add_message(f"📤 [{timestamp}]: {message}", "sent"))
            except Exception as e:
                self.root.after(0, lambda: self.add_message(f"发送失败: {str(e)}", "error"))
                self.root.after(0, self.disconnect_websocket)
        except Exception as outer_e:
            self.root.after(0, lambda: self.add_message(f"发送消息时发生错误: {str(outer_e)}", "error"))

    def send_json(self):
        """发送JSON格式消息"""
        try:
            if not self.is_connected:
                self.root.after(0, lambda: self.add_message("错误: 未连接到服务器", "error"))
                return
                
            message = self.message_to_send.get().strip()
            if not message:
                self.root.after(0, lambda: self.add_message("请输入要发送的JSON消息", "error"))
                return
                
            try:
                # 验证JSON格式
                json_data = json.loads(message)
                formatted = json.dumps(json_data, indent=2)
                
                # 发送JSON消息
                self.ws.send(message)
                
                # 更新消息统计
                self.sent_count += 1
                self.message_count += 1
                
                # 显示消息
                timestamp = datetime.now().strftime("%H:%M:%S")
                self.root.after(0, lambda: self.add_message(f"📤 [JSON] [{timestamp}]:\n{formatted}", "sent"))
            except ValueError as e:
                self.root.after(0, lambda: self.add_message(f"JSON格式错误: {str(e)}", "error"))
                self.root.after(0, self.format_json)  # 尝试自动格式化
            except Exception as e:
                self.root.after(0, lambda: self.add_message(f"发送失败: {str(e)}", "error"))
                self.root.after(0, self.disconnect_websocket)
        except Exception as outer_e:
            self.root.after(0, lambda: self.add_message(f"发送JSON时发生错误: {str(outer_e)}", "error"))
            
    def format_json(self):
        """格式化JSON输入"""
        try:
            message = self.message_to_send.get().strip()
            if not message:
                return
                
            try:
                # 尝试加载为JSON
                json_data = json.loads(message)
                formatted = json.dumps(json_data, indent=2)
                self.message_to_send.set(formatted)
                self.root.after(0, lambda: self.add_message("JSON已格式化", "success"))
            except:
                # 尝试添加引号修复常见问题
                if message.startswith('{') and not message.startswith('"'):
                    fixed_message = f'"{message}"'
                    try:
                        json_data = json.loads(fixed_message)
                        self.message_to_send.set(json.dumps(json_data, indent=2))
                        self.root.after(0, lambda: self.add_message("JSON已修复并格式化", "success"))
                        return
                    except:
                        pass
                self.root.after(0, lambda: self.add_message("内容不是有效的JSON格式", "error"))
        except Exception as e:
            self.root.after(0, lambda: self.add_message(f"格式化JSON时出错: {str(e)}", "error"))

    def _receive_messages(self):
        """接收消息的主循环"""
        try:
            while self.is_connected and self.ws:
                try:
                    start_time = time.time()
                    message = self.ws.recv()
                    
                    if message is None:
                        # 服务器关闭连接
                        if self.is_connected:
                            self.root.after(0, lambda: self.add_message("连接已被服务器关闭", "error"))
                            self.root.after(0, self.disconnect_websocket)
                        break
                    
                    response_time = int((time.time() - start_time) * 1000)
                    self.response_times.append(response_time)
                    
                    # 更新统计信息
                    self.received_count += 1
                    self.message_count = self.received_count + self.sent_count
                    
                    # 在UI线程更新显示
                    self.root.after(0, lambda: self._display_received_message(message, response_time))
                    
                except websocket.WebSocketConnectionClosedException:
                    if self.is_connected:
                        self.root.after(0, lambda: self.add_message("连接已被服务器关闭", "error"))
                        self.root.after(0, self.disconnect_websocket)
                    break
                except Exception as e:
                    if self.is_connected:
                        self.root.after(0, lambda: self.add_message(f"接收消息错误: {str(e)}", "error"))
                        self.root.after(0, self.disconnect_websocket)
                    break
        finally:
            # 确保连接关闭
            if self.ws:
                try:
                    self.ws.close()
                except:
                    pass
                self.ws = None
            self.is_connected = False

    def _display_received_message(self, message, response_time):
        """显示接收到的消息"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        marker = "📥"
        
        # 长消息处理
        max_length = 1000
        if len(message) > max_length:
            display_msg = f"{message[:max_length]}... [共 {len(message)} 字符]"
        else:
            display_msg = message
        
        # 尝试格式化为JSON
        if (display_msg.startswith('{') and display_msg.endswith('}') or 
            display_msg.startswith('[') and display_msg.endswith(']')):
            try:
                parsed = json.loads(message)
                display_msg = json.dumps(parsed, indent=2)
            except:
                pass  # 保持原样
        
        # 添加消息
        self.root.after(0, lambda: self.add_message(f"{marker} [{timestamp}] [响应: {response_time}ms]:\n{display_msg}", "received"))

    def add_message(self, message, msg_type="info", show_time=True):
        """添加消息到消息框"""
        try:
            if not hasattr(self, 'msg_text') or self.msg_text is None:
                return
                
            self.msg_text.config(state=tk.NORMAL)
            
            # 控制消息数量
            line_count = int(self.msg_text.index('end-1c').split('.')[0])
            if line_count > 500:  # 限制最大消息数
                self.msg_text.delete(1.0, "end-2l")  # 删除旧消息
                
            # 添加时间戳
            if show_time:
                timestamp = datetime.now().strftime("%H:%M:%S")
                prefix = f"[{timestamp}] "
            else:
                prefix = ""
            
            # 添加新消息
            self.msg_text.insert(tk.END, prefix + message + "\n")
            
            # 应用标签
            start_index = f"{line_count}.0"
            end_index = f"end-1c"
            self.msg_text.tag_add(msg_type, start_index, end_index)
            
            self.msg_text.see(tk.END)
            self.msg_text.config(state=tk.DISABLED)
            
            # 更新清除按钮状态
            if hasattr(self, 'clear_btn') and self.clear_btn is not None:
                self.clear_btn.config(state=tk.NORMAL)
                
        except Exception as e:
            # 安全地处理错误
            try:
                if hasattr(self, 'status_bar') and self.status_bar is not None:
                    self.status_bar.config(text=f"添加消息错误: {str(e)}")
            except:
                pass

    def clear_messages(self):
        """清除消息框内容"""
        try:
            if not hasattr(self, 'msg_text') or self.msg_text is None:
                return
                
            self.msg_text.config(state=tk.NORMAL)
            self.msg_text.delete(1.0, tk.END)
            self.msg_text.insert(tk.END, "消息记录已清除 - " + 
                                datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\n")
            self.msg_text.config(state=tk.DISABLED)
            
            if hasattr(self, 'clear_btn') and self.clear_btn is not None:
                self.clear_btn.config(state=tk.DISABLED)
        except Exception as e:
            if hasattr(self, 'status_bar') and self.status_bar is not None:
                self.status_bar.config(text=f"清除消息错误: {str(e)}")

    def start_performance_test(self):
        """开始性能测试"""
        try:
            if not self.is_connected:
                self.root.after(0, lambda: self.add_message("错误: 未连接到服务器", "error"))
                return
                
            self.perf_test_btn.config(state=tk.DISABLED)
            self.root.after(0, lambda: self.add_message("开始性能测试: 发送10条消息并测量响应时间", "info"))
            
            threading.Thread(target=self._run_performance_test, daemon=True).start()
        except Exception as e:
            self.root.after(0, lambda: self.add_message(f"启动性能测试失败: {str(e)}", "error"))

    def _run_performance_test(self):
        """执行性能测试"""
        try:
            test_messages = [
                "性能测试消息 #1",
                '{"type": "performance", "index": 2}',
                str(list(range(25))),
                "消息长度中等消息中等消息中等",
                '{"value": 123.45, "active": true}',
                "测试消息 #6",
                "7" * 100,
                '{"complex": {"nested": {"data": [1,2,3]}}}',
                "测试消息 #9",
                "性能测试完成"
            ]
            
            response_times = []
            
            for idx, msg in enumerate(test_messages):
                if not self.is_connected:
                    self.root.after(0, lambda: self.add_message("性能测试中断: 连接已断开", "error"))
                    break
                    
                try:
                    self.root.after(0, lambda m=msg: self.message_to_send.set(m))
                    
                    # 发送消息
                    start_time = time.time()
                    self.ws.send(msg)
                    
                    # 接收响应
                    response = self.ws.recv()
                    
                    # 计算响应时间
                    elapsed = int((time.time() - start_time) * 1000)
                    response_times.append(elapsed)
                    
                    # 在UI更新
                    self.root.after(0, lambda: self.add_message(
                        f"📤 [性能测试]: {msg[:60]}{'...' if len(msg)>60 else ''}", 
                        "sent"
                    ))
                    self.root.after(0, lambda: self.add_message(
                        f"📥 [性能测试] {elapsed}ms: {response[:60]}{'...' if len(response)>60 else ''}", 
                        "received"
                    ))
                    
                    # 更新统计
                    self.received_count += 1
                    self.message_count += 2  # 发送和接收各计一次
                    
                    time.sleep(0.2)  # 延迟
                    
                except Exception as e:
                    self.root.after(0, lambda: self.add_message(f"性能测试中断: {str(e)}", "error"))
                    break
            
            # 显示结果
            if response_times:
                self.root.after(0, lambda: self._display_performance_summary(response_times))
                
            # 恢复按钮
            self.root.after(0, lambda: self.perf_test_btn.config(state=tk.NORMAL))
            
        except Exception as e:
            self.root.after(0, lambda: self.add_message(f"性能测试执行失败: {str(e)}", "error"))
            self.root.after(0, lambda: self.perf_test_btn.config(state=tk.NORMAL))

    def _display_performance_summary(self, response_times):
        """显示性能测试摘要"""
        try:
            avg_time = sum(response_times) / len(response_times)
            min_time = min(response_times)
            max_time = max(response_times)
            
            # 创建摘要
            summary = [
                "=" * 80,
                "性能测试结果:",
                f"总测试消息数: {len(response_times)}",
                f"平均响应时间: {avg_time:.2f}ms",
                f"最小响应时间: {min_time}ms",
                f"最大响应时间: {max_time}ms",
                f"标准差: {self.calculate_std_dev(response_times, avg_time):.2f}ms",
                f"中位响应时间: {sorted(response_times)[len(response_times)//2]}ms",
                "=" * 80
            ]
            
            # 添加消息
            for line in summary:
                self.root.after(0, lambda l=line: self.add_message(l, "success"))
                
        except Exception as e:
            self.root.after(0, lambda: self.add_message(f"生成性能报告失败: {str(e)}", "error"))

    def calculate_std_dev(self, data, mean):
        """计算标准差"""
        variance = sum((x - mean) ** 2 for x in data) / len(data)
        return variance ** 0.5

    def show_ssl_diagnostics(self):
        """显示SSL诊断信息"""
        if self.ssl_window and tk.Toplevel.winfo_exists(self.ssl_window):
            self.ssl_window.lift()
            return
            
        self.ssl_window = tk.Toplevel(self.root)
        self.ssl_window.title("SSL诊断信息")
        self.ssl_window.geometry("700x500")
        self.ssl_window.resizable(True, True)
        
        # 防止多次打开
        self.ssl_window.protocol("WM_DELETE_WINDOW", lambda: self.ssl_window.destroy())
        
        # 创建文本框
        diag_frame = ttk.Frame(self.ssl_window)
        diag_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        ssl_text = scrolledtext.ScrolledText(diag_frame, wrap=tk.WORD, height=20)
        ssl_text.pack(fill=tk.BOTH, expand=True)
        
        # 添加诊断信息
        ssl_text.config(state=tk.NORMAL)
        
        ssl_text.insert(tk.END, "=== SSL/TLS 诊断信息 ===\n", "ssl_debug")
        
        # Python版本信息
        ssl_text.insert(tk.END, f"Python版本: {sys.version}\n")
        ssl_text.insert(tk.END, f"OpenSSL版本: {ssl.OPENSSL_VERSION}\n")
        
        # 模块版本
        ssl_text.insert(tk.END, f"websocket-client版本: {websocket.__version__}\n")
        ssl_text.insert(tk.END, f"certifi版本: {certifi.__version__}\n")
        
        # 工具配置
        ssl_text.insert(tk.END, "\n当前配置:\n")
        ssl_text.insert(tk.END, f"忽略SSL验证: {'是' if self.ignore_ssl.get() else '否'}\n")
        
        # 证书路径
        ssl_text.insert(tk.END, "\n证书路径:\n")
        ssl_text.insert(tk.END, f"certifi证书位置: {certifi.where()}\n")
        ssl_text.insert(tk.END, f"默认系统证书目录: {ssl.get_default_verify_paths().openssl_capath}\n")
        
        # 连接日志
        if self.ssl_log:
            ssl_text.insert(tk.END, "\n最近操作日志:\n")
            for log in self.ssl_log[-20:]:  # 显示最近的20条日志
                ssl_text.insert(tk.END, log + "\n")
        
        # 常见问题解决
        ssl_text.insert(tk.END, "\n常见问题解决:\n", "ssl_debug")
        ssl_text.insert(tk.END, "1. SSL证书验证失败: 尝试勾选'忽略SSL证书验证'选项\n")
        ssl_text.insert(tk.END, "2. 证书问题: 在命令提示符运行: pip install --upgrade certifi\n")
        ssl_text.insert(tk.END, "3. 系统时间问题: 确保您的系统时间和日期正确\n")
        ssl_text.insert(tk.END, "4. 代理问题: 如果使用Burp, 安装Burp根证书\n\n")
        
        ssl_text.insert(tk.END, "要安装Burp证书:\n")
        ssl_text.insert(tk.END, "a. 在浏览器打开 http://burp/cert\n")
        ssl_text.insert(tk.END, "b. 下载证书并保存为burp.cer\n")
        ssl_text.insert(tk.END, "c. 在命令提示符运行: certutil -addstore -f 'Root' burp.cer\n")
        ssl_text.insert(tk.END, "d. 重启此工具\n")
        
        ssl_text.config(state=tk.DISABLED)

    def save_log(self):
        """保存日志到文件"""
        try:
            # 获取当前时间用于文件名
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"websocket_log_{timestamp}.log"
            
            # 构造日志内容
            content = "WebSocket测试工具日志\n"
            content += "=" * 50 + "\n\n"
            
            # 添加消息内容
            self.msg_text.config(state=tk.NORMAL)
            content += self.msg_text.get("1.0", tk.END)
            self.msg_text.config(state=tk.DISABLED)
            
            # 添加诊断信息
            content += "\n\n附加诊断信息:\n"
            content += f"Python版本: {sys.version}\n"
            content += f"OpenSSL版本: {ssl.OPENSSL_VERSION}\n"
            content += f"Ignore SSL: {'Yes' if self.ignore_ssl.get() else 'No'}"
            
            # 写入文件
            with open(filename, "w", encoding="utf-8") as f:
                f.write(content)
            
            self.root.after(0, lambda: self.add_message(f"日志已保存到: {filename}", "success"))
        except Exception as e:
            self.root.after(0, lambda: self.add_message(f"保存日志失败: {str(e)}", "error"))

    def on_close(self):
        """处理窗口关闭事件"""
        try:
            self.running = False
            self.disconnect_websocket()
            self.root.destroy()
        except:
            pass  # 安全地关闭

if __name__ == "__main__":
    try:
        root = tk.Tk()
        app = WebSocketTester(root)
        root.mainloop()
    except Exception as e:
        with open("crash_report.log", "a") as f:
            f.write(f"应用崩溃: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write(f"{str(e)}\n")
            f.write(traceback.format_exc())
        messagebox.showerror("致命错误", f"应用程序崩溃: {str(e)}\n详请查看 crash_report.log")