import pygame
import sys
import time
import math
import random
from typing import Optional, Tuple, List, Dict

# 初始化Pygame
pygame.init()
pygame.mixer.init()  # 初始化音频

# 屏幕设置
WIDTH, HEIGHT = 900, 650
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("专业级计时器")
clock = pygame.time.Clock()

# 配色方案
COLOR_PALETTE = {
    "dark_bg": (15, 20, 30),
    "light_bg": (25, 30, 45),
    "primary": (0, 200, 255),      # 青色
    "secondary": (255, 105, 180),  # 粉色
    "success": (0, 230, 118),      # 绿色
    "warning": (255, 193, 7),      # 黄色
    "error": (255, 61, 0),         # 红色
    "text_light": (245, 245, 245),
    "text_muted": (150, 150, 170),
    "card_bg": (30, 35, 55),
    "border": (60, 70, 100),
    "progress_fill": (0, 200, 255, 100),
    "progress_bg": (40, 50, 80)
}

# 字体
try:
    FONT_TITLE = pygame.font.SysFont("microsoftyahei", 48, bold=True)
    FONT_LARGE = pygame.font.SysFont("consolas", 96, bold=True)
    FONT_MEDIUM = pygame.font.SysFont("microsoftyahei", 36)
    FONT_NORMAL = pygame.font.SysFont("microsoftyahei", 28)
    FONT_SMALL = pygame.font.SysFont("microsoftyahei", 22)
    FONT_TINY = pygame.font.SysFont("microsoftyahei", 18)
except:
    # 备用字体
    FONT_TITLE = pygame.font.Font(None, 48)
    FONT_LARGE = pygame.font.Font(None, 96)
    FONT_MEDIUM = pygame.font.Font(None, 36)
    FONT_NORMAL = pygame.font.Font(None, 28)
    FONT_SMALL = pygame.font.Font(None, 22)
    FONT_TINY = pygame.font.Font(None, 18)

class TimerState:
    """计时器状态"""
    IDLE = "idle"           # 空闲
    RUNNING = "running"     # 运行中
    PAUSED = "paused"       # 暂停
    COMPLETED = "completed" # 完成

class TimerMode:
    """计时器模式"""
    COUNTDOWN = "countdown"  # 倒计时
    STOPWATCH = "stopwatch"  # 正计时

class Timer:
    """计时器核心类"""
    def __init__(self):
        self.reset()
        self.mode = TimerMode.COUNTDOWN
        self.start_time: Optional[float] = None
        self.pause_start: Optional[float] = None
        self.total_paused = 0.0
        
        # 预设时间（单位：秒）
        self.presets = {
            "番茄工作法": 25 * 60,    # 25分钟
            "短时休息": 5 * 60,       # 5分钟
            "长时休息": 15 * 60,      # 15分钟
            "专注60分": 60 * 60,      # 60分钟
            "快速10分": 10 * 60,      # 10分钟
            "演讲计时": 7 * 60,       # 7分钟
            "泡面时间": 3 * 60,       # 3分钟
            "冥想练习": 10 * 60       # 10分钟
        }
        
        # 当前设置
        self.target_time = 25 * 60  # 默认25分钟
        
    def reset(self):
        """重置计时器"""
        self.state = TimerState.IDLE
        self.elapsed = 0.0
        self.remaining = 0.0
        self.start_time = None
        self.pause_start = None
        self.total_paused = 0.0
        
    def set_mode(self, mode: str):
        """设置计时器模式"""
        self.mode = mode
        self.reset()
        if mode == TimerMode.COUNTDOWN:
            self.remaining = self.target_time
            
    def set_target_time(self, seconds: int):
        """设置目标时间（仅对倒计时有效）"""
        self.target_time = seconds
        self.remaining = seconds
        
    def set_preset(self, preset_name: str):
        """设置预设时间"""
        if preset_name in self.presets:
            self.set_target_time(self.presets[preset_name])
            
    def start(self):
        """开始计时"""
        if self.state in [TimerState.IDLE, TimerState.COMPLETED]:
            self.start_time = time.time()
            self.total_paused = 0.0
            self.state = TimerState.RUNNING
        elif self.state == TimerState.PAUSED:
            # 从暂停恢复
            if self.pause_start:
                self.total_paused += time.time() - self.pause_start
                self.pause_start = None
            self.state = TimerState.RUNNING
            
    def pause(self):
        """暂停计时"""
        if self.state == TimerState.RUNNING:
            self.pause_start = time.time()
            self.state = TimerState.PAUSED
            
    def update(self):
        """更新计时器状态"""
        if self.state != TimerState.RUNNING:
            return
            
        current_time = time.time()
        
        if self.mode == TimerMode.COUNTDOWN:
            if self.start_time:
                elapsed = current_time - self.start_time - self.total_paused
                self.elapsed = elapsed
                self.remaining = max(0, self.target_time - elapsed)
                
                if self.remaining <= 0:
                    self.state = TimerState.COMPLETED
                    
        elif self.mode == TimerMode.STOPWATCH:
            if self.start_time:
                self.elapsed = current_time - self.start_time - self.total_paused
                
    def get_display_time(self) -> str:
        """获取显示时间字符串"""
        if self.mode == TimerMode.COUNTDOWN:
            total_seconds = int(self.remaining)
        else:  # STOPWATCH
            total_seconds = int(self.elapsed)
            
        hours = total_seconds // 3600
        minutes = (total_seconds % 3600) // 60
        seconds = total_seconds % 60
        
        if hours > 0:
            return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
        return f"{minutes:02d}:{seconds:02d}"
        
    def get_progress(self) -> float:
        """获取进度（0-1）"""
        if self.mode == TimerMode.COUNTDOWN:
            if self.target_time == 0:
                return 0
            return 1.0 - (self.remaining / self.target_time)
        else:  # STOPWATCH
            # 每分钟循环
            return (self.elapsed % 60) / 60.0
            
    def get_state_color(self) -> Tuple[int, int, int]:
        """根据状态获取颜色"""
        if self.state == TimerState.RUNNING:
            return COLOR_PALETTE["success"]
        elif self.state == TimerState.PAUSED:
            return COLOR_PALETTE["warning"]
        elif self.state == TimerState.COMPLETED:
            return COLOR_PALETTE["error"]
        else:  # IDLE
            return COLOR_PALETTE["primary"]

class Button:
    """按钮控件"""
    def __init__(self, x: int, y: int, width: int, height: int, text: str, 
                 action=None, color=None, hover_color=None, text_color=COLOR_PALETTE["text_light"]):
        self.rect = pygame.Rect(x, y, width, height)
        self.text = text
        self.action = action
        self.color = color or COLOR_PALETTE["card_bg"]
        self.hover_color = hover_color or COLOR_PALETTE["primary"]
        self.text_color = text_color
        self.hovered = False
        self.enabled = True
        self.rounded = 8
        
    def draw(self, surface: pygame.Surface):
        """绘制按钮"""
        # 按钮背景
        color = self.hover_color if self.hovered and self.enabled else self.color
        pygame.draw.rect(surface, color, self.rect, border_radius=self.rounded)
        
        # 边框
        border_color = (200, 200, 200, 100) if self.enabled else (100, 100, 100, 50)
        pygame.draw.rect(surface, border_color, self.rect, 2, border_radius=self.rounded)
        
        # 文字
        font = FONT_NORMAL if self.rect.height > 40 else FONT_SMALL
        text_surf = font.render(self.text, True, 
                               self.text_color if self.enabled else COLOR_PALETTE["text_muted"])
        text_rect = text_surf.get_rect(center=self.rect.center)
        surface.blit(text_surf, text_rect)
        
    def check_hover(self, pos: Tuple[int, int]) -> bool:
        """检查鼠标悬停"""
        self.hovered = self.rect.collidepoint(pos) and self.enabled
        return self.hovered
        
    def handle_event(self, event: pygame.event.Event):
        """处理事件"""
        if event.type == pygame.MOUSEBUTTONDOWN and self.hovered and self.enabled and self.action:
            return self.action()
        return None

class TimeInput:
    """时间输入控件"""
    def __init__(self, x: int, y: int, width: int, height: int):
        self.rect = pygame.Rect(x, y, width, height)
        self.minutes = 25
        self.seconds = 0
        self.focused = False
        self.active_field = "minutes"  # "minutes" 或 "seconds"
        
    def draw(self, surface: pygame.Surface):
        """绘制时间输入"""
        # 背景
        pygame.draw.rect(surface, COLOR_PALETTE["card_bg"], self.rect, border_radius=6)
        pygame.draw.rect(surface, COLOR_PALETTE["border"], self.rect, 2, border_radius=6)
        
        # 时间显示
        time_str = f"{self.minutes:02d}:{self.seconds:02d}"
        time_surf = FONT_MEDIUM.render(time_str, True, COLOR_PALETTE["text_light"])
        time_rect = time_surf.get_rect(center=self.rect.center)
        surface.blit(time_surf, time_rect)
        
        # 光标（如果聚焦）
        if self.focused:
            cursor_x = time_rect.x + (80 if self.active_field == "seconds" else 30)
            pygame.draw.line(surface, COLOR_PALETTE["primary"], 
                           (cursor_x, time_rect.y + 5), 
                           (cursor_x, time_rect.y + time_rect.height - 5), 2)
            
    def handle_event(self, event: pygame.event.Event) -> bool:
        """处理事件，返回是否时间有变化"""
        if event.type == pygame.MOUSEBUTTONDOWN:
            self.focused = self.rect.collidepoint(event.pos)
            if self.focused:
                # 简单判断点击的是分钟还是秒
                rel_x = event.pos[0] - self.rect.x
                self.active_field = "seconds" if rel_x > self.rect.width * 0.6 else "minutes"
                
        elif event.type == pygame.KEYDOWN and self.focused:
            if event.key == pygame.K_UP:
                if self.active_field == "minutes":
                    self.minutes = min(99, self.minutes + 1)
                else:
                    self.seconds = min(59, self.seconds + 1)
                return True
            elif event.key == pygame.K_DOWN:
                if self.active_field == "minutes":
                    self.minutes = max(0, self.minutes - 1)
                else:
                    self.seconds = max(0, self.seconds - 1)
                return True
            elif event.key == pygame.K_TAB:
                self.active_field = "seconds" if self.active_field == "minutes" else "minutes"
            elif event.unicode.isdigit():
                digit = int(event.unicode)
                if self.active_field == "minutes":
                    self.minutes = min(99, self.minutes * 10 + digit)
                else:
                    self.seconds = min(59, self.seconds * 10 + digit)
                return True
                
        return False

class CircularProgressBar:
    """圆形进度条"""
    def __init__(self, center_x: int, center_y: int, radius: int, thickness: int = 20):
        self.center = (center_x, center_y)
        self.radius = radius
        self.thickness = thickness
        
    def draw(self, surface: pygame.Surface, progress: float, color: Tuple[int, int, int]):
        """绘制进度条"""
        # 创建临时surface支持透明度
        temp_surface = pygame.Surface((self.radius * 2 + 20, self.radius * 2 + 20), pygame.SRCALPHA)
        
        # 背景圆
        pygame.draw.circle(temp_surface, (*COLOR_PALETTE["progress_bg"], 100), 
                          (self.radius + 10, self.radius + 10), 
                          self.radius, self.thickness)
        
        # 进度弧
        if progress > 0:
            end_angle = 2 * math.pi * progress - math.pi / 2
            start_angle = -math.pi / 2
            
            # 绘制粗弧线
            for r in range(self.radius - self.thickness // 2, self.radius + self.thickness // 2):
                points = []
                for angle in range(0, int(progress * 360) + 1):
                    rad = math.radians(angle) - math.pi / 2
                    x = self.radius + 10 + r * math.cos(rad)
                    y = self.radius + 10 + r * math.sin(rad)
                    points.append((x, y))
                
                if len(points) > 1:
                    pygame.draw.lines(temp_surface, (*color, 150), False, points, 2)
        
        # 绘制到主surface
        surface.blit(temp_surface, (self.center[0] - self.radius - 10, self.center[1] - self.radius - 10))
        
        # 端点圆点
        if progress > 0:
            end_angle = 2 * math.pi * progress - math.pi / 2
            end_x = self.center[0] + self.radius * math.cos(end_angle)
            end_y = self.center[1] + self.radius * math.sin(end_angle)
            pygame.draw.circle(surface, color, (int(end_x), int(end_y)), self.thickness // 2)

class TimerApp:
    """计时器应用程序"""
    def __init__(self):
        self.timer = Timer()
        self.progress_bar = CircularProgressBar(WIDTH // 2, HEIGHT // 2 - 20, 180, 25)
        self.time_input = TimeInput(WIDTH // 2 - 100, HEIGHT - 200, 200, 60)
        self.buttons: List[Button] = []
        self.message = ""
        self.message_time = 0
        self.notification_played = False
        self.init_ui()
        
    def init_ui(self):
        """初始化UI"""
        self.buttons.clear()
        
        center_x = WIDTH // 2
        
        # 模式切换按钮
        mode_buttons = [
            ("倒计时", lambda: self.switch_mode(TimerMode.COUNTDOWN)),
            ("正计时", lambda: self.switch_mode(TimerMode.STOPWATCH))
        ]
        
        for i, (text, action) in enumerate(mode_buttons):
            is_active = (i == 0 and self.timer.mode == TimerMode.COUNTDOWN) or \
                       (i == 1 and self.timer.mode == TimerMode.STOPWATCH)
            color = COLOR_PALETTE["primary"] if is_active else COLOR_PALETTE["card_bg"]
            
            self.buttons.append(Button(
                center_x - 250 + i * 170, 100, 160, 50, text, action, color
            ))
        
        # 控制按钮
        control_buttons = [
            ("开始", self.start_stop_timer, COLOR_PALETTE["success"]),
            ("暂停", self.timer.pause, COLOR_PALETTE["warning"]),
            ("重置", self.reset_timer, COLOR_PALETTE["error"])
        ]
        
        for i, (text, action, color) in enumerate(control_buttons):
            self.buttons.append(Button(
                center_x - 200 + i * 140, HEIGHT - 120, 130, 50, text, action, color
            ))
        
        # 预设时间按钮
        preset_names = list(self.timer.presets.keys())
        cols = 4
        rows = (len(preset_names) + cols - 1) // cols
        
        for i, name in enumerate(preset_names):
            row = i // cols
            col = i % cols
            x = 30 + col * 210
            y = HEIGHT - 350 + row * 45
            
            self.buttons.append(Button(
                x, y, 200, 40, name, 
                lambda n=name: self.set_preset(n)
            ))
    
    def switch_mode(self, mode: str):
        """切换模式"""
        if self.timer.mode != mode:
            self.timer.set_mode(mode)
            self.show_message(f"切换到{'倒计时' if mode == TimerMode.COUNTDOWN else '正计时'}模式")
            self.init_ui()
    
    def start_stop_timer(self):
        """开始/停止计时器"""
        if self.timer.state in [TimerState.IDLE, TimerState.COMPLETED, TimerState.PAUSED]:
            self.timer.start()
            self.show_message("计时开始" if self.timer.state != TimerState.PAUSED else "继续计时")
        elif self.timer.state == TimerState.RUNNING:
            self.timer.pause()
            self.show_message("计时暂停")
    
    def reset_timer(self):
        """重置计时器"""
        self.timer.reset()
        if self.timer.mode == TimerMode.COUNTDOWN:
            self.timer.remaining = self.timer.target_time
        self.show_message("计时器已重置")
        self.notification_played = False
    
    def set_preset(self, preset_name: str):
        """设置预设时间"""
        self.timer.set_preset(preset_name)
        self.time_input.minutes = self.timer.target_time // 60
        self.time_input.seconds = self.timer.target_time % 60
        self.show_message(f"已设置为: {preset_name}")
    
    def show_message(self, message: str, duration: float = 2.0):
        """显示消息"""
        self.message = message
        self.message_time = time.time() + duration
    
    def draw_background(self):
        """绘制背景"""
        # 渐变背景
        for y in range(0, HEIGHT, 2):
            alpha = 100 + int(155 * (y / HEIGHT))
            color = (20, 25, 35, alpha)
            pygame.draw.line(screen, color, (0, y), (WIDTH, y), 2)
        
        # 装饰性网格
        grid_color = (40, 45, 65, 30)
        for x in range(0, WIDTH, 50):
            pygame.draw.line(screen, grid_color, (x, 0), (x, HEIGHT), 1)
        for y in range(0, HEIGHT, 50):
            pygame.draw.line(screen, grid_color, (0, y), (WIDTH, y), 1)
        
        # 装饰性圆点 - 已修复
        for _ in range(20):
            x = pygame.time.get_ticks() * 0.001 % WIDTH
            y = random.randint(0, HEIGHT)  # 使用随机数
            size = random.randint(2, 6)
            alpha = random.randint(50, 150)
            color = (*COLOR_PALETTE["primary"], alpha)
            pygame.draw.circle(screen, color, (int(x), y), size)
    
    def draw_header(self):
        """绘制标题栏"""
        # 标题
        title = FONT_TITLE.render("专业级计时器", True, COLOR_PALETTE["text_light"])
        screen.blit(title, (WIDTH // 2 - title.get_width() // 2, 20))
        
        # 副标题
        subtitle = FONT_TINY.render("精确计时，高效工作", True, COLOR_PALETTE["text_muted"])
        screen.blit(subtitle, (WIDTH // 2 - subtitle.get_width() // 2, 75))
    
    def draw_timer_display(self):
        """绘制计时器显示"""
        # 绘制进度条
        progress = self.timer.get_progress()
        state_color = self.timer.get_state_color()
        self.progress_bar.draw(screen, progress, state_color)
        
        # 时间显示
        time_str = self.timer.get_display_time()
        time_surf = FONT_LARGE.render(time_str, True, COLOR_PALETTE["text_light"])
        time_rect = time_surf.get_rect(center=(WIDTH // 2, HEIGHT // 2 - 20))
        
        # 时间背景
        bg_rect = time_rect.inflate(40, 20)
        pygame.draw.rect(screen, (*COLOR_PALETTE["card_bg"], 200), bg_rect, border_radius=12)
        pygame.draw.rect(screen, COLOR_PALETTE["border"], bg_rect, 2, border_radius=12)
        
        screen.blit(time_surf, time_rect)
        
        # 状态文本
        state_texts = {
            TimerState.IDLE: "准备就绪",
            TimerState.RUNNING: "计时中...",
            TimerState.PAUSED: "已暂停",
            TimerState.COMPLETED: "时间到！"
        }
        
        state_text = state_texts.get(self.timer.state, "")
        if state_text:
            state_surf = FONT_NORMAL.render(state_text, True, state_color)
            screen.blit(state_surf, (WIDTH // 2 - state_surf.get_width() // 2, HEIGHT // 2 + 60))
        
        # 模式显示
        mode_text = "倒计时" if self.timer.mode == TimerMode.COUNTDOWN else "正计时"
        mode_surf = FONT_SMALL.render(f"模式: {mode_text}", True, COLOR_PALETTE["text_muted"])
        screen.blit(mode_surf, (WIDTH // 2 - mode_surf.get_width() // 2, HEIGHT // 2 + 100))
        
        # 进度百分比
        if self.timer.mode == TimerMode.COUNTDOWN:
            percent = int(progress * 100)
            percent_surf = FONT_SMALL.render(f"{percent}%", True, COLOR_PALETTE["text_muted"])
            screen.blit(percent_surf, (WIDTH // 2 - percent_surf.get_width() // 2, HEIGHT // 2 + 130))
    
    def draw_time_input(self):
        """绘制时间输入"""
        if self.timer.mode == TimerMode.COUNTDOWN and self.timer.state == TimerState.IDLE:
            # 输入框标签
            label = FONT_SMALL.render("设置时间 (分:秒):", True, COLOR_PALETTE["text_muted"])
            screen.blit(label, (WIDTH // 2 - label.get_width() // 2, HEIGHT - 260))
            
            # 绘制输入框
            self.time_input.draw(screen)
            
            # 控制提示
            controls = FONT_TINY.render("↑↓键调整 | Tab键切换 | 数字键输入", True, COLOR_PALETTE["text_muted"])
            screen.blit(controls, (WIDTH // 2 - controls.get_width() // 2, HEIGHT - 130))
    
    def draw_presets(self):
        """绘制预设按钮区域"""
        # 预设标题
        preset_title = FONT_MEDIUM.render("快速预设", True, COLOR_PALETTE["text_light"])
        screen.blit(preset_title, (30, HEIGHT - 400))
        
        # 预设描述
        preset_desc = FONT_TINY.render("点击以下预设快速设置时间:", True, COLOR_PALETTE["text_muted"])
        screen.blit(preset_desc, (30, HEIGHT - 370))
    
    def draw_message(self):
        """绘制消息提示"""
        if time.time() < self.message_time:
            # 消息背景
            msg_surf = FONT_SMALL.render(self.message, True, COLOR_PALETTE["text_light"])
            msg_rect = msg_surf.get_rect(center=(WIDTH // 2, 180))
            
            bg_rect = msg_rect.inflate(30, 15)
            pygame.draw.rect(screen, (*COLOR_PALETTE["success"], 150), bg_rect, border_radius=20)
            pygame.draw.rect(screen, COLOR_PALETTE["border"], bg_rect, 2, border_radius=20)
            
            screen.blit(msg_surf, msg_rect)
    
    def draw_footer(self):
        """绘制页脚"""
        # 快捷键提示
        shortcuts = [
            "空格键: 开始/暂停",
            "R键: 重置",
            "1键: 倒计时",
            "2键: 正计时",
            "ESC键: 退出"
        ]
        
        for i, text in enumerate(shortcuts):
            shortcut = FONT_TINY.render(text, True, COLOR_PALETTE["text_muted"])
            screen.blit(shortcut, (WIDTH - shortcut.get_width() - 20, 20 + i * 25))
        
        # 版权信息
        copyright_text = FONT_TINY.render("© 2024 Professional Timer v1.0", True, (100, 100, 120))
        screen.blit(copyright_text, (WIDTH // 2 - copyright_text.get_width() // 2, HEIGHT - 30))
        
        # 当前时间
        current_time = time.strftime("%H:%M:%S")
        time_text = FONT_TINY.render(f"系统时间: {current_time}", True, COLOR_PALETTE["text_muted"])
        screen.blit(time_text, (20, HEIGHT - 30))
    
    def check_completion(self):
        """检查计时器是否完成"""
        if self.timer.state == TimerState.COMPLETED and not self.notification_played:
            self.show_message("时间到！计时完成", 3.0)
            self.notification_played = True
    
    def handle_events(self) -> bool:
        """处理事件，返回是否继续运行"""
        mouse_pos = pygame.mouse.get_pos()
        
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return False
            
            # 键盘事件
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    self.start_stop_timer()
                elif event.key == pygame.K_r:
                    self.reset_timer()
                elif event.key == pygame.K_1:
                    self.switch_mode(TimerMode.COUNTDOWN)
                elif event.key == pygame.K_2:
                    self.switch_mode(TimerMode.STOPWATCH)
                elif event.key == pygame.K_ESCAPE:
                    return False
            
            # 处理按钮事件
            for button in self.buttons:
                button.check_hover(mouse_pos)
                result = button.handle_event(event)
                if result:
                    self.show_message(result)
            
            # 处理时间输入事件
            if self.time_input.handle_event(event):
                new_time = self.time_input.minutes * 60 + self.time_input.seconds
                self.timer.set_target_time(new_time)
                self.show_message(f"时间已设置为: {self.time_input.minutes:02d}:{self.time_input.seconds:02d}")
        
        return True
    
    def update(self):
        """更新应用程序状态"""
        # 更新计时器
        self.timer.update()
        
        # 更新UI状态
        for button in self.buttons:
            if button.text == "开始":
                if self.timer.state == TimerState.RUNNING:
                    button.text = "暂停"
                    button.color = COLOR_PALETTE["warning"]
                else:
                    button.text = "继续" if self.timer.state == TimerState.PAUSED else "开始"
                    button.color = COLOR_PALETTE["success"]
            
            if button.text == "暂停":
                button.enabled = self.timer.state == TimerState.RUNNING
        
        # 检查计时器完成
        self.check_completion()
    
    def draw(self):
        """绘制整个应用程序"""
        # 绘制背景
        self.draw_background()
        
        # 绘制标题
        self.draw_header()
        
        # 绘制计时器显示
        self.draw_timer_display()
        
        # 绘制预设区域
        self.draw_presets()
        
        # 绘制时间输入
        self.draw_time_input()
        
        # 绘制按钮
        for button in self.buttons:
            button.draw(screen)
        
        # 绘制消息
        self.draw_message()
        
        # 绘制页脚
        self.draw_footer()
    
    def run(self):
        """运行应用程序"""
        self.show_message("欢迎使用专业级计时器！")
        
        running = True
        while running:
            # 处理事件
            running = self.handle_events()
            
            # 更新状态
            self.update()
            
            # 绘制界面
            self.draw()
            
            # 更新显示
            pygame.display.flip()
            clock.tick(60)

def main():
    """主函数"""
    app = TimerApp()
    app.run()
    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()