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

class WordMemoryApp:
    """单词数据管理类"""
    def __init__(self, data_file="words_data.json"):
        self.data_file = data_file
        self.words = self.load_data()
        
    def load_data(self):
        if os.path.exists(self.data_file):
            with open(self.data_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        return {}
    
    def save_data(self):
        with open(self.data_file, 'w', encoding='utf-8') as f:
            json.dump(self.words, f, ensure_ascii=False, indent=2)
    
    def add_word(self, english, chinese, category="general"):
        word_id = str(len(self.words) + 1)
        self.words[word_id] = {
            "english": english,
            "chinese": chinese,
            "category": category,
            "added_date": datetime.now().strftime("%Y-%m-%d"),
            "review_count": 0,
            "correct_count": 0,
            "last_review": None,
            "mastery": 0
        }
        self.save_data()
        return word_id
    
    def get_word_count(self):
        return len(self.words)
    
    def get_review_stats(self):
        total_reviews = sum(w.get('review_count', 0) for w in self.words.values())
        total_correct = sum(w.get('correct_count', 0) for w in self.words.values())
        return total_reviews, total_correct
    
    def get_words_for_review(self, num=5):
        if not self.words:
            return []
        
        word_ids = list(self.words.keys())
        # 优先选择掌握度低的单词
        word_ids.sort(key=lambda x: self.words[x].get('mastery', 0))
        return random.sample(word_ids, min(num, len(word_ids)))
    
    def update_review_result(self, word_id, is_correct):
        if word_id in self.words:
            word = self.words[word_id]
            word['review_count'] += 1
            word['last_review'] = datetime.now().strftime("%Y-%m-%d %H:%M")
            
            if is_correct:
                word['correct_count'] += 1
                word['mastery'] = min(100, word.get('mastery', 0) + 20)
            else:
                word['mastery'] = max(0, word.get('mastery', 0) - 10)
            
            self.save_data()

class WordMemoryGUI:
    """主界面类"""
    def __init__(self, root):
        self.root = root
        self.root.title("英语单词背诵助手")
        self.root.geometry("900x700")
        self.root.configure(bg='#f0f0f0')
        
        # 设置图标
        try:
            self.root.iconbitmap("word_icon.ico")
        except:
            pass
        
        # 初始化数据
        self.app = WordMemoryApp()
        self.current_review_words = []
        self.current_review_index = 0
        self.review_correct = 0
        
        # 设置样式
        self.setup_styles()
        
        # 创建界面
        self.create_widgets()
        self.load_sample_data_if_empty()
        
    def setup_styles(self):
        """设置样式"""
        style = ttk.Style()
        style.theme_use('clam')
        
        # 自定义颜色
        self.colors = {
            'primary': '#4a6fa5',
            'secondary': '#6b9ac4',
            'success': '#2e8b57',
            'warning': '#ffa500',
            'danger': '#dc143c',
            'light': '#f8f9fa',
            'dark': '#343a40',
            'background': '#f0f0f0'
        }
        
    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)
        main_frame.columnconfigure(0, weight=1)
        main_frame.rowconfigure(1, weight=1)
        
        # 标题
        title_label = ttk.Label(
            main_frame, 
            text="📚 英语单词背诵助手", 
            font=('Microsoft YaHei', 20, 'bold'),
            foreground=self.colors['primary']
        )
        title_label.grid(row=0, column=0, pady=(0, 20))
        
        # 创建标签页
        self.notebook = ttk.Notebook(main_frame)
        self.notebook.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # 创建各个页面
        self.create_dashboard_tab()
        self.create_add_word_tab()
        self.create_review_tab()
        self.create_test_tab()
        self.create_words_tab()
        self.create_stats_tab()
        
        # 状态栏
        self.create_status_bar(main_frame)
        
    def create_dashboard_tab(self):
        """创建仪表板标签页"""
        dashboard_frame = ttk.Frame(self.notebook, padding="20")
        self.notebook.add(dashboard_frame, text="🏠 仪表板")
        
        # 欢迎信息
        welcome_label = ttk.Label(
            dashboard_frame,
            text="欢迎使用英语单词背诵助手！",
            font=('Microsoft YaHei', 16)
        )
        welcome_label.pack(pady=(0, 30))
        
        # 统计卡片框架
        stats_frame = ttk.Frame(dashboard_frame)
        stats_frame.pack(fill=tk.X, pady=(0, 30))
        
        # 单词总数卡片
        total_card = self.create_stat_card(
            stats_frame,
            "📊 单词总数",
            str(self.app.get_word_count()),
            self.colors['primary']
        )
        total_card.pack(side=tk.LEFT, padx=5, expand=True, fill=tk.BOTH)
        
        # 今日复习卡片
        review_card = self.create_stat_card(
            stats_frame,
            "📅 今日复习",
            "0",
            self.colors['secondary']
        )
        review_card.pack(side=tk.LEFT, padx=5, expand=True, fill=tk.BOTH)
        
        # 正确率卡片
        total_reviews, total_correct = self.app.get_review_stats()
        accuracy = (total_correct / total_reviews * 100) if total_reviews > 0 else 0
        accuracy_card = self.create_stat_card(
            stats_frame,
            "🎯 总正确率",
            f"{accuracy:.1f}%" if total_reviews > 0 else "N/A",
            self.colors['success']
        )
        accuracy_card.pack(side=tk.LEFT, padx=5, expand=True, fill=tk.BOTH)
        
        # 快速操作按钮
        quick_frame = ttk.LabelFrame(dashboard_frame, text="快速操作", padding="20")
        quick_frame.pack(fill=tk.X, pady=(0, 20))
        
        btn_frame = ttk.Frame(quick_frame)
        btn_frame.pack()
        
        ttk.Button(
            btn_frame,
            text="➕ 添加新单词",
            command=lambda: self.notebook.select(1)
        ).pack(side=tk.LEFT, padx=5)
        
        ttk.Button(
            btn_frame,
            text="📖 开始复习",
            command=lambda: self.notebook.select(2)
        ).pack(side=tk.LEFT, padx=5)
        
        ttk.Button(
            btn_frame,
            text="📝 开始测试",
            command=lambda: self.notebook.select(3)
        ).pack(side=tk.LEFT, padx=5)
        
        # 今日目标进度
        progress_frame = ttk.LabelFrame(dashboard_frame, text="今日目标", padding="20")
        progress_frame.pack(fill=tk.X)
        
        ttk.Label(
            progress_frame,
            text="每日目标: 复习20个单词"
        ).pack(anchor=tk.W)
        
        self.progress_var = tk.DoubleVar(value=0)
        progress_bar = ttk.Progressbar(
            progress_frame,
            variable=self.progress_var,
            length=400,
            mode='determinate'
        )
        progress_bar.pack(fill=tk.X, pady=(5, 0))
        
        self.progress_label = ttk.Label(
            progress_frame,
            text="0/20 (0%)"
        )
        self.progress_label.pack(pady=(5, 0))
        
    def create_stat_card(self, parent, title, value, color):
        """创建统计卡片"""
        card = ttk.Frame(parent, relief=tk.RAISED, borderwidth=2)
        
        # 标题
        title_label = ttk.Label(
            card,
            text=title,
            font=('Microsoft YaHei', 10),
            foreground='gray'
        )
        title_label.pack(pady=(10, 5))
        
        # 数值
        value_label = ttk.Label(
            card,
            text=value,
            font=('Microsoft YaHei', 18, 'bold'),
            foreground=color
        )
        value_label.pack(pady=(0, 10))
        
        return card
    
    def create_add_word_tab(self):
        """创建添加单词标签页"""
        add_frame = ttk.Frame(self.notebook, padding="20")
        self.notebook.add(add_frame, text="➕ 添加单词")
        
        # 输入表单
        form_frame = ttk.LabelFrame(add_frame, text="输入单词信息", padding="20")
        form_frame.pack(fill=tk.BOTH, expand=True)
        
        # 英文单词
        ttk.Label(form_frame, text="英文单词:", font=('Microsoft YaHei', 10)).grid(
            row=0, column=0, sticky=tk.W, pady=(0, 5))
        self.eng_entry = ttk.Entry(form_frame, width=30, font=('Microsoft YaHei', 10))
        self.eng_entry.grid(row=0, column=1, sticky=(tk.W, tk.E), pady=(0, 10), padx=(10, 0))
        
        # 中文释义
        ttk.Label(form_frame, text="中文释义:", font=('Microsoft YaHei', 10)).grid(
            row=1, column=0, sticky=tk.W, pady=(0, 5))
        self.chi_entry = ttk.Entry(form_frame, width=30, font=('Microsoft YaHei', 10))
        self.chi_entry.grid(row=1, column=1, sticky=(tk.W, tk.E), pady=(0, 10), padx=(10, 0))
        
        # 分类
        ttk.Label(form_frame, text="分类:", font=('Microsoft YaHei', 10)).grid(
            row=2, column=0, sticky=tk.W, pady=(0, 5))
        self.cat_combo = ttk.Combobox(
            form_frame,
            width=28,
            font=('Microsoft YaHei', 10),
            values=["general", "study", "work", "travel", "business", "technology", "food"]
        )
        self.cat_combo.set("general")
        self.cat_combo.grid(row=2, column=1, sticky=(tk.W, tk.E), pady=(0, 20), padx=(10, 0))
        
        # 添加按钮
        ttk.Button(
            form_frame,
            text="添加单词",
            command=self.add_new_word,
            style='Accent.TButton'
        ).grid(row=3, column=0, columnspan=2, pady=(10, 0))
        
        # 批量添加区域
        batch_frame = ttk.LabelFrame(add_frame, text="批量添加 (每行: 英文,中文,分类)", padding="20")
        batch_frame.pack(fill=tk.BOTH, expand=True, pady=(20, 0))
        
        self.batch_text = scrolledtext.ScrolledText(
            batch_frame,
            height=8,
            width=50,
            font=('Microsoft YaHei', 10)
        )
        self.batch_text.pack(fill=tk.BOTH, expand=True)
        
        ttk.Button(
            batch_frame,
            text="批量添加",
            command=self.add_batch_words
        ).pack(pady=(10, 0))
        
        # 配置网格权重
        form_frame.columnconfigure(1, weight=1)
        
    def create_review_tab(self):
        """创建复习标签页"""
        self.review_frame = ttk.Frame(self.notebook, padding="20")
        self.notebook.add(self.review_frame, text="📖 单词复习")
        
        # 复习控制面板
        control_frame = ttk.Frame(self.review_frame)
        control_frame.pack(fill=tk.X, pady=(0, 20))
        
        ttk.Label(control_frame, text="复习数量:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=(0, 5))
        self.review_count_var = tk.StringVar(value="5")
        review_spin = ttk.Spinbox(
            control_frame,
            from_=1,
            to=20,
            textvariable=self.review_count_var,
            width=5
        )
        review_spin.pack(side=tk.LEFT, padx=(0, 20))
        
        ttk.Button(
            control_frame,
            text="开始复习",
            command=self.start_review,
            style='Accent.TButton'
        ).pack(side=tk.LEFT)
        
        # 复习内容显示区域
        self.review_content = ttk.Frame(self.review_frame)
        self.review_content.pack(fill=tk.BOTH, expand=True)
        
        # 初始显示提示
        ttk.Label(
            self.review_content,
            text="点击'开始复习'按钮开始单词复习",
            font=('Microsoft YaHei', 12),
            foreground='gray'
        ).pack(expand=True)
        
    def create_test_tab(self):
        """创建测试标签页"""
        test_frame = ttk.Frame(self.notebook, padding="20")
        self.notebook.add(test_frame, text="📝 单词测试")
        
        # 测试控制
        ttk.Label(test_frame, text="测试模式", font=('Microsoft YaHei', 16)).pack(anchor=tk.W, pady=(0, 20))
        
        mode_frame = ttk.Frame(test_frame)
        mode_frame.pack(fill=tk.X, pady=(0, 20))
        
        self.test_mode_var = tk.StringVar(value="choice")
        
        ttk.Radiobutton(
            mode_frame,
            text="选择题测试",
            variable=self.test_mode_var,
            value="choice"
        ).pack(side=tk.LEFT, padx=(0, 20))
        
        ttk.Radiobutton(
            mode_frame,
            text="拼写测试",
            variable=self.test_mode_var,
            value="spell"
        ).pack(side=tk.LEFT)
        
        # 题目数量
        count_frame = ttk.Frame(test_frame)
        count_frame.pack(fill=tk.X, pady=(0, 20))
        
        ttk.Label(count_frame, text="题目数量:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=(0, 5))
        self.test_count_var = tk.StringVar(value="10")
        test_spin = ttk.Spinbox(
            count_frame,
            from_=1,
            to=50,
            textvariable=self.test_count_var,
            width=5
        )
        test_spin.pack(side=tk.LEFT, padx=(0, 20))
        
        ttk.Button(
            test_frame,
            text="开始测试",
            command=self.start_test,
            style='Accent.TButton',
            width=15
        ).pack()
        
    def create_words_tab(self):
        """创建单词列表标签页"""
        words_frame = ttk.Frame(self.notebook, padding="10")
        self.notebook.add(words_frame, text="📋 单词列表")
        
        # 搜索和筛选
        filter_frame = ttk.Frame(words_frame)
        filter_frame.pack(fill=tk.X, pady=(0, 10))
        
        ttk.Label(filter_frame, text="搜索:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=(0, 5))
        self.search_var = tk.StringVar()
        self.search_var.trace('w', lambda *args: self.filter_words())
        ttk.Entry(filter_frame, textvariable=self.search_var, width=20).pack(side=tk.LEFT, padx=(0, 20))
        
        ttk.Label(filter_frame, text="分类:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=(0, 5))
        self.category_var = tk.StringVar(value="全部")
        category_combo = ttk.Combobox(
            filter_frame,
            textvariable=self.category_var,
            values=["全部"] + self.get_categories(),
            state="readonly",
            width=15
        )
        category_combo.pack(side=tk.LEFT, padx=(0, 20))
        category_combo.bind('<<ComboboxSelected>>', lambda e: self.filter_words())
        
        # 单词表格
        columns = ("ID", "英文", "中文", "分类", "掌握度", "最后复习")
        self.words_tree = ttk.Treeview(
            words_frame,
            columns=columns,
            show="headings",
            height=20
        )
        
        # 设置列
        for col in columns:
            self.words_tree.heading(col, text=col)
            self.words_tree.column(col, width=100, anchor=tk.CENTER)
        
        # 调整列宽
        self.words_tree.column("中文", width=150)
        self.words_tree.column("掌握度", width=80)
        self.words_tree.column("最后复习", width=120)
        
        # 滚动条
        scrollbar = ttk.Scrollbar(words_frame, orient=tk.VERTICAL, command=self.words_tree.yview)
        self.words_tree.configure(yscrollcommand=scrollbar.set)
        
        self.words_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # 加载单词
        self.load_words_to_tree()
        
    def create_stats_tab(self):
        """创建统计标签页"""
        stats_frame = ttk.Frame(self.notebook, padding="20")
        self.notebook.add(stats_frame, text="📈 学习统计")
        
        # 基本统计
        basic_frame = ttk.LabelFrame(stats_frame, text="基本统计", padding="20")
        basic_frame.pack(fill=tk.X, pady=(0, 20))
        
        # 使用网格布局
        stats_grid = ttk.Frame(basic_frame)
        stats_grid.pack()
        
        # 计算统计数据
        total_words = self.app.get_word_count()
        total_reviews, total_correct = self.app.get_review_stats()
        accuracy = (total_correct / total_reviews * 100) if total_reviews > 0 else 0
        
        stats = [
            ("单词总数", f"{total_words} 个"),
            ("总复习次数", f"{total_reviews} 次"),
            ("总正确次数", f"{total_correct} 次"),
            ("总正确率", f"{accuracy:.1f}%"),
            ("今日复习", "0 个"),
            ("学习天数", "1 天")
        ]
        
        for i, (label, value) in enumerate(stats):
            row, col = divmod(i, 3)
            frame = ttk.Frame(stats_grid)
            frame.grid(row=row, column=col, padx=20, pady=10, sticky=tk.W)
            
            ttk.Label(frame, text=label, font=('Microsoft YaHei', 10), foreground='gray').pack(anchor=tk.W)
            ttk.Label(frame, text=value, font=('Microsoft YaHei', 16, 'bold')).pack(anchor=tk.W)
        
        # 掌握程度分布
        mastery_frame = ttk.LabelFrame(stats_frame, text="掌握程度分布", padding="20")
        mastery_frame.pack(fill=tk.BOTH, expand=True)
        
        # 这里可以添加图表，但为简化先显示文字
        self.mastery_text = scrolledtext.ScrolledText(mastery_frame, height=10)
        self.mastery_text.pack(fill=tk.BOTH, expand=True)
        self.update_mastery_stats()
        
    def create_status_bar(self, parent):
        """创建状态栏"""
        status_bar = ttk.Frame(parent)
        status_bar.grid(row=2, column=0, sticky=(tk.W, tk.E), pady=(10, 0))
        
        self.status_label = ttk.Label(
            status_bar,
            text="就绪",
            relief=tk.SUNKEN,
            anchor=tk.W
        )
        self.status_label.pack(fill=tk.X)
        
    def load_sample_data_if_empty(self):
        """如果数据为空，加载示例数据"""
        if not self.app.words:
            sample_words = [
                ("hello", "你好", "general"),
                ("world", "世界", "general"),
                ("python", "Python语言", "technology"),
                ("program", "程序", "technology"),
                ("learn", "学习", "study"),
                ("book", "书", "study"),
                ("apple", "苹果", "food"),
                ("happy", "快乐的", "emotion")
            ]
            for eng, chi, cat in sample_words:
                self.app.add_word(eng, chi, cat)
            self.status_label.config(text="已加载示例单词数据")
    
    def get_categories(self):
        """获取所有分类"""
        categories = set()
        for word in self.app.words.values():
            categories.add(word.get('category', 'general'))
        return sorted(list(categories))
    
    def load_words_to_tree(self):
        """加载单词到表格"""
        # 清空现有数据
        for item in self.words_tree.get_children():
            self.words_tree.delete(item)
        
        # 添加数据
        for word_id, word in self.app.words.items():
            mastery = word.get('mastery', 0)
            mastery_str = f"{mastery}%"
            if mastery < 30:
                mastery_str += " ⚠️"
            elif mastery > 80:
                mastery_str += " ✅"
            
            last_review = word.get('last_review', '从未复习')
            self.words_tree.insert(
                "",
                tk.END,
                values=(
                    word_id,
                    word['english'],
                    word['chinese'],
                    word.get('category', 'general'),
                    mastery_str,
                    last_review
                )
            )
    
    def filter_words(self):
        """筛选单词"""
        search_term = self.search_var.get().lower()
        category = self.category_var.get()
        
        for item in self.words_tree.get_children():
            self.words_tree.delete(item)
        
        for word_id, word in self.app.words.items():
            if category != "全部" and word.get('category', 'general') != category:
                continue
            
            if (search_term in word['english'].lower() or 
                search_term in word['chinese'] or
                search_term in word.get('category', '').lower()):
                
                mastery = word.get('mastery', 0)
                mastery_str = f"{mastery}%"
                if mastery < 30:
                    mastery_str += " ⚠️"
                elif mastery > 80:
                    mastery_str += " ✅"
                
                last_review = word.get('last_review', '从未复习')
                self.words_tree.insert(
                    "",
                    tk.END,
                    values=(
                        word_id,
                        word['english'],
                        word['chinese'],
                        word.get('category', 'general'),
                        mastery_str,
                        last_review
                    )
                )
    
    def add_new_word(self):
        """添加新单词"""
        english = self.eng_entry.get().strip()
        chinese = self.chi_entry.get().strip()
        category = self.cat_combo.get().strip()
        
        if not english or not chinese:
            messagebox.showwarning("输入错误", "请填写英文单词和中文释义")
            return
        
        word_id = self.app.add_word(english, chinese, category)
        
        # 清空输入框
        self.eng_entry.delete(0, tk.END)
        self.chi_entry.delete(0, tk.END)
        
        # 更新UI
        self.load_words_to_tree()
        self.status_label.config(text=f"已添加单词: {english} - {chinese}")
        messagebox.showinfo("成功", f"单词 '{english}' 添加成功！")
    
    def add_batch_words(self):
        """批量添加单词"""
        text = self.batch_text.get("1.0", tk.END).strip()
        if not text:
            return
        
        lines = text.split('\n')
        added = 0
        errors = []
        
        for i, line in enumerate(lines, 1):
            line = line.strip()
            if not line:
                continue
            
            parts = [p.strip() for p in line.split(',')]
            if len(parts) >= 2:
                english = parts[0]
                chinese = parts[1]
                category = parts[2] if len(parts) > 2 else "general"
                
                if english and chinese:
                    self.app.add_word(english, chinese, category)
                    added += 1
                else:
                    errors.append(f"第{i}行: 格式错误")
            else:
                errors.append(f"第{i}行: 格式错误")
        
        # 清空文本框
        self.batch_text.delete("1.0", tk.END)
        
        # 更新UI
        self.load_words_to_tree()
        
        msg = f"成功添加 {added} 个单词"
        if errors:
            msg += f"\n\n错误:\n" + "\n".join(errors[:5])  # 只显示前5个错误
            if len(errors) > 5:
                msg += f"\n... 还有{len(errors)-5}个错误"
        
        messagebox.showinfo("批量添加结果", msg)
        self.status_label.config(text=f"批量添加完成，共添加{added}个单词")
    
    def start_review(self):
        """开始复习"""
        try:
            num_words = int(self.review_count_var.get())
        except ValueError:
            num_words = 5
        
        if num_words < 1 or num_words > 50:
            messagebox.showwarning("输入错误", "请输入1-50之间的数字")
            return
        
        self.current_review_words = self.app.get_words_for_review(num_words)
        if not self.current_review_words:
            messagebox.showinfo("提示", "没有单词可复习")
            return
        
        self.current_review_index = 0
        self.review_correct = 0
        
        # 清空复习区域
        for widget in self.review_content.winfo_children():
            widget.destroy()
        
        # 显示第一个单词
        self.show_next_review_word()
    
    def show_next_review_word(self):
        """显示下一个复习单词"""
        if self.current_review_index >= len(self.current_review_words):
            self.show_review_result()
            return
        
        # 清空区域
        for widget in self.review_content.winfo_children():
            widget.destroy()
        
        word_id = self.current_review_words[self.current_review_index]
        word = self.app.words[word_id]
        
        # 进度显示
        progress_frame = ttk.Frame(self.review_content)
        progress_frame.pack(fill=tk.X, pady=(0, 20))
        
        ttk.Label(
            progress_frame,
            text=f"进度: {self.current_review_index + 1}/{len(self.current_review_words)}",
            font=('Microsoft YaHei', 10)
        ).pack(side=tk.LEFT)
        
        # 单词信息
        word_frame = ttk.LabelFrame(self.review_content, text="单词复习", padding="30")
        word_frame.pack(fill=tk.BOTH, expand=True)
        
        # 中文提示
        ttk.Label(
            word_frame,
            text="中文:",
            font=('Microsoft YaHei', 12)
        ).pack(anchor=tk.W, pady=(0, 5))
        
        ttk.Label(
            word_frame,
            text=word['chinese'],
            font=('Microsoft YaHei', 24, 'bold'),
            foreground=self.colors['primary']
        ).pack(pady=(0, 30))
        
        # 英文输入
        ttk.Label(
            word_frame,
            text="请输入对应的英文单词:",
            font=('Microsoft YaHei', 12)
        ).pack(anchor=tk.W, pady=(0, 5))
        
        self.review_entry = ttk.Entry(
            word_frame,
            font=('Microsoft YaHei', 14),
            width=30
        )
        self.review_entry.pack(pady=(0, 20))
        self.review_entry.focus()
        
        # 提交按钮
        ttk.Button(
            word_frame,
            text="提交答案",
            command=self.check_review_answer,
            style='Accent.TButton',
            width=15
        ).pack()
        
        # 绑定回车键
        self.review_entry.bind('<Return>', lambda e: self.check_review_answer())
    
    def check_review_answer(self):
        """检查复习答案"""
        user_answer = self.review_entry.get().strip().lower()
        word_id = self.current_review_words[self.current_review_index]
        word = self.app.words[word_id]
        correct_answer = word['english'].lower()
        
        is_correct = (user_answer == correct_answer)
        self.app.update_review_result(word_id, is_correct)
        
        if is_correct:
            self.review_correct += 1
            result_text = f"✓ 正确！答案是: {word['english']}"
            result_color = self.colors['success']
        else:
            result_text = f"✗ 错误，正确答案是: {word['english']}"
            result_color = self.colors['danger']
        
        # 显示结果
        for widget in self.review_content.winfo_children():
            widget.destroy()
        
        result_frame = ttk.Frame(self.review_content)
        result_frame.pack(fill=tk.BOTH, expand=True)
        
        ttk.Label(
            result_frame,
            text=result_text,
            font=('Microsoft YaHei', 16),
            foreground=result_color
        ).pack(pady=(50, 20))
        
        ttk.Label(
            result_frame,
            text=f"中文: {word['chinese']}",
            font=('Microsoft YaHei', 14)
        ).pack(pady=(0, 20))
        
        ttk.Label(
            result_frame,
            text=f"分类: {word.get('category', 'general')}",
            font=('Microsoft YaHei', 12)
        ).pack(pady=(0, 30))
        
        # 下一个按钮
        ttk.Button(
            result_frame,
            text="下一个单词" if (self.current_review_index + 1) < len(self.current_review_words) else "查看结果",
            command=self.next_review_word,
            style='Accent.TButton',
            width=15
        ).pack()
    
    def next_review_word(self):
        """进入下一个单词"""
        self.current_review_index += 1
        self.show_next_review_word()
    
    def show_review_result(self):
        """显示复习结果"""
        for widget in self.review_content.winfo_children():
            widget.destroy()
        
        accuracy = (self.review_correct / len(self.current_review_words)) * 100
        
        result_frame = ttk.Frame(self.review_content)
        result_frame.pack(fill=tk.BOTH, expand=True)
        
        ttk.Label(
            result_frame,
            text="复习完成！",
            font=('Microsoft YaHei', 20, 'bold'),
            foreground=self.colors['primary']
        ).pack(pady=(30, 20))
        
        ttk.Label(
            result_frame,
            text=f"正确: {self.review_correct}/{len(self.current_review_words)}",
            font=('Microsoft YaHei', 16)
        ).pack(pady=(0, 10))
        
        ttk.Label(
            result_frame,
            text=f"正确率: {accuracy:.1f}%",
            font=('Microsoft YaHei', 16, 'bold'),
            foreground=self.colors['success'] if accuracy >= 60 else self.colors['warning']
        ).pack(pady=(0, 30))
        
        # 按钮
        btn_frame = ttk.Frame(result_frame)
        btn_frame.pack()
        
        ttk.Button(
            btn_frame,
            text="重新复习",
            command=self.start_review
        ).pack(side=tk.LEFT, padx=5)
        
        ttk.Button(
            btn_frame,
            text="返回首页",
            command=lambda: self.notebook.select(0)
        ).pack(side=tk.LEFT, padx=5)
    
    def start_test(self):
        """开始测试"""
        messagebox.showinfo("提示", "测试功能开发中...\n请先使用复习功能")
    
    def update_mastery_stats(self):
        """更新掌握程度统计"""
        if not self.app.words:
            return
        
        levels = {
            "新手(0-30%)": 0,
            "初级(31-60%)": 0,
            "中级(61-80%)": 0,
            "高级(81-100%)": 0
        }
        
        for word in self.app.words.values():
            mastery = word.get('mastery', 0)
            if mastery <= 30:
                levels["新手(0-30%)"] += 1
            elif mastery <= 60:
                levels["初级(31-60%)"] += 1
            elif mastery <= 80:
                levels["中级(61-80%)"] += 1
            else:
                levels["高级(81-100%)"] += 1
        
        text = ""
        for level, count in levels.items():
            if count > 0:
                percentage = (count / len(self.app.words)) * 100
                bar = "▇" * int(percentage / 5)  # 每个▇代表5%
                text += f"{level}: {count}个 ({percentage:.1f}%)\n{bar}\n\n"
        
        self.mastery_text.delete("1.0", tk.END)
        self.mastery_text.insert("1.0", text)

def main():
    """主函数"""
    root = tk.Tk()
    
    # 设置窗口居中
    window_width = 900
    window_height = 700
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    x = (screen_width - window_width) // 2
    y = (screen_height - window_height) // 2
    root.geometry(f"{window_width}x{window_height}+{x}+{y}")
    
    app = WordMemoryGUI(root)
    root.mainloop()

if __name__ == "__main__":
    main()