import os
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
from PIL import Image, ImageDraw, ImageFont, ImageTk, ImageFilter, ImageOps
import random
import threading
import math

class ModernStudentCardGenerator:
    """现代风格学生证件生成器"""
    
    def __init__(self):
        self.card_width = 540
        self.card_height = 340
        
        # 渐变颜色方案
        self.color_schemes = [
            {
                'name': '经典蓝',
                'primary': (25, 118, 211),      # 主色
                'secondary': (66, 133, 244),     # 辅色
                'accent': (232, 245, 253),       # 强调色
                'dark': (13, 71, 161),           # 深色
                'light': (187, 222, 251),        # 浅色
                'gradient_start': (25, 69, 131),
                'gradient_end': (56, 142, 237),
            },
            {
                'name': '翡翠绿',
                'primary': (0, 137, 123),
                'secondary': (84, 182, 167),
                'accent': (230, 246, 242),
                'dark': (0, 96, 87),
                'light': (176, 231, 219),
                'gradient_start': (0, 105, 93),
                'gradient_end': (63, 181, 156),
            },
            {
                'name': '典雅红',
                'primary': (183, 54, 68),
                'secondary': (216, 74, 89),
                'accent': (249, 236, 238),
                'dark': (139, 51, 59),
                'light': (234, 191, 195),
                'gradient_start': (147, 46, 57),
                'gradient_end': (203, 81, 94),
            },
            {
                'name': '科技紫',
                'primary': (106, 76, 184),
                'secondary': (138, 107, 209),
                'accent': (239, 233, 252),
                'dark': (78, 53, 146),
                'light': (198, 179, 235),
                'gradient_start': (91, 63, 162),
                'gradient_end': (126, 97, 197),
            },
        ]
        
        self.current_scheme = self.color_schemes[0]
        self.fonts = self._load_fonts()
    
    def _load_fonts(self):
        """加载字体"""
        fonts = {}
        font_paths = [
            "C:/Windows/Fonts/msyhbd.ttc",      # 微软雅黑粗体
            "C:/Windows/Fonts/msyh.ttc",         # 微软雅黑
            "C:/Windows/Fonts/simhei.ttf",       # 黑体
            "C:/Windows/Fonts/simsun.ttc",       # 宋体
            "/System/Library/Fonts/PingFang.ttc",
            "/System/Library/Fonts/STHeiti Medium.ttc",
            "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc"
        ]
        
        for path in font_paths:
            if os.path.exists(path):
                try:
                    fonts['title'] = ImageFont.truetype(path, 32)
                    fonts['subtitle'] = ImageFont.truetype(path, 20)
                    fonts['name_large'] = ImageFont.truetype(path, 30)
                    fonts['info'] = ImageFont.truetype(path, 16)
                    fonts['small'] = ImageFont.truetype(path, 13)
                    fonts['tiny'] = ImageFont.truetype(path, 11)
                    break
                except:
                    continue
        
        if not fonts:
            default = ImageFont.load_default()
            fonts = {key: default for key in ['title', 'subtitle', 'name_large', 
                                              'info', 'small', 'tiny']}
        
        return fonts
    
    def set_color_scheme(self, index):
        """设置配色方案"""
        if 0 <= index < len(self.color_schemes):
            self.current_scheme = self.color_schemes[index]
    
    def generate_gradient_background(self, width, height):
        """生成渐变背景"""
        base = Image.new('RGBA', (width, height), (255, 255, 255, 0))
        draw = ImageDraw.Draw(base)
        
        start_r, start_g, start_b = self.current_scheme['gradient_start']
        end_r, end_g, end_b = self.current_scheme['gradient_end']
        
        for y in range(height):
            ratio = y / height
            r = int(start_r + (end_r - start_r) * ratio)
            g = int(start_g + (end_g - start_g) * ratio)
            b = int(start_b + (end_b - start_b) * ratio)
            draw.line([(0, y), (width, y)], fill=(r, g, b, 255))
        
        return base
    
    def generate_avatar(self, size=(115, 152)):
        """生成更真实的头像"""
        # 创建圆角矩形头像
        img = Image.new('RGBA', size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(img)
        
        # 背景颜色（基于肤色）
        skin_colors = [
            (255, 213, 170),  # 白皙
            (247, 194, 153),  # 自然
            (229, 173, 134),  # 小麦
            (206, 149, 112),  # 古铜
        ]
        skin_color = random.choice(skin_colors)
        
        # 头发颜色
        hair_colors = [
            (20, 18, 25),     # 黑色
            (101, 67, 77),    # 棕色
            (207, 157, 114),  # 金色
            (168, 132, 102),  # 浅棕
        ]
        hair_color = random.choice(hair_colors)
        
        # 绘制圆角矩形头像背景
        radius = 15
        draw.rounded_rectangle([(0, 0), (size[0]-1, size[1]-1)], 
                              radius=radius, fill=skin_color)
        
        cx, cy = size[0] // 2, size[1] // 2 - 10
        
        # 头发（上半部分）
        hair_top = cy - 35
        hair_bottom = cy - 5
        draw.ellipse([cx - 35, hair_top, cx + 35, hair_bottom], 
                    fill=hair_color)
        
        # 两侧头发
        draw.ellipse([cx - 38, hair_top + 5, cx - 10, hair_top + 30], 
                    fill=hair_color)
        draw.ellipse([cx + 10, hair_top + 5, cx + 38, hair_top + 30], 
                    fill=hair_color)
        
        # 眉毛
        eyebrow_color = (80, 60, 50)
        draw.arc([cx - 22, cy - 12, cx - 2, cy + 2], 
                200, 360, fill=eyebrow_color, width=3)
        draw.arc([cx + 2, cy - 12, cx + 22, cy + 2], 
                180, 340, fill=eyebrow_color, width=3)
        
        # 眼睛
        eye_white = (255, 255, 255)
        eye_pupil = (40, 45, 60)
        
        # 左眼
        draw.ellipse([cx - 18, cy - 5, cx - 4, cy + 8], fill=eye_white)
        draw.ellipse([cx - 15, cy - 2, cx - 7, cy + 5], fill=eye_pupil)
        draw.ellipse([cx - 13, cy - 1, cx - 9, cy + 2], fill=(255, 255, 255))
        
        # 右眼
        draw.ellipse([cx + 4, cy - 5, cx + 18, cy + 8], fill=eye_white)
        draw.ellipse([cx + 7, cy - 2, cx + 15, cy + 5], fill=eye_pupil)
        draw.ellipse([cx + 9, cy - 1, cx + 13, cy + 2], fill=(255, 255, 255))
        
        # 鼻子
        nose_color = tuple(min(c - 20, 255) for c in skin_color)
        draw.polygon([(cx, cy + 6), (cx - 3, cy + 14), (cx + 3, cy + 14)], 
                    fill=nose_color)
        
        # 嘴巴
        mouth_color = (200, 100, 100)
        draw.arc([cx - 12, cy + 14, cx + 12, cy + 24], 
                0, 180, fill=mouth_color, width=2)
        
        # 添加校服领子
        collar_color = self.current_scheme['primary']
        draw.polygon([(cx - 30, cy + 38), (cx, cy + 28), (cx + 30, cy + 38)], 
                    fill=collar_color)
        
        # 添加微妙的阴影效果
        shadow = Image.new('RGBA', size, (0, 0, 0, 0))
        shadow_draw = ImageDraw.Draw(shadow)
        shadow_draw.rounded_rectangle([(0, 0), (size[0]-1, size[1]-1)], 
                                     radius=radius, fill=(0, 0, 0, 30))
        shadow = shadow.filter(ImageFilter.GaussianBlur(radius=3))
        img = Image.alpha_composite(img, shadow)
        
        return img
    
    def create_decorative_pattern(self, width, height):
        """创建装饰性底纹"""
        pattern = Image.new('RGBA', (width, height), (0, 0, 0, 0))
        draw = ImageDraw.Draw(pattern)
        
        accent_color = self.current_scheme['accent']
        
        # 右上角装饰圆点
        for i in range(5):
            x = width - 30 - i * 35
            y = 15 + i * 20
            alpha = max(0, 128 - i * 25)
            draw.ellipse([x-8, y-8, x+8, y+8], 
                        fill=(*accent_color[:3], alpha))
        
        # 左下角装饰线条
        for i in range(3):
            y = height - 20 - i * 15
            x_start = 20 + i * 20
            x_end = 80 + i * 30
            alpha = max(0, 100 - i * 30)
            draw.line([(x_start, y), (x_end, y)], 
                     fill=(*accent_color[:3], alpha), width=2)
        
        return pattern
    
    def generate_student_id(self):
        """生成学号"""
        year = random.randint(2020, 2024)
        dept = f"{random.randint(1, 30):02d}"
        grade = f"{random.randint(1, 9)}"
        number = f"{random.randint(1, 299):03d}"
        return f"{year}{dept}{grade}{number}"
    
    def generate_name(self):
        """生成姓名"""
        surnames = ['张', '李', '王', '刘', '陈', '杨', '黄', '赵', '周', '吴',
                   '徐', '孙', '马', '朱', '胡', '郭', '何', '高', '林', '罗']
        given_names = ['伟', '芳', '娜', '秀英', '敏', '静', '丽', '强', '磊', '军',
                      '洋', '勇', '艳', '杰', '娟', '涛', '明', '超', '秀兰', '霞',
                      '志强', '晓明', '雪梅', '海燕', '建华', '国庆', '文博', '思远']
        return random.choice(surnames) + random.choice(given_names)
    
    def create_student_card(self, student_info=None):
        """创建精美的学生证"""
        w, h = self.card_width, self.card_height
        
        # 1. 创建基础卡片
        card = Image.new('RGBA', (w, h), (255, 255, 255, 255))
        
        # 2. 绘制渐变背景（左侧）
        gradient_left = self.generate_gradient_background(w // 3, h)
        card.paste(gradient_left, (0, 0), gradient_left)
        
        # 3. 白色主体区域
        white_area = Image.new('RGBA', (w - w//3 + 20, h), (255, 255, 255, 255))
        card.paste(white_area, (w//3 - 20, 0), white_area)
        
        # 4. 添加装饰性底纹
        decoration = self.create_decorative_pattern(w, h)
        card = Image.alpha_composite(card, decoration)
        
        # 5. 创建绘图对象
        draw = ImageDraw.Draw(card)
        
        # 6. 处理学生信息
        if student_info is None:
            student_info = {
                'school': '清华大学',
                'name': self.generate_name(),
                'student_id': self.generate_student_id(),
                'department': random.choice(['计算机科学与技术学院', '电子信息工程学院', 
                                            '经济管理学院', '建筑学院', '医学院']),
                'major': random.choice(['计算机科学与技术', '软件工程', '人工智能', 
                                       '数据科学与大数据技术', '信息安全']),
                'class': f"计{random.randint(21, 24)}{random.choice(['甲', '乙', '丙', '丁'])}班",
                'valid_until': f"20{random.randint(26, 29)}年{random.randint(6, 9)}月",
                'gender': random.choice(['男', '女']),
                'birthday': f"{random.randint(1999, 2005)}年{random.randint(1, 12):02d}月{random.randint(1, 28):02d}日"
            }
        
        # 7. 绘制学校名称（左侧渐变区）
        school_text = student_info['school']
        # 竖排文字
        chars = list(school_text)
        char_size = 28
        start_y = (h - len(chars) * (char_size + 5)) // 2
        for i, char in enumerate(chars):
            y = start_y + i * (char_size + 5)
            draw.text((35, y), char, fill=(255, 255, 255, 220), 
                     font=self.fonts['title'])
        
        # 8. 绘制"学生证"标识
        card_type = "学生证"
        bbox = draw.textbbox((0, 0), card_type, font=self.fonts['subtitle'])
        tw = bbox[2] - bbox[0]
        draw.text((w//6 - tw//2 + 10, 25), card_type, 
                 fill=(255, 215, 0), font=self.fonts['subtitle'])
        
        # 9. 绘制分隔线
        line_x = w // 3 - 5
        draw.line([(line_x, 50), (line_x, h-50)], 
                 fill=self.current_scheme['primary'], width=2)
        
        # 10. 绘制头像区域
        avatar = self.generate_avatar()
        avatar_x = 25
        avatar_y = 60
        card.paste(avatar, (avatar_x, avatar_y), avatar)
        
        # 11. 头像边框
        draw.rounded_rectangle([avatar_x-3, avatar_y-3, 
                               avatar_x+avatar.size[0]+3, 
                               avatar_y+avatar.size[1]+3],
                              radius=18, 
                              outline=self.current_scheme['primary'], 
                              width=2)
        
        # 12. 绘制学生信息（右侧白色区域）
        info_x = w // 3 + 20
        info_y = 35
        line_height = 32
        
        # 姓名（大号显示）
        name_text = f"姓  名：{student_info['name']}"
        draw.text((info_x, info_y), name_text, 
                 fill=self.current_scheme['dark'], font=self.fonts['name_large'])
        
        # 其他信息
        other_info = [
            ('性  别', student_info['gender']),
            ('出生年月', student_info['birthday']),
            ('学  号', student_info['student_id']),
            ('院  系', student_info['department']),
            ('专  业', student_info['major']),
            ('班  级', student_info['class']),
        ]
        
        current_y = info_y + 45
        for label, value in other_info:
            # 标签
            draw.text((info_x, current_y), label, 
                     fill=(127, 144, 169), font=self.fonts['info'])
            label_w = draw.textlength(label, font=self.fonts['info'])
            
            # 值
            draw.text((info_x + label_w + 10, current_y), value, 
                     fill=(33, 37, 41), font=self.fonts['info'])
            
            current_y += line_height
        
        # 13. 底部信息
        bottom_y = h - 35
        
        # 有效期
        draw.text((info_x, bottom_y), f"有效期至：{student_info['valid_until']}", 
                 fill=(127, 144, 169), font=self.fonts['small'])
        
        # 证件编号
        card_no = f"NO.{student_info['student_id']}"
        bbox = draw.textbbox((0, 0), card_no, font=self.fonts['small'])
        tw = bbox[2] - bbox[0]
        draw.text((w - 30 - tw, bottom_y), card_no, 
                 fill=(177, 186, 201), font=self.fonts['small'])
        
        # 14. 底部装饰线
        draw.line([(info_x, bottom_y - 8), (w - 30, bottom_y - 8)], 
                 fill=self.current_scheme['light'], width=1)
        
        # 15. 防伪水印
        watermark = "VALID"
        bbox = draw.textbbox((0, 0), watermark, font=self.fonts['tiny'])
        tw = bbox[2] - bbox[0]
        th = bbox[3] - bbox[1]
        for i in range(3):
            wx = info_x + 100 + i * 60
            wy = h - 60
            draw.text((wx, wy), watermark, 
                     fill=(200, 208, 221, 100), font=self.fonts['tiny'])
        
        # 16. 添加微妙的阴影效果
        shadow = Image.new('RGBA', (w+10, h+10), (0, 0, 0, 0))
        shadow_draw = ImageDraw.Draw(shadow)
        shadow_draw.rounded_rectangle([(5, 5), (w+5, h+5)], 
                                     radius=20, fill=(0, 0, 0, 40))
        shadow = shadow.filter(ImageFilter.GaussianBlur(radius=5))
        
        final_card = Image.new('RGBA', (w+10, h+10), (255, 255, 255, 0))
        final_card.paste(shadow, (0, 0), shadow)
        final_card.paste(card, (5, 5), card)
        
        # 裁剪回原始尺寸
        final_card = final_card.crop((5, 5, w+5, h+5))
        
        return final_card.convert('RGB'), student_info


class StudentCardGUI:
    """图形界面"""
    
    def __init__(self, root):
        self.root = root
        self.root.title("学生证件生成系统 v3.0")
        self.root.geometry("1000x750")
        self.root.configure(bg='#f8f9fa')
        
        self.generator = ModernStudentCardGenerator()
        self.current_card = None
        self.current_info = None
        self.card_tk = None
        
        self.setup_ui()
        self.generate_new_card()
    
    def setup_ui(self):
        """设置界面"""
        # 标题栏
        title_frame = tk.Frame(self.root, bg='#1a237e', height=60)
        title_frame.pack(fill=tk.X)
        title_frame.pack_propagate(False)
        
        tk.Label(title_frame, text="🎓 学生证件智能生成系统", 
                font=('Microsoft YaHei', 18, 'bold'),
                bg='#1a237e', fg='white').pack(pady=12)
        
        # 主内容区域
        main_frame = tk.Frame(self.root, bg='#f8f9fa')
        main_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=15)
        
        # 左侧预览
        left_frame = tk.LabelFrame(main_frame, text="证件预览", 
                                   font=('Microsoft YaHei', 11, 'bold'),
                                   bg='#f8f9fa', padx=10, pady=10)
        left_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        self.preview_canvas = tk.Canvas(left_frame, width=560, height=380,
                                        bg='white', highlightthickness=2,
                                        highlightbackground='#e0e0e0')
        self.preview_canvas.pack()
        
        # 预览控制
        control_frame = tk.Frame(left_frame, bg='#f8f9fa')
        control_frame.pack(pady=10)
        
        btn_style = {'font': ('Microsoft YaHei', 10), 'padx': 15, 'pady': 5}
        
        tk.Button(control_frame, text="🔄 随机生成", 
                 command=self.generate_new_card,
                 bg='#1976d2', fg='white', **btn_style).pack(side=tk.LEFT, padx=5)
        
        tk.Button(control_frame, text="💾 保存图片", 
                 command=self.save_card,
                 bg='#388e3c', fg='white', **btn_style).pack(side=tk.LEFT, padx=5)
        
        tk.Button(control_frame, text="🖨️ 打印", 
                 command=self.print_card,
                 bg='#f57c00', fg='white', **btn_style).pack(side=tk.LEFT, padx=5)
        
        # 右侧信息编辑
        right_frame = tk.LabelFrame(main_frame, text="学生信息编辑", 
                                    font=('Microsoft YaHei', 11, 'bold'),
                                    bg='#f8f9fa', padx=15, pady=15)
        right_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=(15, 0))
        
        # 配色选择
        color_frame = tk.Frame(right_frame, bg='#f8f9fa')
        color_frame.pack(fill=tk.X, pady=(0, 15))
        
        tk.Label(color_frame, text="配色方案:", 
                font=('Microsoft YaHei', 10), bg='#f8f9fa').pack(side=tk.LEFT)
        
        self.color_var = tk.StringVar(value="经典蓝")
        color_menu = ttk.Combobox(color_frame, textvariable=self.color_var,
                                  values=['经典蓝', '翡翠绿', '典雅红', '科技紫'],
                                  state='readonly', width=10)
        color_menu.pack(side=tk.LEFT, padx=10)
        color_menu.bind('<<ComboboxSelected>>', self.change_color_scheme)
        
        # 信息字段
        self.info_vars = {}
        fields = [
            ('学校名称', 'school', 25),
            ('学生姓名', 'name', 25),
            ('性    别', 'gender', 25),
            ('出生年月', 'birthday', 25),
            ('学    号', 'student_id', 25),
            ('院    系', 'department', 30),
            ('专    业', 'major', 30),
            ('班    级', 'class', 25),
            ('有效期至', 'valid_until', 25),
        ]
        
        for label, key, width in fields:
            frame = tk.Frame(right_frame, bg='#f8f9fa')
            frame.pack(fill=tk.X, pady=3)
            
            tk.Label(frame, text=label, width=8, anchor=tk.E, 
                    font=('Microsoft YaHei', 10), bg='#f8f9fa').pack(side=tk.LEFT)
            
            var = tk.StringVar()
            self.info_vars[key] = var
            tk.Entry(frame, textvariable=var, width=width, 
                    font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=5)
        
        # 操作按钮
        btn_frame = tk.Frame(right_frame, bg='#f8f9fa')
        btn_frame.pack(fill=tk.X, pady=15)
        
        tk.Button(btn_frame, text="✅ 应用修改", 
                 command=self.apply_changes,
                 bg='#1976d2', fg='white', 
                 font=('Microsoft YaHei', 10), padx=20, pady=5).pack(fill=tk.X, pady=3)
        
        tk.Button(btn_frame, text="🎲 随机填充", 
                 command=self.random_fill,
                 bg='#6c757d', fg='white',
                 font=('Microsoft YaHei', 10), padx=20, pady=5).pack(fill=tk.X, pady=3)
        
        # 批量生成
        batch_frame = tk.LabelFrame(right_frame, text="批量生成", 
                                    font=('Microsoft YaHei', 10, 'bold'),
                                    bg='#f8f9fa', padx=10, pady=10)
        batch_frame.pack(fill=tk.X, pady=10)
        
        tk.Label(batch_frame, text="数量:", 
                font=('Microsoft YaHei', 10), bg='#f8f9fa').pack(side=tk.LEFT)
        
        self.batch_var = tk.StringVar(value="5")
        tk.Spinbox(batch_frame, from_=1, to=100, width=5,
                  textvariable=self.batch_var,
                  font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=5)
        
        tk.Button(batch_frame, text="📦 批量生成", 
                 command=self.batch_generate,
                 bg='#7b1fa2', fg='white',
                 font=('Microsoft YaHei', 10), padx=10).pack(side=tk.LEFT, padx=5)
        
        # 状态栏
        self.status_bar = tk.Label(self.root, text="就绪", 
                                   bd=1, relief=tk.SUNKEN, anchor=tk.W,
                                   font=('Microsoft YaHei', 9),
                                   bg='#e9ecef', padx=10)
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
    
    def update_preview(self):
        """更新预览"""
        if self.current_card:
            # 缩放预览
            preview = self.current_card.copy()
            preview.thumbnail((540, 370), Image.Resampling.LANCZOS)
            
            # 转换为Tkinter图片
            self.card_tk = ImageTk.PhotoImage(preview)
            
            # 更新画布
            self.preview_canvas.delete("all")
            self.preview_canvas.create_image(280, 192, image=self.card_tk, anchor=tk.CENTER)
            
            # 更新状态
            if self.current_info:
                self.status_bar.config(
                    text=f"当前学生: {self.current_info['name']} | "
                         f"学号: {self.current_info['student_id']} | "
                         f"配色: {self.color_var.get()}"
                )
    
    def generate_new_card(self):
        """生成新卡片"""
        self.current_card, self.current_info = self.generator.create_student_card()
        self.update_preview()
        self.update_info_fields()
    
    def apply_changes(self):
        """应用修改"""
        try:
            info = {key: var.get() for key, var in self.info_vars.items()}
            self.current_card, self.current_info = self.generator.create_student_card(info)
            self.update_preview()
            self.status_bar.config(text="✅ 已应用修改")
        except Exception as e:
            messagebox.showerror("错误", f"生成失败: {str(e)}")
    
    def random_fill(self):
        """随机填充"""
        self.info_vars['name'].set(self.generator.generate_name())
        self.info_vars['student_id'].set(self.generator.generate_student_id())
        self.info_vars['gender'].set(random.choice(['男', '女']))
        self.info_vars['birthday'].set(
            f"{random.randint(1999, 2005)}年{random.randint(1, 12):02d}月{random.randint(1, 28):02d}日"
        )
        self.info_vars['department'].set(
            random.choice(['计算机科学与技术学院', '电子信息工程学院', 
                          '经济管理学院', '建筑学院', '医学院'])
        )
        self.info_vars['major'].set(
            random.choice(['计算机科学与技术', '软件工程', '人工智能', 
                          '数据科学与大数据技术', '信息安全'])
        )
        self.info_vars['class'].set(
            f"计{random.randint(21, 24)}{random.choice(['甲', '乙', '丙', '丁'])}班"
        )
        self.status_bar.config(text="🎲 已随机填充信息")
    
    def update_info_fields(self):
        """更新信息字段"""
        if self.current_info:
            for key, var in self.info_vars.items():
                if key in self.current_info:
                    var.set(str(self.current_info[key]))
    
    def change_color_scheme(self, event=None):
        """更换配色"""
        scheme_map = {'经典蓝': 0, '翡翠绿': 1, '典雅红': 2, '科技紫': 3}
        index = scheme_map.get(self.color_var.get(), 0)
        self.generator.set_color_scheme(index)
        self.apply_changes()
    
    def save_card(self):
        """保存图片"""
        if not self.current_card:
            messagebox.showwarning("提示", "请先生成学生证")
            return
        
        filename = f"学生证_{self.current_info['name']}.png"
        filepath = filedialog.asksaveasfilename(
            defaultextension=".png",
            filetypes=[("PNG图片", "*.png"), ("JPEG图片", "*.jpg")],
            initialfile=filename
        )
        
        if filepath:
            try:
                self.current_card.save(filepath, quality=95)
                messagebox.showinfo("成功", f"已保存到:\n{filepath}")
                self.status_bar.config(text=f"💾 已保存: {os.path.basename(filepath)}")
            except Exception as e:
                messagebox.showerror("错误", f"保存失败: {str(e)}")
    
    def print_card(self):
        """打印"""
        if not self.current_card:
            messagebox.showwarning("提示", "请先生成学生证")
            return
        
        try:
            temp = "temp_card.png"
            self.current_card.save(temp)
            os.startfile(temp, "print")
        except:
            messagebox.showinfo("提示", "请手动打开图片进行打印")
    
    def batch_generate(self):
        """批量生成"""
        try:
            count = int(self.batch_var.get())
            if count < 1 or count > 100:
                raise ValueError
            
            directory = filedialog.askdirectory(title="选择保存目录")
            if not directory:
                return
            
            self.status_bar.config(text=f"⏳ 正在生成 {count} 张学生证...")
            
            def generate():
                success = 0
                for i in range(count):
                    try:
                        card, info = self.generator.create_student_card()
                        filename = f"学生证_{i+1:03d}_{info['name']}.png"
                        filepath = os.path.join(directory, filename)
                        card.save(filepath, quality=95)
                        success += 1
                    except:
                        pass
                    
                    # 更新进度
                    progress = int((i + 1) / count * 100)
                    self.root.after(0, lambda p=progress: self.status_bar.config(
                        text=f"⏳ 生成进度: {p}% ({i+1}/{count})"
                    ))
                
                self.root.after(0, lambda: self.status_bar.config(
                    text=f"✅ 批量生成完成! 成功: {success}/{count}"
                ))
                self.root.after(0, lambda: messagebox.showinfo(
                    "完成", f"批量生成完成!\n成功: {success}/{count} 张\n保存位置: {directory}"
                ))
            
            threading.Thread(target=generate, daemon=True).start()
            
        except ValueError:
            messagebox.showerror("错误", "请输入有效的数量(1-100)")


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

if __name__ == "__main__":
    main()