import tkinter as tk
from tkinter import ttk, messagebox, font
import random
import json
import os
from datetime import datetime
from PIL import Image, ImageTk, ImageDraw, ImageFont
import io

class RockPaperScissorsGame:
    """石头剪刀布游戏逻辑类"""
    def __init__(self):
        self.choices = ['石头', '剪刀', '布']
        self.rules = {
            '石头': '剪刀',  # 石头赢剪刀
            '剪刀': '布',    # 剪刀赢布
            '布': '石头'     # 布赢石头
        }
        self.emoji_map = {
            '石头': '✊',
            '剪刀': '✌️',
            '布': '✋'
        }
        self.user_score = 0
        self.computer_score = 0
        self.draw_count = 0
        self.round_num = 1
        self.game_history = []
        self.stats_file = "rps_stats.json"
        self.load_stats()
    
    def load_stats(self):
        """加载游戏统计"""
        if os.path.exists(self.stats_file):
            with open(self.stats_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
                self.total_games = data.get('total_games', 0)
                self.total_wins = data.get('total_wins', 0)
                self.total_losses = data.get('total_losses', 0)
                self.total_draws = data.get('total_draws', 0)
                self.best_streak = data.get('best_streak', 0)
        else:
            self.total_games = 0
            self.total_wins = 0
            self.total_losses = 0
            self.total_draws = 0
            self.best_streak = 0
    
    def save_stats(self):
        """保存游戏统计"""
        data = {
            'total_games': self.total_games + (self.round_num - 1),
            'total_wins': self.total_wins + self.user_score,
            'total_losses': self.total_losses + self.computer_score,
            'total_draws': self.total_draws + self.draw_count,
            'best_streak': self.best_streak,
            'last_played': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        with open(self.stats_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    
    def get_computer_choice(self, difficulty="normal"):
        """获取电脑选择"""
        if difficulty == "easy":
            return random.choice(self.choices)
        elif difficulty == "hard" and len(self.game_history) >= 3:
            # 困难模式：分析用户出拳模式
            recent_user_choices = [game['user'] for game in self.game_history[-3:]]
            from collections import Counter
            choice_counts = Counter(recent_user_choices)
            if choice_counts:
                most_common = choice_counts.most_common(1)[0][0]
                # 60%概率选择克制用户最常用选择的选项
                if random.random() < 0.6:
                    winning_choices = {
                        '石头': '布',
                        '剪刀': '石头',
                        '布': '剪刀'
                    }
                    return winning_choices.get(most_common, random.choice(self.choices))
        return random.choice(self.choices)
    
    def play_round(self, user_choice, difficulty="normal"):
        """进行一轮游戏"""
        computer_choice = self.get_computer_choice(difficulty)
        result = self.determine_winner(user_choice, computer_choice)
        
        # 更新分数
        if result == '你赢了':
            self.user_score += 1
        elif result == '电脑赢了':
            self.computer_score += 1
        else:
            self.draw_count += 1
        
        # 记录历史
        self.game_history.append({
            'round': self.round_num,
            'user': user_choice,
            'computer': computer_choice,
            'result': result,
            'time': datetime.now().strftime("%H:%M:%S")
        })
        
        self.round_num += 1
        
        return {
            'user_choice': user_choice,
            'computer_choice': computer_choice,
            'result': result,
            'user_emoji': self.emoji_map[user_choice],
            'computer_emoji': self.emoji_map[computer_choice]
        }
    
    def determine_winner(self, user, computer):
        """判断胜负"""
        if user == computer:
            return '平局'
        
        if self.rules[user] == computer:
            return '你赢了'
        else:
            return '电脑赢了'
    
    def reset_game(self):
        """重置游戏"""
        self.user_score = 0
        self.computer_score = 0
        self.draw_count = 0
        self.round_num = 1
        self.game_history.clear()
    
    def get_win_rate(self):
        """计算胜率"""
        total_games = self.user_score + self.computer_score + self.draw_count
        if total_games == 0:
            return 0
        return (self.user_score / total_games) * 100
    
    def get_streak(self):
        """计算连胜"""
        streak = 0
        for game in reversed(self.game_history):
            if game['result'] == '你赢了':
                streak += 1
            else:
                break
        if streak > self.best_streak:
            self.best_streak = streak
        return streak

class RockPaperScissorsGUI:
    """游戏GUI类"""
    def __init__(self, root):
        self.root = root
        self.root.title("石头剪刀布游戏")
        self.root.geometry("800x600")
        self.root.configure(bg='#f0f2f5')
        
        # 设置窗口图标
        try:
            self.root.iconbitmap(default="rps.ico")
        except:
            pass
        
        # 初始化游戏
        self.game = RockPaperScissorsGame()
        self.difficulty = tk.StringVar(value="normal")
        self.current_streak = 0
        
        # 创建界面
        self.create_widgets()
        self.center_window()
    
    def center_window(self):
        """窗口居中"""
        self.root.update_idletasks()
        width = self.root.winfo_width()
        height = self.root.winfo_height()
        x = (self.root.winfo_screenwidth() // 2) - (width // 2)
        y = (self.root.winfo_screenheight() // 2) - (height // 2)
        self.root.geometry(f'{width}x{height}+{x}+{y}')
    
    def create_widgets(self):
        """创建所有界面组件"""
        # 主框架
        main_frame = tk.Frame(self.root, bg='#f0f2f5')
        main_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # 标题
        title_label = tk.Label(
            main_frame,
            text="✊ ✌️ ✋ 石头剪刀布 ✋ ✌️ ✊",
            font=('Microsoft YaHei', 24, 'bold'),
            bg='#f0f2f5',
            fg='#2c3e50'
        )
        title_label.pack(pady=(0, 20))
        
        # 游戏区域框架
        game_frame = tk.Frame(main_frame, bg='white', relief=tk.RAISED, bd=2)
        game_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 20))
        
        # 游戏状态栏
        self.create_status_bar(game_frame)
        
        # 游戏显示区域
        self.create_game_display(game_frame)
        
        # 玩家选择区域
        self.create_player_controls(game_frame)
        
        # 控制面板
        self.create_control_panel(main_frame)
        
        # 绑定键盘事件
        self.root.bind('<Key>', self.on_key_press)
    
    def create_status_bar(self, parent):
        """创建状态栏"""
        status_frame = tk.Frame(parent, bg='#34495e', height=60)
        status_frame.pack(fill=tk.X, pady=(0, 20))
        status_frame.pack_propagate(False)
        
        # 当前比分
        score_frame = tk.Frame(status_frame, bg='#34495e')
        score_frame.pack(side=tk.LEFT, padx=20)
        
        tk.Label(
            score_frame,
            text="当前比分",
            font=('Microsoft YaHei', 10),
            bg='#34495e',
            fg='#ecf0f1'
        ).pack()
        
        self.score_label = tk.Label(
            score_frame,
            text="你 0 - 0 电脑",
            font=('Microsoft YaHei', 16, 'bold'),
            bg='#34495e',
            fg='#f1c40f'
        )
        self.score_label.pack()
        
        # 回合数
        round_frame = tk.Frame(status_frame, bg='#34495e')
        round_frame.pack(side=tk.LEFT, padx=40)
        
        tk.Label(
            round_frame,
            text="第 1 回合",
            font=('Microsoft YaHei', 12),
            bg='#34495e',
            fg='#ecf0f1'
        ).pack()
        
        # 胜率
        winrate_frame = tk.Frame(status_frame, bg='#34495e')
        winrate_frame.pack(side=tk.RIGHT, padx=20)
        
        tk.Label(
            winrate_frame,
            text="胜率",
            font=('Microsoft YaHei', 10),
            bg='#34495e',
            fg='#ecf0f1'
        ).pack()
        
        self.winrate_label = tk.Label(
            winrate_frame,
            text="0%",
            font=('Microsoft YaHei', 16, 'bold'),
            bg='#34495e',
            fg='#2ecc71'
        )
        self.winrate_label.pack()
    
    def create_game_display(self, parent):
        """创建游戏显示区域"""
        display_frame = tk.Frame(parent, bg='white')
        display_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=(0, 20))
        
        # 电脑区域
        computer_frame = tk.Frame(display_frame, bg='white')
        computer_frame.pack(fill=tk.X, pady=(0, 10))
        
        tk.Label(
            computer_frame,
            text="电脑",
            font=('Microsoft YaHei', 14, 'bold'),
            bg='white',
            fg='#e74c3c'
        ).pack(side=tk.LEFT, padx=(0, 20))
        
        self.computer_choice_label = tk.Label(
            computer_frame,
            text="❓",
            font=('Arial', 60),
            bg='white',
            fg='#e74c3c'
        )
        self.computer_choice_label.pack(side=tk.LEFT)
        
        self.computer_text_label = tk.Label(
            computer_frame,
            text="等待中...",
            font=('Microsoft YaHei', 16),
            bg='white',
            fg='#7f8c8d'
        )
        self.computer_text_label.pack(side=tk.LEFT, padx=(20, 0))
        
        # 对战符号
        vs_frame = tk.Frame(display_frame, bg='white')
        vs_frame.pack(pady=10)
        
        self.vs_label = tk.Label(
            vs_frame,
            text="VS",
            font=('Microsoft YaHei', 24, 'bold'),
            bg='white',
            fg='#f39c12'
        )
        self.vs_label.pack()
        
        # 玩家区域
        player_frame = tk.Frame(display_frame, bg='white')
        player_frame.pack(fill=tk.X, pady=(10, 0))
        
        tk.Label(
            player_frame,
            text="你",
            font=('Microsoft YaHei', 14, 'bold'),
            bg='white',
            fg='#3498db'
        ).pack(side=tk.LEFT, padx=(0, 20))
        
        self.player_choice_label = tk.Label(
            player_frame,
            text="❓",
            font=('Arial', 60),
            bg='white',
            fg='#3498db'
        )
        self.player_choice_label.pack(side=tk.LEFT)
        
        self.player_text_label = tk.Label(
            player_frame,
            text="请选择...",
            font=('Microsoft YaHei', 16),
            bg='white',
            fg='#7f8c8d'
        )
        self.player_text_label.pack(side=tk.LEFT, padx=(20, 0))
        
        # 结果显示
        result_frame = tk.Frame(display_frame, bg='white')
        result_frame.pack(fill=tk.X, pady=(20, 0))
        
        self.result_label = tk.Label(
            result_frame,
            text="等待开始...",
            font=('Microsoft YaHei', 20, 'bold'),
            bg='white',
            fg='#2c3e50'
        )
        self.result_label.pack()
        
        self.result_detail_label = tk.Label(
            result_frame,
            text="选择你的出拳！",
            font=('Microsoft YaHei', 12),
            bg='white',
            fg='#95a5a6'
        )
        self.result_detail_label.pack()
    
    def create_player_controls(self, parent):
        """创建玩家控制区域"""
        control_frame = tk.Frame(parent, bg='white')
        control_frame.pack(fill=tk.X, padx=20, pady=(0, 20))
        
        tk.Label(
            control_frame,
            text="选择你的出拳:",
            font=('Microsoft YaHei', 12),
            bg='white',
            fg='#2c3e50'
        ).pack()
        
        # 按钮框架
        buttons_frame = tk.Frame(control_frame, bg='white')
        buttons_frame.pack(pady=10)
        
        # 石头按钮
        self.rock_btn = tk.Button(
            buttons_frame,
            text="✊\n石头\n(1/R)",
            font=('Microsoft YaHei', 16),
            bg='#3498db',
            fg='white',
            width=8,
            height=3,
            relief=tk.RAISED,
            bd=3,
            command=lambda: self.player_choice('石头')
        )
        self.rock_btn.pack(side=tk.LEFT, padx=5)
        
        # 剪刀按钮
        self.scissors_btn = tk.Button(
            buttons_frame,
            text="✌️\n剪刀\n(2/S)",
            font=('Microsoft YaHei', 16),
            bg='#2ecc71',
            fg='white',
            width=8,
            height=3,
            relief=tk.RAISED,
            bd=3,
            command=lambda: self.player_choice('剪刀')
        )
        self.scissors_btn.pack(side=tk.LEFT, padx=5)
        
        # 布按钮
        self.paper_btn = tk.Button(
            buttons_frame,
            text="✋\n布\n(3/P)",
            font=('Microsoft YaHei', 16),
            bg='#e74c3c',
            fg='white',
            width=8,
            height=3,
            relief=tk.RAISED,
            bd=3,
            command=lambda: self.player_choice('布')
        )
        self.paper_btn.pack(side=tk.LEFT, padx=5)
        
        # 快捷键提示
        shortcut_frame = tk.Frame(control_frame, bg='white')
        shortcut_frame.pack(pady=(5, 0))
        
        tk.Label(
            shortcut_frame,
            text="快捷键: 1-石头 2-剪刀 3-布 R-重置 S-统计 H-历史",
            font=('Microsoft YaHei', 9),
            bg='white',
            fg='#7f8c8d'
        ).pack()
    
    def create_control_panel(self, parent):
        """创建控制面板"""
        control_panel = tk.Frame(parent, bg='#f0f2f5')
        control_panel.pack(fill=tk.X)
        
        # 左侧按钮
        left_frame = tk.Frame(control_panel, bg='#f0f2f5')
        left_frame.pack(side=tk.LEFT)
        
        # 重置按钮
        reset_btn = tk.Button(
            left_frame,
            text="🔄 重新开始",
            font=('Microsoft YaHei', 10),
            bg='#95a5a6',
            fg='white',
            width=12,
            height=2,
            command=self.reset_game
        )
        reset_btn.pack(side=tk.LEFT, padx=5)
        
        # 历史记录按钮
        history_btn = tk.Button(
            left_frame,
            text="📊 查看历史",
            font=('Microsoft YaHei', 10),
            bg='#3498db',
            fg='white',
            width=12,
            height=2,
            command=self.show_history
        )
        history_btn.pack(side=tk.LEFT, padx=5)
        
        # 统计按钮
        stats_btn = tk.Button(
            left_frame,
            text="📈 游戏统计",
            font=('Microsoft YaHei', 10),
            bg='#2ecc71',
            fg='white',
            width=12,
            height=2,
            command=self.show_stats
        )
        stats_btn.pack(side=tk.LEFT, padx=5)
        
        # 右侧难度选择
        right_frame = tk.Frame(control_panel, bg='#f0f2f5')
        right_frame.pack(side=tk.RIGHT)
        
        tk.Label(
            right_frame,
            text="难度:",
            font=('Microsoft YaHei', 10),
            bg='#f0f2f5',
            fg='#2c3e50'
        ).pack(side=tk.LEFT, padx=(0, 5))
        
        # 难度选择
        difficulty_frame = tk.Frame(right_frame, bg='#f0f2f5')
        difficulty_frame.pack(side=tk.LEFT)
        
        difficulties = [
            ("简单", "easy"),
            ("普通", "normal"),
            ("困难", "hard")
        ]
        
        for text, value in difficulties:
            rb = tk.Radiobutton(
                difficulty_frame,
                text=text,
                variable=self.difficulty,
                value=value,
                bg='#f0f2f5',
                font=('Microsoft YaHei', 9),
                command=self.update_difficulty
            )
            rb.pack(side=tk.LEFT, padx=2)
    
    def player_choice(self, choice):
        """玩家选择"""
        # 禁用按钮防止重复点击
        self.rock_btn.config(state=tk.DISABLED)
        self.scissors_btn.config(state=tk.DISABLED)
        self.paper_btn.config(state=tk.DISABLED)
        
        # 更新玩家显示
        self.player_choice_label.config(text=self.game.emoji_map[choice])
        self.player_text_label.config(text=choice)
        
        # 显示"电脑思考中..."
        self.computer_choice_label.config(text="🤔")
        self.computer_text_label.config(text="思考中...")
        self.vs_label.config(text="...")
        self.result_label.config(text="电脑思考中...", fg='#f39c12')
        
        # 延迟显示电脑选择（模拟思考过程）
        self.root.after(800, lambda: self.show_computer_choice(choice))
    
    def show_computer_choice(self, user_choice):
        """显示电脑选择并计算结果"""
        # 获取电脑选择
        result = self.game.play_round(user_choice, self.difficulty.get())
        
        # 更新电脑显示
        self.computer_choice_label.config(text=result['computer_emoji'])
        self.computer_text_label.config(text=result['computer_choice'])
        self.vs_label.config(text="VS")
        
        # 显示结果
        result_color = {
            '你赢了': '#2ecc71',
            '电脑赢了': '#e74c3c',
            '平局': '#f39c12'
        }
        
        result_emoji = {
            '你赢了': '🎉 恭喜！',
            '电脑赢了': '😢 再接再厉',
            '平局': '🤝 平手'
        }
        
        self.result_label.config(
            text=f"{result_emoji[result['result']]}",
            fg=result_color[result['result']]
        )
        self.result_detail_label.config(
            text=f"{user_choice} vs {result['computer_choice']} → {result['result']}"
        )
        
        # 更新分数显示
        self.update_score_display()
        
        # 启用按钮
        self.root.after(1000, self.enable_buttons)
    
    def update_score_display(self):
        """更新分数显示"""
        self.score_label.config(text=f"你 {self.game.user_score} - {self.game.computer_score} 电脑")
        
        # 更新回合数
        round_label = self.score_label.master.master.winfo_children()[1].winfo_children()[0]
        round_label.config(text=f"第 {self.game.round_num} 回合")
        
        # 更新胜率
        win_rate = self.game.get_win_rate()
        self.winrate_label.config(text=f"{win_rate:.1f}%")
        
        # 更新连胜
        streak = self.game.get_streak()
        if streak > 1:
            self.result_label.config(text=f"{self.result_label.cget('text')} (连胜{streak}局！)")
    
    def enable_buttons(self):
        """启用所有按钮"""
        self.rock_btn.config(state=tk.NORMAL)
        self.scissors_btn.config(state=tk.NORMAL)
        self.paper_btn.config(state=tk.NORMAL)
    
    def reset_game(self):
        """重置游戏"""
        if self.game.round_num > 1:  # 只有有游戏记录时才保存
            self.game.save_stats()
        
        self.game.reset_game()
        
        # 重置显示
        self.player_choice_label.config(text="❓")
        self.player_text_label.config(text="请选择...")
        self.computer_choice_label.config(text="❓")
        self.computer_text_label.config(text="等待中...")
        self.result_label.config(text="等待开始...", fg='#2c3e50')
        self.result_detail_label.config(text="选择你的出拳！")
        
        # 更新分数显示
        self.update_score_display()
        
        # 启用按钮
        self.enable_buttons()
    
    def show_history(self):
        """显示历史记录窗口"""
        if not self.game.game_history:
            messagebox.showinfo("历史记录", "暂无游戏历史")
            return
        
        history_window = tk.Toplevel(self.root)
        history_window.title("游戏历史记录")
        history_window.geometry("500x400")
        history_window.configure(bg='white')
        history_window.transient(self.root)
        history_window.grab_set()
        
        # 居中显示
        history_window.update_idletasks()
        width = history_window.winfo_width()
        height = history_window.winfo_height()
        x = (history_window.winfo_screenwidth() // 2) - (width // 2)
        y = (history_window.winfo_screenheight() // 2) - (height // 2)
        history_window.geometry(f'{500}x{400}+{x}+{y}')
        
        # 标题
        tk.Label(
            history_window,
            text="游戏历史记录",
            font=('Microsoft YaHei', 16, 'bold'),
            bg='white',
            fg='#2c3e50'
        ).pack(pady=10)
        
        # 创建文本框
        text_frame = tk.Frame(history_window, bg='white')
        text_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=(0, 20))
        
        # 添加滚动条
        scrollbar = tk.Scrollbar(text_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        history_text = tk.Text(
            text_frame,
            height=15,
            width=50,
            font=('Microsoft YaHei', 10),
            bg='#f8f9fa',
            yscrollcommand=scrollbar.set
        )
        history_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.config(command=history_text.yview)
        
        # 添加历史记录
        history_text.insert(tk.END, f"{'回合':<6} {'你的选择':<8} {'电脑选择':<8} {'结果':<8} {'时间':<8}\n")
        history_text.insert(tk.END, "="*45 + "\n")
        
        for game in self.game.game_history[-20:]:  # 显示最近20条
            result_symbol = {
                '你赢了': '✓',
                '电脑赢了': '✗',
                '平局': '='
            }.get(game['result'], '?')
            
            history_text.insert(
                tk.END,
                f"{game['round']:<6} {game['user']:<8} {game['computer']:<8} "
                f"{result_symbol:<8} {game['time']:<8}\n"
            )
        
        history_text.config(state=tk.DISABLED)  # 设置为只读
        
        # 关闭按钮
        tk.Button(
            history_window,
            text="关闭",
            font=('Microsoft YaHei', 10),
            command=history_window.destroy,
            width=15
        ).pack(pady=10)
    
    def show_stats(self):
        """显示统计窗口"""
        # 计算统计数据
        total_games = self.game.total_games + (self.game.round_num - 1)
        total_wins = self.game.total_wins + self.game.user_score
        total_losses = self.game.total_losses + self.game.computer_score
        total_draws = self.game.total_draws + self.game.draw_count
        
        win_rate = (total_wins / total_games * 100) if total_games > 0 else 0
        
        stats_window = tk.Toplevel(self.root)
        stats_window.title("游戏统计")
        stats_window.geometry("400x500")
        stats_window.configure(bg='white')
        stats_window.transient(self.root)
        stats_window.grab_set()
        
        # 居中显示
        stats_window.update_idletasks()
        width = stats_window.winfo_width()
        height = stats_window.winfo_height()
        x = (stats_window.winfo_screenwidth() // 2) - (width // 2)
        y = (stats_window.winfo_screenheight() // 2) - (height // 2)
        stats_window.geometry(f'{400}x{500}+{x}+{y}')
        
        # 标题
        tk.Label(
            stats_window,
            text="📊 游戏统计",
            font=('Microsoft YaHei', 20, 'bold'),
            bg='white',
            fg='#2c3e50'
        ).pack(pady=20)
        
        # 统计信息框架
        stats_frame = tk.Frame(stats_window, bg='white')
        stats_frame.pack(fill=tk.BOTH, expand=True, padx=30)
        
        # 总对局
        self.create_stat_item(stats_frame, "总对局数", f"{total_games} 局", 0)
        
        # 胜负平
        self.create_stat_item(stats_frame, "胜利", f"{total_wins} 局", 1, '#2ecc71')
        self.create_stat_item(stats_frame, "失败", f"{total_losses} 局", 2, '#e74c3c')
        self.create_stat_item(stats_frame, "平局", f"{total_draws} 局", 3, '#f39c12')
        
        # 胜率
        self.create_stat_item(stats_frame, "胜率", f"{win_rate:.1f}%", 4, '#3498db')
        
        # 当前连胜
        current_streak = self.game.get_streak()
        self.create_stat_item(stats_frame, "当前连胜", f"{current_streak} 局", 5, '#9b59b6')
        
        # 最高连胜
        self.create_stat_item(stats_frame, "最高连胜", f"{self.game.best_streak} 局", 6, '#e67e22')
        
        # 当前游戏统计
        tk.Label(
            stats_frame,
            text="-"*30 + "\n本局统计",
            font=('Microsoft YaHei', 12, 'bold'),
            bg='white',
            fg='#2c3e50'
        ).grid(row=7, column=0, columnspan=2, pady=(20, 10), sticky='w')
        
        self.create_stat_item(stats_frame, "当前比分", 
                             f"{self.game.user_score} - {self.game.computer_score}", 8)
        self.create_stat_item(stats_frame, "本局胜率", 
                             f"{self.game.get_win_rate():.1f}%", 9, '#3498db')
        
        # 关闭按钮
        tk.Button(
            stats_window,
            text="关闭",
            font=('Microsoft YaHei', 10),
            command=stats_window.destroy,
            width=15
        ).pack(pady=20)
    
    def create_stat_item(self, parent, label, value, row, color='#2c3e50'):
        """创建统计项"""
        tk.Label(
            parent,
            text=label + ":",
            font=('Microsoft YaHei', 11),
            bg='white',
            fg='#7f8c8d'
        ).grid(row=row, column=0, sticky='w', pady=5)
        
        tk.Label(
            parent,
            text=value,
            font=('Microsoft YaHei', 12, 'bold'),
            bg='white',
            fg=color
        ).grid(row=row, column=1, sticky='e', pady=5)
    
    def update_difficulty(self):
        """更新难度设置"""
        difficulty_text = {
            "easy": "简单",
            "normal": "普通", 
            "hard": "困难"
        }
        messagebox.showinfo("难度设置", 
                          f"已切换为 {difficulty_text[self.difficulty.get()]} 模式")
    
    def on_key_press(self, event):
        """键盘事件处理"""
        key = event.char.lower()
        
        if key in ['1', 'r']:
            self.player_choice('石头')
        elif key in ['2', 's']:
            self.player_choice('剪刀')
        elif key in ['3', 'p']:
            self.player_choice('布')
        elif key == 'r' and event.state & 0x4:  # Ctrl+R
            self.reset_game()
        elif key == 'h':
            self.show_history()
        elif key == 's':
            self.show_stats()
    
    def on_closing(self):
        """窗口关闭时保存数据"""
        if self.game.round_num > 1:
            self.game.save_stats()
        self.root.destroy()

def main():
    """主函数"""
    root = tk.Tk()
    
    # 设置窗口样式
    try:
        root.tk.call('source', 'azure.tcl')
        root.tk.call('set_theme', 'dark')
    except:
        pass
    
    app = RockPaperScissorsGUI(root)
    
    # 绑定关闭事件
    root.protocol("WM_DELETE_WINDOW", app.on_closing)
    
    # 运行主循环
    root.mainloop()

if __name__ == "__main__":
    main()