import random
import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext
from typing import List, Tuple, Dict, Optional
import time
from datetime import datetime

class LotterySimulator:
    """彩票模拟器核心类"""
    
    def __init__(self, name: str, price: float):
        self.name = name
        self.price = price
    
    def generate_numbers(self) -> List[int]:
        raise NotImplementedError
    
    def check_prize(self, user_numbers: List[int], draw_numbers: List[int]) -> Tuple[int, str]:
        raise NotImplementedError
    
    def get_prize_money(self, level: int) -> float:
        return 0.0
    
    def validate_numbers(self, numbers: List[int]) -> bool:
        return True

class DoubleColorBall(LotterySimulator):
    """双色球"""
    
    def __init__(self):
        super().__init__("双色球", 2.0)
        self.red_range = (1, 33)
        self.blue_range = (1, 16)
        self.red_count = 6
        self.blue_count = 1
    
    def generate_numbers(self) -> List[int]:
        reds = sorted(random.sample(range(self.red_range[0], self.red_range[1] + 1), self.red_count))
        blue = random.randint(self.blue_range[0], self.blue_range[1])
        return reds + [blue]
    
    def validate_numbers(self, numbers: List[int]) -> bool:
        if len(numbers) != 7:
            return False
        reds = numbers[:6]
        blue = numbers[6]
        if len(set(reds)) != 6:
            return False
        if not all(1 <= n <= 33 for n in reds):
            return False
        if not (1 <= blue <= 16):
            return False
        return True
    
    def check_prize(self, user_numbers: List[int], draw_numbers: List[int]) -> Tuple[int, str]:
        user_reds = set(user_numbers[:6])
        user_blue = user_numbers[6]
        draw_reds = set(draw_numbers[:6])
        draw_blue = draw_numbers[6]
        
        red_matches = len(user_reds & draw_reds)
        blue_match = (user_blue == draw_blue)
        
        if red_matches == 6 and blue_match:
            return 1, "一等奖（6红+1蓝）🌟"
        elif red_matches == 6 and not blue_match:
            return 2, "二等奖（6红+0蓝）"
        elif red_matches == 5 and blue_match:
            return 3, "三等奖（5红+1蓝）"
        elif red_matches == 5 and not blue_match:
            return 4, "四等奖（5红+0蓝）"
        elif red_matches == 4 and blue_match:
            return 4, "四等奖（4红+1蓝）"
        elif red_matches == 4 and not blue_match:
            return 5, "五等奖（4红+0蓝）"
        elif red_matches == 3 and blue_match:
            return 5, "五等奖（3红+1蓝）"
        elif red_matches == 2 and blue_match:
            return 6, "六等奖（2红+1蓝）"
        elif red_matches == 1 and blue_match:
            return 6, "六等奖（1红+1蓝）"
        elif red_matches == 0 and blue_match:
            return 6, "六等奖（0红+1蓝）"
        else:
            return 0, "未中奖 😅"
    
    def get_prize_money(self, level: int) -> float:
        prizes = {
            1: 5000000.0,
            2: 200000.0,
            3: 3000.0,
            4: 200.0,
            5: 10.0,
            6: 5.0
        }
        return prizes.get(level, 0.0)

class BigLotto(LotterySimulator):
    """大乐透"""
    
    def __init__(self):
        super().__init__("大乐透", 2.0)
        self.front_range = (1, 35)
        self.back_range = (1, 12)
        self.front_count = 5
        self.back_count = 2
    
    def generate_numbers(self) -> List[int]:
        fronts = sorted(random.sample(range(self.front_range[0], self.front_range[1] + 1), self.front_count))
        backs = sorted(random.sample(range(self.back_range[0], self.back_range[1] + 1), self.back_count))
        return fronts + backs
    
    def validate_numbers(self, numbers: List[int]) -> bool:
        if len(numbers) != 7:
            return False
        fronts = numbers[:5]
        backs = numbers[5:]
        if len(set(fronts)) != 5:
            return False
        if len(set(backs)) != 2:
            return False
        if not all(1 <= n <= 35 for n in fronts):
            return False
        if not all(1 <= n <= 12 for n in backs):
            return False
        return True
    
    def check_prize(self, user_numbers: List[int], draw_numbers: List[int]) -> Tuple[int, str]:
        user_fronts = set(user_numbers[:5])
        user_backs = set(user_numbers[5:])
        draw_fronts = set(draw_numbers[:5])
        draw_backs = set(draw_numbers[5:])
        
        front_matches = len(user_fronts & draw_fronts)
        back_matches = len(user_backs & draw_backs)
        
        if front_matches == 5 and back_matches == 2:
            return 1, "一等奖（5前+2后）🌟"
        elif front_matches == 5 and back_matches == 1:
            return 2, "二等奖（5前+1后）"
        elif front_matches == 5 and back_matches == 0:
            return 3, "三等奖（5前+0后）"
        elif front_matches == 4 and back_matches == 2:
            return 4, "四等奖（4前+2后）"
        elif front_matches == 4 and back_matches == 1:
            return 5, "五等奖（4前+1后）"
        elif front_matches == 3 and back_matches == 2:
            return 6, "六等奖（3前+2后）"
        elif front_matches == 4 and back_matches == 0:
            return 7, "七等奖（4前+0后）"
        elif front_matches == 3 and back_matches == 1:
            return 8, "八等奖（3前+1后）"
        elif front_matches == 2 and back_matches == 2:
            return 8, "八等奖（2前+2后）"
        elif front_matches == 3 and back_matches == 0:
            return 9, "九等奖（3前+0后）"
        elif front_matches == 2 and back_matches == 1:
            return 9, "九等奖（2前+1后）"
        elif front_matches == 1 and back_matches == 2:
            return 9, "九等奖（1前+2后）"
        elif front_matches == 0 and back_matches == 2:
            return 9, "九等奖（0前+2后）"
        else:
            return 0, "未中奖 😅"
    
    def get_prize_money(self, level: int) -> float:
        prizes = {
            1: 5000000.0,
            2: 200000.0,
            3: 10000.0,
            4: 3000.0,
            5: 300.0,
            6: 200.0,
            7: 100.0,
            8: 15.0,
            9: 5.0
        }
        return prizes.get(level, 0.0)

class LotteryGUI:
    """彩票模拟器图形界面"""
    
    def __init__(self, root):
        self.root = root
        self.root.title("🎰 彩票模拟器 v2.0")
        self.root.geometry("1000x750")
        self.root.resizable(True, True)
        
        # 设置样式
        self.setup_styles()
        
        # 初始化数据
        self.games = {
            "双色球": DoubleColorBall(),
            "大乐透": BigLotto()
        }
        self.history = []
        self.current_game = "双色球"
        self.is_simulating = False
        
        # 创建界面
        self.create_widgets()
        
        # 默认显示双色球
        self.update_game_info()
    
    def setup_styles(self):
        """设置颜色样式"""
        self.colors = {
            'red': '#FF4444',
            'blue': '#4444FF',
            'green': '#44BB44',
            'gold': '#FFD700',
            'bg': '#F0F0F0',
            'frame_bg': '#FFFFFF'
        }
    
    def create_widgets(self):
        """创建所有界面组件"""
        # 主容器
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        
        # 顶部标题
        title_frame = ttk.Frame(main_frame)
        title_frame.grid(row=0, column=0, columnspan=3, pady=(0, 10), sticky=(tk.W, tk.E))
        
        title_label = tk.Label(title_frame, text="🎰 彩票模拟器", 
                               font=('Arial', 20, 'bold'), fg='#2C3E50')
        title_label.pack(side=tk.LEFT)
        
        subtitle_label = tk.Label(title_frame, text="娱乐为主，理性购彩", 
                                  font=('Arial', 10), fg='#7F8C8D')
        subtitle_label.pack(side=tk.LEFT, padx=(10, 0))
        
        # 左侧控制面板
        left_frame = ttk.LabelFrame(main_frame, text="🎯 投注控制", padding="10")
        left_frame.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 10))
        
        # 彩票类型选择
        ttk.Label(left_frame, text="彩票类型:", font=('Arial', 10, 'bold')).grid(row=0, column=0, sticky=tk.W, pady=(0, 5))
        
        self.game_var = tk.StringVar(value="双色球")
        game_frame = ttk.Frame(left_frame)
        game_frame.grid(row=1, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
        
        ttk.Radiobutton(game_frame, text="双色球", variable=self.game_var, 
                       value="双色球", command=self.update_game_info).pack(side=tk.LEFT, padx=(0, 10))
        ttk.Radiobutton(game_frame, text="大乐透", variable=self.game_var, 
                       value="大乐透", command=self.update_game_info).pack(side=tk.LEFT)
        
        # 游戏信息显示
        self.info_frame = ttk.LabelFrame(left_frame, text="📋 游戏信息", padding="10")
        self.info_frame.grid(row=2, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
        
        self.info_text = tk.Text(self.info_frame, height=5, width=30, 
                                 font=('Arial', 9), bg='#F8F9FA')
        self.info_text.pack(fill=tk.BOTH, expand=True)
        
        # 投注区域
        bet_frame = ttk.LabelFrame(left_frame, text="📝 投注号码", padding="10")
        bet_frame.grid(row=3, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
        
        ttk.Label(bet_frame, text="请输入号码（用空格分隔）:").pack(anchor=tk.W)
        
        self.number_entry = tk.Text(bet_frame, height=3, width=30, font=('Arial', 10))
        self.number_entry.pack(fill=tk.BOTH, expand=True, pady=(5, 5))
        
        # 按钮区域
        button_frame = ttk.Frame(left_frame)
        button_frame.grid(row=4, column=0, sticky=(tk.W, tk.E), pady=(0, 5))
        
        ttk.Button(button_frame, text="🎲 随机一注", command=self.random_bet).pack(side=tk.LEFT, padx=(0, 5))
        ttk.Button(button_frame, text="✅ 自选投注", command=self.custom_bet).pack(side=tk.LEFT)
        
        # 快速选号按钮
        quick_frame = ttk.Frame(left_frame)
        quick_frame.grid(row=5, column=0, sticky=(tk.W, tk.E), pady=(5, 0))
        
        ttk.Button(quick_frame, text="🔴 红球随机", command=self.quick_red).pack(side=tk.LEFT, padx=(0, 5))
        ttk.Button(quick_frame, text="🔵 蓝球随机", command=self.quick_blue).pack(side=tk.LEFT)
        
        # 批量模拟控制
        sim_frame = ttk.LabelFrame(left_frame, text="📊 批量模拟", padding="10")
        sim_frame.grid(row=6, column=0, sticky=(tk.W, tk.E), pady=(10, 0))
        
        ttk.Label(sim_frame, text="模拟期数:").grid(row=0, column=0, sticky=tk.W)
        self.times_entry = ttk.Entry(sim_frame, width=10)
        self.times_entry.grid(row=0, column=1, padx=(5, 0))
        self.times_entry.insert(0, "1000")
        
        ttk.Label(sim_frame, text="预算（可选）:").grid(row=1, column=0, sticky=tk.W, pady=(5, 0))
        self.budget_entry = ttk.Entry(sim_frame, width=10)
        self.budget_entry.grid(row=1, column=1, padx=(5, 0), pady=(5, 0))
        
        ttk.Button(sim_frame, text="🚀 开始模拟", command=self.start_simulation).grid(row=2, column=0, columnspan=2, pady=(10, 0), sticky=(tk.W, tk.E))
        
        # 右侧结果显示区域
        right_frame = ttk.LabelFrame(main_frame, text="📊 结果展示", padding="10")
        right_frame.grid(row=1, column=1, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # 结果文本区域
        self.result_text = scrolledtext.ScrolledText(right_frame, height=15, 
                                                     font=('Consolas', 10), bg='#FFFFFF')
        self.result_text.pack(fill=tk.BOTH, expand=True)
        
        # 底部统计面板
        stat_frame = ttk.LabelFrame(main_frame, text="📈 统计信息", padding="10")
        stat_frame.grid(row=2, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(10, 0))
        
        self.stats_labels = {}
        stats = ["总投注", "总花费", "总奖金", "净收益", "中奖次数", "中奖率"]
        for i, stat in enumerate(stats):
            frame = ttk.Frame(stat_frame)
            frame.grid(row=0, column=i, padx=(10, 0), sticky=(tk.W, tk.E))
            
            ttk.Label(frame, text=stat + ":", font=('Arial', 9, 'bold')).pack(anchor=tk.W)
            self.stats_labels[stat] = ttk.Label(frame, text="0", font=('Arial', 9))
            self.stats_labels[stat].pack(anchor=tk.W)
        
        # 底部操作按钮
        bottom_frame = ttk.Frame(main_frame)
        bottom_frame.grid(row=3, column=0, columnspan=3, pady=(10, 0), sticky=(tk.W, tk.E))
        
        ttk.Button(bottom_frame, text="📜 查看历史", command=self.show_history).pack(side=tk.LEFT, padx=(0, 5))
        ttk.Button(bottom_frame, text="🗑️ 清空记录", command=self.clear_history).pack(side=tk.LEFT, padx=(0, 5))
        ttk.Button(bottom_frame, text="💡 使用说明", command=self.show_help).pack(side=tk.LEFT)
        
        # 配置网格权重
        main_frame.columnconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=2)
        main_frame.columnconfigure(2, weight=1)
        main_frame.rowconfigure(1, weight=1)
        right_frame.columnconfigure(0, weight=1)
        right_frame.rowconfigure(0, weight=1)
        
        # 初始化结果显示
        self.result_text.insert(tk.END, "欢迎使用彩票模拟器！\n")
        self.result_text.insert(tk.END, "请选择彩票类型，然后进行投注或模拟。\n")
        self.result_text.insert(tk.END, "=" * 50 + "\n")
    
    def update_game_info(self):
        """更新游戏信息"""
        game_type = self.game_var.get()
        game = self.games[game_type]
        
        self.info_text.delete(1.0, tk.END)
        info = f"玩法: {game.name}\n"
        info += f"价格: {game.price:.2f}元/注\n"
        
        if game_type == "双色球":
            info += f"红球: 6个 (1-33)\n"
            info += f"蓝球: 1个 (1-16)\n"
            info += f"奖项: 6个等级"
        else:
            info += f"前区: 5个 (1-35)\n"
            info += f"后区: 2个 (1-12)\n"
            info += f"奖项: 9个等级"
        
        self.info_text.insert(1.0, info)
        
        # 清空号码输入框
        self.number_entry.delete(1.0, tk.END)
        
        # 更新示例
        example = game.generate_numbers()
        if game_type == "双色球":
            self.number_entry.insert(1.0, f"示例: {' '.join(map(str, example[:6]))} | {example[6]}")
        else:
            self.number_entry.insert(1.0, f"示例: {' '.join(map(str, example[:5]))} | {' '.join(map(str, example[5:]))}")
    
    def quick_red(self):
        """快速生成红球/前区"""
        game_type = self.game_var.get()
        game = self.games[game_type]
        numbers = game.generate_numbers()
        
        self.number_entry.delete(1.0, tk.END)
        if game_type == "双色球":
            self.number_entry.insert(1.0, f"{' '.join(map(str, numbers[:6]))} | ")
        else:
            self.number_entry.insert(1.0, f"{' '.join(map(str, numbers[:5]))} | ")
    
    def quick_blue(self):
        """快速生成蓝球/后区"""
        game_type = self.game_var.get()
        game = self.games[game_type]
        numbers = game.generate_numbers()
        
        # 保留现有内容
        content = self.number_entry.get(1.0, tk.END).strip()
        if "|" in content:
            parts = content.split("|")
            if game_type == "双色球":
                self.number_entry.delete(1.0, tk.END)
                self.number_entry.insert(1.0, f"{parts[0].strip()} | {numbers[6]}")
            else:
                self.number_entry.delete(1.0, tk.END)
                self.number_entry.insert(1.0, f"{parts[0].strip()} | {' '.join(map(str, numbers[5:]))}")
    
    def parse_numbers(self, text: str, game_type: str) -> List[int]:
        """解析用户输入的号码"""
        # 移除"示例:"前缀
        if text.startswith("示例:"):
            text = text[3:]
        
        # 移除"|"分隔符
        text = text.replace("|", " ")
        
        # 分割并转换为整数
        parts = text.strip().split()
        try:
            numbers = list(map(int, parts))
        except ValueError:
            return None
        
        # 验证数量
        if game_type == "双色球" and len(numbers) != 7:
            return None
        elif game_type == "大乐透" and len(numbers) != 7:
            return None
        
        return numbers
    
    def random_bet(self):
        """随机投注"""
        game_type = self.game_var.get()
        game = self.games[game_type]
        
        # 生成随机号码
        numbers = game.generate_numbers()
        
        # 显示结果
        self.display_result(game_type, numbers, None)
    
    def custom_bet(self):
        """自选投注"""
        game_type = self.game_var.get()
        game = self.games[game_type]
        
        text = self.number_entry.get(1.0, tk.END).strip()
        numbers = self.parse_numbers(text, game_type)
        
        if numbers is None:
            messagebox.showerror("错误", "号码格式错误！\n请确保输入正确的号码数量。")
            return
        
        # 验证号码
        if not game.validate_numbers(numbers):
            messagebox.showerror("错误", "号码验证失败！\n请检查号码范围和重复情况。")
            return
        
        # 显示结果
        self.display_result(game_type, numbers, None)
    
    def display_result(self, game_type: str, user_numbers: List[int], draw_numbers: List[int] = None):
        """显示投注结果"""
        game = self.games[game_type]
        
        # 如果未提供开奖号码，自动生成
        if draw_numbers is None:
            draw_numbers = game.generate_numbers()
        
        # 检查中奖
        level, desc = game.check_prize(user_numbers, draw_numbers)
        prize = game.get_prize_money(level)
        
        # 保存历史
        result = {
            "时间": datetime.now().strftime("%H:%M:%S"),
            "彩票类型": game_type,
            "投注号码": user_numbers,
            "开奖号码": draw_numbers,
            "中奖等级": level,
            "中奖描述": desc,
            "奖金": prize
        }
        self.history.append(result)
        
        # 更新统计
        self.update_stats()
        
        # 显示结果
        self.result_text.insert(tk.END, f"\n{'='*50}\n")
        self.result_text.insert(tk.END, f"⏰ {result['时间']} | {game_type}\n")
        
        # 格式化号码显示
        if game_type == "双色球":
            user_str = f"{' '.join(map(str, user_numbers[:6]))} | {user_numbers[6]}"
            draw_str = f"{' '.join(map(str, draw_numbers[:6]))} | {draw_numbers[6]}"
        else:
            user_str = f"{' '.join(map(str, user_numbers[:5]))} | {' '.join(map(str, user_numbers[5:]))}"
            draw_str = f"{' '.join(map(str, draw_numbers[:5]))} | {' '.join(map(str, draw_numbers[5:]))}"
        
        self.result_text.insert(tk.END, f"📝 投注: {user_str}\n")
        self.result_text.insert(tk.END, f"🎯 开奖: {draw_str}\n")
        self.result_text.insert(tk.END, f"🏆 结果: {desc}\n")
        
        if prize > 0:
            self.result_text.insert(tk.END, f"💰 奖金: {prize:,.2f}元\n", "win")
        else:
            self.result_text.insert(tk.END, f"💰 奖金: 0.00元\n", "lose")
        
        # 滚动到底部
        self.result_text.see(tk.END)
        
        # 如果有大奖，弹窗提示
        if level == 1:
            messagebox.showinfo("🎉 恭喜中奖！", 
                              f"恭喜你中得一等奖！\n奖金: {prize:,.2f}元")
    
    def start_simulation(self):
        """开始批量模拟"""
        if self.is_simulating:
            return
        
        try:
            times = int(self.times_entry.get())
            if times <= 0:
                messagebox.showerror("错误", "期数必须大于0！")
                return
            
            budget_text = self.budget_entry.get().strip()
            budget = float(budget_text) if budget_text else None
            
            game_type = self.game_var.get()
            game = self.games[game_type]
            
        except ValueError:
            messagebox.showerror("错误", "请输入有效数字！")
            return
        
        # 在后台线程中运行模拟
        import threading
        self.is_simulating = True
        threading.Thread(target=self.run_simulation, args=(game_type, times, budget), daemon=True).start()
    
    def run_simulation(self, game_type: str, times: int, budget: float):
        """执行批量模拟（在后台线程中）"""
        game = self.games[game_type]
        
        total_cost = 0
        total_win = 0
        win_count = 0
        win_records = []
        
        # 更新界面
        self.root.after(0, lambda: self.result_text.insert(tk.END, f"\n{'='*50}\n"))
        self.root.after(0, lambda: self.result_text.insert(tk.END, f"🚀 开始模拟 {times} 期 {game_type}...\n"))
        
        start_time = time.time()
        
        for i in range(times):
            # 检查预算
            if budget and total_cost + game.price > budget:
                break
            
            # 生成随机号码并开奖
            user_numbers = game.generate_numbers()
            draw_numbers = game.generate_numbers()
            
            # 检查中奖
            level, desc = game.check_prize(user_numbers, draw_numbers)
            prize = game.get_prize_money(level)
            
            total_cost += game.price
            total_win += prize
            
            if level > 0:
                win_count += 1
                win_records.append({
                    "期数": i+1,
                    "等级": level,
                    "描述": desc,
                    "奖金": prize
                })
            
            # 进度提示
            if (i + 1) % 100 == 0:
                progress = (i + 1) / times * 100
                self.root.after(0, lambda p=progress: self.update_progress(p))
        
        elapsed = time.time() - start_time
        net = total_win - total_cost
        win_rate = (win_count / times * 100) if times > 0 else 0
        roi = (total_win / total_cost * 100) if total_cost > 0 else 0
        
        # 显示结果
        self.root.after(0, lambda: self.display_simulation_result(
            game_type, times, total_cost, total_win, net, 
            win_count, win_rate, roi, win_records, elapsed
        ))
        
        self.is_simulating = False
    
    def update_progress(self, progress: float):
        """更新进度（在主线程中）"""
        self.result_text.insert(tk.END, f"⏳ 模拟进度: {progress:.1f}%\n")
        self.result_text.see(tk.END)
    
    def display_simulation_result(self, game_type: str, times: int, total_cost: float, 
                                  total_win: float, net: float, win_count: int, 
                                  win_rate: float, roi: float, win_records: list, elapsed: float):
        """显示模拟结果（在主线程中）"""
        self.result_text.insert(tk.END, f"\n{'='*50}\n")
        self.result_text.insert(tk.END, f"📊 {game_type} 模拟统计结果\n")
        self.result_text.insert(tk.END, f"{'='*50}\n")
        self.result_text.insert(tk.END, f"⏱️ 耗时: {elapsed:.2f}秒\n")
        self.result_text.insert(tk.END, f"📝 模拟期数: {times}\n")
        self.result_text.insert(tk.END, f"💵 总投注金额: {total_cost:,.2f}元\n")
        self.result_text.insert(tk.END, f"🏆 总中奖金额: {total_win:,.2f}元\n")
        
        if net >= 0:
            self.result_text.insert(tk.END, f"📈 净收益: +{net:,.2f}元\n", "win")
        else:
            self.result_text.insert(tk.END, f"📉 净收益: {net:,.2f}元\n", "lose")
        
        self.result_text.insert(tk.END, f"🎯 中奖次数: {win_count}\n")
        self.result_text.insert(tk.END, f"📊 中奖率: {win_rate:.2f}%\n")
        self.result_text.insert(tk.END, f"💰 回报率: {roi:.2f}%\n")
        
        if win_records:
            self.result_text.insert(tk.END, f"\n📋 中奖明细 (前10条):\n")
            for i, record in enumerate(win_records[:10], 1):
                self.result_text.insert(tk.END, f"  {i}. 第{record['期数']}期: {record['描述']} - {record['奖金']:,.2f}元\n")
        
        self.result_text.see(tk.END)
        
        # 更新历史记录
        self.history.append({
            "时间": datetime.now().strftime("%H:%M:%S"),
            "彩票类型": game_type,
            "模拟": True,
            "期数": times,
            "总投注": total_cost,
            "总奖金": total_win,
            "净收益": net,
            "中奖率": win_rate
        })
        
        self.update_stats()
    
    def update_stats(self):
        """更新统计信息"""
        total_bets = len(self.history)
        total_cost = sum(h.get('总投注', 0) if h.get('模拟', False) else 2.0 for h in self.history)
        total_win = sum(h.get('奖金', 0) if not h.get('模拟', False) else h.get('总奖金', 0) for h in self.history)
        net = total_win - total_cost
        win_count = sum(1 for h in self.history if not h.get('模拟', False) and h.get('中奖等级', 0) > 0)
        win_rate = (win_count / len([h for h in self.history if not h.get('模拟', False)]) * 100) if [h for h in self.history if not h.get('模拟', False)] else 0
        
        # 更新标签
        self.stats_labels["总投注"].config(text=f"{len(self.history)}")
        self.stats_labels["总花费"].config(text=f"{total_cost:,.2f}元")
        self.stats_labels["总奖金"].config(text=f"{total_win:,.2f}元")
        
        if net >= 0:
            self.stats_labels["净收益"].config(text=f"+{net:,.2f}元", foreground="green")
        else:
            self.stats_labels["净收益"].config(text=f"{net:,.2f}元", foreground="red")
        
        self.stats_labels["中奖次数"].config(text=f"{win_count}")
        self.stats_labels["中奖率"].config(text=f"{win_rate:.2f}%")
    
    def show_history(self):
        """显示历史记录"""
        if not self.history:
            messagebox.showinfo("历史记录", "暂无历史记录")
            return
        
        # 创建新窗口显示历史
        history_window = tk.Toplevel(self.root)
        history_window.title("📜 历史记录")
        history_window.geometry("800x500")
        
        text_widget = scrolledtext.ScrolledText(history_window, font=('Consolas', 10))
        text_widget.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        text_widget.insert(tk.END, f"{'='*70}\n")
        text_widget.insert(tk.END, f"📜 历史记录 (共 {len(self.history)} 条)\n")
        text_widget.insert(tk.END, f"{'='*70}\n\n")
        
        for i, record in enumerate(reversed(self.history), 1):
            if record.get('模拟', False):
                text_widget.insert(tk.END, f"{i}. [{record['时间']}] {record['彩票类型']} 模拟 {record['期数']}期\n")
                text_widget.insert(tk.END, f"   投注: {record['总投注']:,.2f}元 | 奖金: {record['总奖金']:,.2f}元 | 净收益: {record['净收益']:,.2f}元\n\n")
            else:
                if record['中奖等级'] > 0:
                    text_widget.insert(tk.END, f"{i}. [{record['时间']}] {record['彩票类型']} 🎉 {record['中奖描述']}\n", "win")
                else:
                    text_widget.insert(tk.END, f"{i}. [{record['时间']}] {record['彩票类型']} {record['中奖描述']}\n", "lose")
                
                if record['中奖等级'] == 1:
                    text_widget.insert(tk.END, f"   奖金: {record['奖金']:,.2f}元 ⭐⭐⭐\n\n")
                elif record['中奖等级'] > 0:
                    text_widget.insert(tk.END, f"   奖金: {record['奖金']:,.2f}元\n\n")
                else:
                    text_widget.insert(tk.END, "\n")
        
        text_widget.config(state=tk.DISABLED)
    
    def clear_history(self):
        """清空历史记录"""
        if messagebox.askyesno("确认", "确定要清空所有历史记录吗？"):
            self.history = []
            self.result_text.delete(1.0, tk.END)
            self.result_text.insert(tk.END, "历史记录已清空\n")
            self.update_stats()
    
    def show_help(self):
        """显示使用说明"""
        help_text = """
🎰 彩票模拟器使用说明

1. 选择彩票类型
   - 双色球：6个红球(1-33) + 1个蓝球(1-16)
   - 大乐透：5个前区(1-35) + 2个后区(1-12)

2. 投注方式
   - 随机一注：系统随机生成号码
   - 自选投注：手动输入号码，用空格分隔
   - 红/蓝快速随机：快速生成部分号码

3. 批量模拟
   - 设置模拟期数和预算
   - 系统自动统计中奖率、回报率等数据

4. 提示
   - 中奖概率极低，请理性娱乐
   - 一等奖按500万估算
   - 所有数据仅在本地保存
        """
        messagebox.showinfo("使用说明", help_text)

def main():
    root = tk.Tk()
    app = LotteryGUI(root)
    root.mainloop()

if __name__ == "__main__":
    main()