import tkinter as tk
from tkinter import ttk, messagebox
import time
import threading
import winsound
import sys

class TimerApp:
    def __init__(self, root):
        self.root = root
        self.root.title("多功能定时器")
        self.root.geometry("500x600")
        self.root.configure(bg='#f0f0f0')
        
        # 定时器状态
        self.is_running = False
        self.is_paused = False
        self.start_time = 0
        self.paused_time = 0
        self.total_elapsed = 0
        self.alarms = []  # 存储闹钟时间
        self.alarm_enabled = True
        
        # 创建界面
        self.setup_ui()
        
    def setup_ui(self):
        """设置用户界面"""
        # 主框架
        main_frame = ttk.Frame(self.root, padding="20")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 标题
        title_label = tk.Label(main_frame, text="⏰ 多功能定时器", 
                              font=("微软雅黑", 24, "bold"),
                              fg='#2c3e50', bg='#f0f0f0')
        title_label.pack(pady=(0, 20))
        
        # 时间显示区域
        self.setup_time_display(main_frame)
        
        # 时间设置区域
        self.setup_time_setting(main_frame)
        
        # 控制按钮区域
        self.setup_controls(main_frame)
        
        # 闹钟设置区域
        self.setup_alarm_controls(main_frame)
        
        # 闹钟列表区域
        self.setup_alarm_list(main_frame)
        
        # 状态栏
        self.setup_status_bar(main_frame)
        
    def setup_time_display(self, parent):
        """设置时间显示区域"""
        time_frame = ttk.Frame(parent, relief=tk.RAISED, borderwidth=2)
        time_frame.pack(fill=tk.X, pady=(0, 20), padx=20)
        
        # 时间显示
        self.time_label = tk.Label(time_frame, text="00:00:00.00", 
                                  font=("Consolas", 48, "bold"),
                                  fg='#3498db', bg='white',
                                  width=12, height=2, anchor='center')
        self.time_label.pack(pady=20, padx=20)
        
        # 进度条
        self.progress_bar = ttk.Progressbar(time_frame, length=300, mode='determinate')
        self.progress_bar.pack(pady=(0, 20), padx=20)
        
    def setup_time_setting(self, parent):
        """设置时间设置区域"""
        setting_frame = ttk.LabelFrame(parent, text="⏱️ 设置时间", padding="15")
        setting_frame.pack(fill=tk.X, pady=(0, 20), padx=20)
        
        # 小时
        hour_frame = ttk.Frame(setting_frame)
        hour_frame.pack(side=tk.LEFT, padx=10)
        ttk.Label(hour_frame, text="时:").pack()
        self.hour_spinbox = ttk.Spinbox(hour_frame, from_=0, to=23, width=5,
                                       font=("微软雅黑", 12), format="%02.0f")
        self.hour_spinbox.set("00")
        self.hour_spinbox.pack(pady=5)
        
        # 分钟
        minute_frame = ttk.Frame(setting_frame)
        minute_frame.pack(side=tk.LEFT, padx=10)
        ttk.Label(minute_frame, text="分:").pack()
        self.minute_spinbox = ttk.Spinbox(minute_frame, from_=0, to=59, width=5,
                                         font=("微软雅黑", 12), format="%02.0f")
        self.minute_spinbox.set("00")
        self.minute_spinbox.pack(pady=5)
        
        # 秒
        second_frame = ttk.Frame(setting_frame)
        second_frame.pack(side=tk.LEFT, padx=10)
        ttk.Label(second_frame, text="秒:").pack()
        self.second_spinbox = ttk.Spinbox(second_frame, from_=0, to=59, width=5,
                                         font=("微软雅黑", 12), format="%02.0f")
        self.second_spinbox.set("10")
        self.second_spinbox.pack(pady=5)
        
        # 快捷按钮
        quick_frame = ttk.Frame(setting_frame)
        quick_frame.pack(side=tk.LEFT, padx=20)
        ttk.Label(quick_frame, text="快捷设置:").pack()
        
        btn_frame = ttk.Frame(quick_frame)
        btn_frame.pack()
        
        ttk.Button(btn_frame, text="1分钟", width=8, 
                  command=lambda: self.set_quick_time(0, 1, 0)).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="5分钟", width=8,
                  command=lambda: self.set_quick_time(0, 5, 0)).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="10分钟", width=8,
                  command=lambda: self.set_quick_time(0, 10, 0)).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="15分钟", width=8,
                  command=lambda: self.set_quick_time(0, 15, 0)).pack(side=tk.LEFT, padx=2)
        
    def setup_controls(self, parent):
        """设置控制按钮区域"""
        control_frame = ttk.Frame(parent)
        control_frame.pack(pady=(0, 20))
        
        # 开始/暂停按钮
        self.start_button = ttk.Button(control_frame, text="▶ 开始", 
                                      command=self.start_timer, width=12)
        self.start_button.pack(side=tk.LEFT, padx=5)
        
        # 暂停/继续按钮
        self.pause_button = ttk.Button(control_frame, text="⏸ 暂停", 
                                      command=self.pause_timer, width=12, state=tk.DISABLED)
        self.pause_button.pack(side=tk.LEFT, padx=5)
        
        # 重置按钮
        ttk.Button(control_frame, text="↺ 重置", 
                  command=self.reset_timer, width=12).pack(side=tk.LEFT, padx=5)
        
        # 停止按钮
        ttk.Button(control_frame, text="■ 停止", 
                  command=self.stop_timer, width=12).pack(side=tk.LEFT, padx=5)
        
    def setup_alarm_controls(self, parent):
        """设置闹钟控制区域"""
        alarm_frame = ttk.LabelFrame(parent, text="⏰ 闹钟设置", padding="15")
        alarm_frame.pack(fill=tk.X, pady=(0, 20), padx=20)
        
        # 时间设置
        time_set_frame = ttk.Frame(alarm_frame)
        time_set_frame.pack(fill=tk.X, pady=(0, 10))
        
        ttk.Label(time_set_frame, text="闹钟时间:").pack(side=tk.LEFT, padx=5)
        
        # 小时
        self.alarm_hour = ttk.Spinbox(time_set_frame, from_=0, to=23, width=3,
                                     font=("微软雅黑", 10), format="%02.0f")
        self.alarm_hour.set("12")
        self.alarm_hour.pack(side=tk.LEFT, padx=2)
        ttk.Label(time_set_frame, text="时").pack(side=tk.LEFT)
        
        # 分钟
        self.alarm_minute = ttk.Spinbox(time_set_frame, from_=0, to=59, width=3,
                                       font=("微软雅黑", 10), format="%02.0f")
        self.alarm_minute.set("00")
        self.alarm_minute.pack(side=tk.LEFT, padx=2)
        ttk.Label(time_set_frame, text="分").pack(side=tk.LEFT)
        
        # 描述
        ttk.Label(alarm_frame, text="描述:").pack(side=tk.LEFT, padx=5)
        self.alarm_desc = ttk.Entry(alarm_frame, width=20, font=("微软雅黑", 10))
        self.alarm_desc.pack(side=tk.LEFT, padx=5)
        self.alarm_desc.insert(0, "闹钟提醒")
        
        # 添加按钮
        ttk.Button(alarm_frame, text="添加闹钟", 
                  command=self.add_alarm, width=10).pack(side=tk.RIGHT, padx=5)
        
    def setup_alarm_list(self, parent):
        """设置闹钟列表区域"""
        list_frame = ttk.LabelFrame(parent, text="📅 闹钟列表", padding="10")
        list_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 20), padx=20)
        
        # 创建Treeview
        columns = ("时间", "描述", "状态")
        self.alarm_tree = ttk.Treeview(list_frame, columns=columns, show="headings", height=6)
        
        # 设置列
        self.alarm_tree.heading("时间", text="时间")
        self.alarm_tree.heading("描述", text="描述")
        self.alarm_tree.heading("状态", text="状态")
        
        self.alarm_tree.column("时间", width=100, anchor='center')
        self.alarm_tree.column("描述", width=200, anchor='center')
        self.alarm_tree.column("状态", width=80, anchor='center')
        
        # 添加滚动条
        scrollbar = ttk.Scrollbar(list_frame, orient=tk.VERTICAL, command=self.alarm_tree.yview)
        self.alarm_tree.configure(yscrollcommand=scrollbar.set)
        
        self.alarm_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # 闹钟操作按钮
        alarm_btn_frame = ttk.Frame(list_frame)
        alarm_btn_frame.pack(fill=tk.X, pady=(5, 0))
        
        ttk.Button(alarm_btn_frame, text="删除选中", 
                  command=self.delete_alarm, width=10).pack(side=tk.LEFT, padx=2)
        ttk.Button(alarm_btn_frame, text="清空列表", 
                  command=self.clear_alarms, width=10).pack(side=tk.LEFT, padx=2)
        
        # 闹钟开关
        self.alarm_var = tk.BooleanVar(value=True)
        ttk.Checkbutton(alarm_btn_frame, text="启用闹钟", 
                       variable=self.alarm_var, command=self.toggle_alarm).pack(side=tk.RIGHT, padx=2)
        
    def setup_status_bar(self, parent):
        """设置状态栏"""
        self.status_bar = ttk.Label(parent, text="就绪", relief=tk.SUNKEN, anchor=tk.W)
        self.status_bar.pack(fill=tk.X, padx=20, pady=(0, 10))
        
    def set_quick_time(self, hours, minutes, seconds):
        """快捷设置时间"""
        self.hour_spinbox.set(f"{hours:02d}")
        self.minute_spinbox.set(f"{minutes:02d}")
        self.second_spinbox.set(f"{seconds:02d}")
        self.update_display()
        self.status_bar.config(text=f"已设置为 {hours:02d}:{minutes:02d}:{seconds:02d}")
        
    def update_display(self):
        """更新显示"""
        hours = int(self.hour_spinbox.get())
        minutes = int(self.minute_spinbox.get())
        seconds = int(self.second_spinbox.get())
        
        total_seconds = hours * 3600 + minutes * 60 + seconds
        self.progress_bar['maximum'] = total_seconds
        
        # 格式化显示
        time_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
        self.time_label.config(text=time_str)
        
    def start_timer(self):
        """开始计时"""
        if not self.is_running:
            self.is_running = True
            self.is_paused = False
            self.start_time = time.time()
            
            # 获取设置的时间
            target_hours = int(self.hour_spinbox.get())
            target_minutes = int(self.minute_spinbox.get())
            target_seconds = int(self.second_spinbox.get())
            
            self.target_time = target_hours * 3600 + target_minutes * 60 + target_seconds
            self.progress_bar['maximum'] = self.target_time
            
            # 更新按钮状态
            self.start_button.config(state=tk.DISABLED, text="▶ 运行中")
            self.pause_button.config(state=tk.NORMAL, text="⏸ 暂停")
            
            # 创建定时器线程
            self.timer_thread = threading.Thread(target=self.timer_loop, daemon=True)
            self.timer_thread.start()
            
            self.status_bar.config(text="定时器已启动")
    
    def pause_timer(self):
        """暂停/继续计时"""
        if self.is_running and not self.is_paused:
            # 暂停
            self.is_paused = True
            self.paused_time = time.time()
            self.pause_button.config(text="▶ 继续")
            self.status_bar.config(text="定时器已暂停")
        elif self.is_running and self.is_paused:
            # 继续
            self.is_paused = False
            # 调整开始时间以补偿暂停时间
            pause_duration = time.time() - self.paused_time
            self.start_time += pause_duration
            self.pause_button.config(text="⏸ 暂停")
            self.status_bar.config(text="定时器已继续")
    
    def reset_timer(self):
        """重置计时器"""
        self.stop_timer()
        self.update_display()
        self.status_bar.config(text="定时器已重置")
    
    def stop_timer(self):
        """停止计时"""
        self.is_running = False
        self.is_paused = False
        
        # 更新按钮状态
        self.start_button.config(state=tk.NORMAL, text="▶ 开始")
        self.pause_button.config(state=tk.DISABLED, text="⏸ 暂停")
        
        # 重置进度条
        self.progress_bar['value'] = 0
        
        self.status_bar.config(text="定时器已停止")
    
    def timer_loop(self):
        """定时器循环"""
        while self.is_running:
            if not self.is_paused:
                elapsed = time.time() - self.start_time
                
                # 在主线程中更新显示
                self.root.after(0, self.update_timer_display, elapsed)
                
                # 检查是否到达目标时间
                if elapsed >= self.target_time:
                    self.root.after(0, self.timer_complete)
                    break
                
                # 更新进度条
                progress = min(elapsed, self.target_time)
                self.root.after(0, self.progress_bar.config, {'value': progress})
                
                # 检查闹钟
                self.root.after(0, self.check_alarms)
            
            time.sleep(0.1)  # 减少CPU使用
    
    def update_timer_display(self, elapsed):
        """更新计时器显示"""
        if not self.is_running:
            return
            
        remaining = max(0, self.target_time - elapsed)
        
        hours = int(remaining // 3600)
        minutes = int((remaining % 3600) // 60)
        seconds = int(remaining % 60)
        milliseconds = int((remaining - int(remaining)) * 100)
        
        time_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}.{milliseconds:02d}"
        self.time_label.config(text=time_str)
        
        # 最后10秒闪烁
        if remaining <= 10 and not self.is_paused:
            if int(time.time() * 2) % 2 == 0:  # 每秒闪烁2次
                self.time_label.config(fg='#e74c3c')
            else:
                self.time_label.config(fg='#3498db')
    
    def timer_complete(self):
        """计时完成"""
        self.stop_timer()
        
        # 播放提示音
        if sys.platform == 'win32':
            try:
                winsound.Beep(1000, 1000)  # 频率1000Hz，持续1秒
                winsound.Beep(1200, 500)   # 频率1200Hz，持续0.5秒
                winsound.Beep(1000, 1000)  # 频率1000Hz，持续1秒
            except:
                pass
        
        # 显示完成消息
        messagebox.showinfo("定时完成", "⏰ 时间到！\n\n定时器已完成计时。")
        
        # 重置显示
        self.time_label.config(text="00:00:00.00", fg='#3498db')
        self.status_bar.config(text="定时器已完成")
    
    def add_alarm(self):
        """添加闹钟"""
        try:
            hour = int(self.alarm_hour.get())
            minute = int(self.alarm_minute.get())
            desc = self.alarm_desc.get().strip()
            
            if not desc:
                desc = "闹钟提醒"
            
            if 0 <= hour <= 23 and 0 <= minute <= 59:
                alarm_time = f"{hour:02d}:{minute:02d}"
                
                # 检查是否已存在
                for item in self.alarm_tree.get_children():
                    if self.alarm_tree.item(item)['values'][0] == alarm_time:
                        messagebox.showwarning("重复闹钟", "该时间已存在闹钟！")
                        return
                
                # 添加到列表
                self.alarms.append({
                    'time': alarm_time,
                    'hour': hour,
                    'minute': minute,
                    'desc': desc,
                    'enabled': True
                })
                
                # 添加到Treeview
                self.alarm_tree.insert("", tk.END, values=(alarm_time, desc, "启用"))
                
                # 清空输入
                self.alarm_desc.delete(0, tk.END)
                self.alarm_desc.insert(0, "闹钟提醒")
                
                self.status_bar.config(text=f"已添加闹钟: {alarm_time} - {desc}")
            else:
                messagebox.showerror("错误", "请输入有效的时间！")
        except ValueError:
            messagebox.showerror("错误", "请输入有效的数字！")
    
    def delete_alarm(self):
        """删除选中闹钟"""
        selected = self.alarm_tree.selection()
        if not selected:
            messagebox.showwarning("提示", "请先选择一个闹钟")
            return
        
        for item in selected:
            # 从alarms列表中删除
            alarm_time = self.alarm_tree.item(item)['values'][0]
            self.alarms = [a for a in self.alarms if a['time'] != alarm_time]
            # 从Treeview中删除
            self.alarm_tree.delete(item)
        
        self.status_bar.config(text="已删除选中的闹钟")
    
    def clear_alarms(self):
        """清空所有闹钟"""
        if messagebox.askyesno("确认", "确定要清空所有闹钟吗？"):
            self.alarms.clear()
            for item in self.alarm_tree.get_children():
                self.alarm_tree.delete(item)
            self.status_bar.config(text="已清空所有闹钟")
    
    def toggle_alarm(self):
        """切换闹钟开关"""
        self.alarm_enabled = self.alarm_var.get()
        status = "启用" if self.alarm_enabled else "禁用"
        self.status_bar.config(text=f"闹钟已{status}")
    
    def check_alarms(self):
        """检查闹钟"""
        if not self.alarm_enabled or not self.alarms:
            return
        
        current_time = time.localtime()
        current_hour = current_time.tm_hour
        current_minute = current_time.tm_min
        
        for alarm in self.alarms:
            if alarm['enabled'] and alarm['hour'] == current_hour and alarm['minute'] == current_minute:
                # 触发闹钟
                self.trigger_alarm(alarm)
                alarm['enabled'] = False  # 防止重复触发
    
    def trigger_alarm(self, alarm):
        """触发闹钟"""
        # 播放声音
        if sys.platform == 'win32':
            try:
                for _ in range(3):  # 响3次
                    winsound.Beep(800, 500)
                    winsound.Beep(1200, 500)
            except:
                pass
        
        # 显示消息
        messagebox.showinfo("⏰ 闹钟提醒", 
                          f"时间: {alarm['time']}\n"
                          f"描述: {alarm['desc']}")
        
        # 更新Treeview中的状态
        for item in self.alarm_tree.get_children():
            if self.alarm_tree.item(item)['values'][0] == alarm['time']:
                self.alarm_tree.set(item, "状态", "已触发")
                break
        
        self.status_bar.config(text=f"闹钟触发: {alarm['time']} - {alarm['desc']}")

def main():
    root = tk.Tk()
    app = TimerApp(root)
    
    # 设置窗口居中
    root.update_idletasks()
    width = root.winfo_width()
    height = root.winfo_height()
    x = (root.winfo_screenwidth() // 2) - (width // 2)
    y = (root.winfo_screenheight() // 2) - (height // 2)
    root.geometry(f'{width}x{height}+{x}+{y}')
    
    # 添加菜单
    menubar = tk.Menu(root)
    root.config(menu=menubar)
    
    # 文件菜单
    file_menu = tk.Menu(menubar, tearoff=0)
    menubar.add_cascade(label="文件", menu=file_menu)
    file_menu.add_command(label="退出", command=root.quit)
    
    # 帮助菜单
    help_menu = tk.Menu(menubar, tearoff=0)
    menubar.add_cascade(label="帮助", menu=help_menu)
    help_menu.add_command(label="关于", command=lambda: messagebox.showinfo("关于", 
        "多功能定时器 v1.0\n\n功能：\n• 倒计时定时器\n• 闹钟功能\n• 快捷时间设置\n• 进度条显示"))
    
    root.mainloop()

if __name__ == "__main__":
    main()