TimerManager.cpp

#include "TimerManager.h"
#include "SDF.h"
#include <sstream>
#include <iomanip>
#include <cmath>
using namespace std;

//自定义计时器对话框实现
CustomTimerDialog::CustomTimerDialog()
{
    dialog_width = 350;
    dialog_height = 260;
    dialog_x = (520 - dialog_width) / 2;
    dialog_y = (680 - dialog_height) / 2;
    
    hours = 0;
    minutes = 0;
    seconds = 0;
    label_input = L"";
    ringtone_name = L"做个文明中国人";
    
    current_focus = TIMER_FOCUS_NONE;
    is_editing_label = false;
    
    hour_input_buffer = -1;
    minute_input_buffer = -1;
    second_input_buffer = -1;
    last_input_time = 0;
    
    show_ringtone_menu = false;
    ringtone_menu_y = 0;
    ringtone_scroll_offset = 0;
    ringtone_hovered_index = -1;
    
    is_visible = false;
    is_confirmed = false;
    
    AlarmSound::get_all_ringtones(&ringtone_list, ringtone_count);
}

CustomTimerDialog::~CustomTimerDialog()
{
    if (ringtone_list != nullptr)
    {
        delete[] ringtone_list;
    }
}

void CustomTimerDialog::show()
{
    is_visible = true;
    is_confirmed = false;
    hours = 0;
    minutes = 0;
    seconds = 0;
    label_input = L"";
    ringtone_name = L"做个文明中国人";
    current_focus = TIMER_FOCUS_NONE;
    is_editing_label = false;
    show_ringtone_menu = false;
}

void CustomTimerDialog::hide()
{
    is_visible = false;
    show_ringtone_menu = false;
}

void CustomTimerDialog::draw()
{
    if (!is_visible) return;
    
    //绘制半透明背景
    setfillcolor(RGB(0, 0, 0));
    for (int y = 0; y < 680; y += 2)
    {
        for (int x = 0; x < 520; x += 2)
        {
            putpixel(x, y, RGB(0, 0, 0));
        }
    }
    
    //绘制对话框背景
    setfillcolor(RGB(45, 45, 45));
    solidroundrect(dialog_x, dialog_y, dialog_x + dialog_width, dialog_y + dialog_height, 15, 15);
    
    setlinecolor(RGB(80, 80, 80));
    setlinestyle(PS_SOLID, 1);
    roundrect(dialog_x, dialog_y, dialog_x + dialog_width, dialog_y + dialog_height, 15, 15);
    
    draw_time_section();
    draw_label_section();
    draw_ringtone_section();
    draw_buttons();
    
    if (show_ringtone_menu)
    {
        draw_ringtone_menu();
    }
}

void CustomTimerDialog::draw_time_section()
{
    int time_y = dialog_y + 25;
    
    //绘制小时分钟秒标签
    settextstyle(12, 0, L"微软雅黑");
    settextcolor(RGB(154, 154, 154));
    setbkmode(TRANSPARENT);
    
    int digit_width = 45;
    int colon_width = 15;
    int total_width = digit_width * 3 + colon_width * 2;
    int start_x = dialog_x + (dialog_width - total_width) / 2;
    
    outtextxy(start_x + digit_width / 2 - 12, time_y, L"小时");
    outtextxy(start_x + digit_width + colon_width + digit_width / 2 - 12, time_y, L"分钟");
    outtextxy(start_x + digit_width * 2 + colon_width * 2 + digit_width / 2 - 6, time_y, L"秒");
    
    //绘制时间数字
    int digits_y = time_y + 20;
    settextstyle(40, 0, L"微软雅黑");
    
    wstringstream wss;
    wss << setfill(L'0') << setw(2) << hours;
    wstring hour_str = wss.str();
    wss.str(L"");
    wss << setfill(L'0') << setw(2) << minutes;
    wstring min_str = wss.str();
    wss.str(L"");
    wss << setfill(L'0') << setw(2) << seconds;
    wstring sec_str = wss.str();
    
    //小时背景
    if (current_focus == TIMER_FOCUS_HOUR)
    {
        setfillcolor(RGB(192, 123, 62));
        solidroundrect(start_x - 2, digits_y - 2, start_x + digit_width + 2, digits_y + 42, 5, 5);
    }
    
    settextcolor(RGB(221, 221, 221));
    outtextxy(start_x + 5, digits_y, hour_str.c_str());
    
    //冒号
    outtextxy(start_x + digit_width + 2, digits_y, L":");
    
    //分钟背景
    if (current_focus == TIMER_FOCUS_MINUTE)
    {
        setfillcolor(RGB(192, 123, 62));
        solidroundrect(start_x + digit_width + colon_width - 2, digits_y - 2, start_x + digit_width * 2 + colon_width + 2, digits_y + 42, 5, 5);
    }
    
    settextcolor(RGB(221, 221, 221));
    outtextxy(start_x + digit_width + colon_width + 5, digits_y, min_str.c_str());
    
    //冒号
    outtextxy(start_x + digit_width * 2 + colon_width + 2, digits_y, L":");
    
    //秒背景
    if (current_focus == TIMER_FOCUS_SECOND)
    {
        setfillcolor(RGB(192, 123, 62));
        solidroundrect(start_x + digit_width * 2 + colon_width * 2 - 2, digits_y - 2,start_x + digit_width * 3 + colon_width * 2 + 2, digits_y + 42, 5, 5);
    }
    
    settextcolor(RGB(221, 221, 221));
    outtextxy(start_x + digit_width * 2 + colon_width * 2 + 5, digits_y, sec_str.c_str());
}

void CustomTimerDialog::draw_label_section()
{
    int label_y = dialog_y + 100;
    int label_x = dialog_x + 20;
    int input_x = dialog_x + 100;
    int input_width = dialog_width - 120;
    int input_height = 28;
    
    //标签文字
    settextstyle(14, 0, L"微软雅黑");
    settextcolor(RGB(180, 180, 180));
    setbkmode(TRANSPARENT);
    outtextxy(label_x, label_y + 6, L"标签：");
    
    //输入框
    setfillcolor(RGB(60, 60, 60));
    solidroundrect(input_x, label_y, input_x + input_width, label_y + input_height, 5, 5);
    
    if (is_editing_label)
    {
        setlinecolor(RGB(192, 123, 62));
        setlinestyle(PS_SOLID, 1);
        roundrect(input_x, label_y, input_x + input_width, label_y + input_height, 5, 5);
    }
    
    if (label_input.empty())
    {
        settextcolor(RGB(86, 86, 86));
        outtextxy(input_x + 8, label_y + 6, L"计时器");
    }
    else
    {
        settextcolor(RGB(221, 221, 221));
        outtextxy(input_x + 8, label_y + 6, label_input.c_str());
    }
}

void CustomTimerDialog::draw_ringtone_section()
{
    int ringtone_y = dialog_y + 140;
    int label_x = dialog_x + 20;
    int input_x = dialog_x + 100;
    int input_width = dialog_width - 120;
    int input_height = 28;
    
    //标签文字（与"标签："的冒号对齐）
    settextstyle(14, 0, L"微软雅黑");
    settextcolor(RGB(180, 180, 180));
    setbkmode(TRANSPARENT);
    outtextxy(label_x - 56, ringtone_y + 6, L"计时结束时启用：");
    
    //选择框
    setfillcolor(RGB(60, 60, 60));
    solidroundrect(input_x, ringtone_y, input_x + input_width, ringtone_y + input_height, 5, 5);
    
    settextcolor(RGB(221, 221, 221));
    outtextxy(input_x + 8, ringtone_y + 6, ringtone_name.c_str());
    
    settextcolor(RGB(150, 150, 150));
    outtextxy(input_x + input_width - 20, ringtone_y + 6, L"▼");
    
    ringtone_menu_y = ringtone_y + input_height + 5;
}

void CustomTimerDialog::draw_buttons()
{
    int button_y = dialog_y + dialog_height - 50;
    int button_width = 100;
    int button_height = 32;
    int spacing = 20;
    
    int cancel_x = dialog_x + dialog_width / 2 - button_width - spacing / 2;
    int start_x = dialog_x + dialog_width / 2 + spacing / 2;
    
    //取消按钮
    setfillcolor(RGB(39, 39, 39));
    solidroundrect(cancel_x, button_y, cancel_x + button_width, button_y + button_height, 
                   button_height / 2, button_height / 2);
    
    settextstyle(14, 0, L"微软雅黑");
    settextcolor(RGB(92, 92, 92));
    setbkmode(TRANSPARENT);
    wstring cancel_text = L"取消";
    int cancel_text_width = textwidth(cancel_text.c_str());
    outtextxy(cancel_x + (button_width - cancel_text_width) / 2, button_y + 8, cancel_text.c_str());
    
    //开始计时按钮
    bool can_start = (hours > 0 || minutes > 0 || seconds > 0);
    
    if (can_start)
    {
        setfillcolor(RGB(104, 206, 103));
        settextcolor(RGB(255, 255, 255));
    }
    else
    {
        setfillcolor(RGB(34, 39, 34));
        settextcolor(RGB(92, 92, 92));
    }
    
    solidroundrect(start_x, button_y, start_x + button_width, button_y + button_height,
                   button_height / 2, button_height / 2);
    
    wstring start_text = L"开始计时";
    int start_text_width = textwidth(start_text.c_str());
    outtextxy(start_x + (button_width - start_text_width) / 2, button_y + 8, start_text.c_str());
}

void CustomTimerDialog::draw_ringtone_menu()
{
    int menu_x = dialog_x + 100;
    int menu_width = dialog_width - 120;
    int item_height = 30;
    int menu_height = min(ringtone_count * item_height, 150);
    
    setfillcolor(RGB(60, 60, 60));
    solidroundrect(menu_x, ringtone_menu_y, menu_x + menu_width, ringtone_menu_y + menu_height, 5, 5);
    
    setlinecolor(RGB(100, 100, 100));
    setlinestyle(PS_SOLID, 1);
    roundrect(menu_x, ringtone_menu_y, menu_x + menu_width, ringtone_menu_y + menu_height, 5, 5);
    
    HDC hdc = GetImageHDC(NULL);
    HRGN clip_region = CreateRectRgn(menu_x, ringtone_menu_y, menu_x + menu_width, ringtone_menu_y + menu_height);
    SelectClipRgn(hdc, clip_region);
    
    for (int i = 0; i < ringtone_count; i++)
    {
        int item_y = ringtone_menu_y + i * item_height + ringtone_scroll_offset;
        
        if (item_y + item_height < ringtone_menu_y || item_y > ringtone_menu_y + menu_height)
            continue;
        
        if (i == ringtone_hovered_index)
        {
            setfillcolor(RGB(80, 80, 80));
            solidrectangle(menu_x + 2, item_y + 2, menu_x + menu_width - 2, item_y + item_height - 2);
        }
        
        settextcolor(WHITE);
        settextstyle(14, 0, L"微软雅黑");
        setbkmode(TRANSPARENT);
        outtextxy(menu_x + 10, item_y + 7, ringtone_list[i].display_name.c_str());
    }
    
    SelectClipRgn(hdc, NULL);
    DeleteObject(clip_region);
}

bool CustomTimerDialog::handle_mouse_click(int mouse_x, int mouse_y)
{
    if (!is_visible) return false;
    
    //处理铃声菜单点击
    if (show_ringtone_menu)
    {
        int menu_x = dialog_x + 100;
        int menu_width = dialog_width - 120;
        int item_height = 30;
        int menu_height = min(ringtone_count * item_height, 150);
        
        if (mouse_x >= menu_x && mouse_x <= menu_x + menu_width && mouse_y >= ringtone_menu_y && mouse_y <= ringtone_menu_y + menu_height)
        {
            int relative_y = mouse_y - ringtone_menu_y - ringtone_scroll_offset;
            int index = relative_y / item_height;
            
            if (index >= 0 && index < ringtone_count)
            {
                ringtone_name = ringtone_list[index].display_name;
                show_ringtone_menu = false;
                return true;
            }
        }
        else
        {
            show_ringtone_menu = false;
            return true;
        }
    }
    
    //检查对话框外点击
    if (mouse_x < dialog_x || mouse_x > dialog_x + dialog_width || mouse_y < dialog_y || mouse_y > dialog_y + dialog_height)
    {
        hide();
        return true;
    }
    
    //检查时间数字点击
    int time_y = dialog_y + 25;
    int digits_y = time_y + 20;
    int digit_width = 45;
    int colon_width = 15;
    int total_width = digit_width * 3 + colon_width * 2;
    int start_x = dialog_x + (dialog_width - total_width) / 2;
    
    if (mouse_y >= digits_y - 2 && mouse_y <= digits_y + 42)
    {
        if (mouse_x >= start_x - 2 && mouse_x <= start_x + digit_width + 2)
        {
            current_focus = TIMER_FOCUS_HOUR;
            is_editing_label = false;
            hour_input_buffer = -1;
            return true;
        }
        else if (mouse_x >= start_x + digit_width + colon_width - 2 && mouse_x <= start_x + digit_width * 2 + colon_width + 2)
        {
            current_focus = TIMER_FOCUS_MINUTE;
            is_editing_label = false;
            minute_input_buffer = -1;
            return true;
        }
        else if (mouse_x >= start_x + digit_width * 2 + colon_width * 2 - 2 && mouse_x <= start_x + digit_width * 3 + colon_width * 2 + 2)
        {
            current_focus = TIMER_FOCUS_SECOND;
            is_editing_label = false;
            second_input_buffer = -1;
            return true;
        }
    }
    
    //检查标签输入框点击
    int label_y = dialog_y + 100;
    int input_x = dialog_x + 100;
    int input_width = dialog_width - 120;
    int input_height = 28;
    
    if (mouse_x >= input_x && mouse_x <= input_x + input_width && mouse_y >= label_y && mouse_y <= label_y + input_height)
    {
        is_editing_label = true;
        current_focus = TIMER_FOCUS_NONE;
        return true;
    }
    else
    {
        is_editing_label = false;
    }
    
    //检查铃声选择框点击
    int ringtone_y = dialog_y + 140;
    
    if (mouse_x >= input_x && mouse_x <= input_x + input_width && mouse_y >= ringtone_y && mouse_y <= ringtone_y + input_height)
    {
        show_ringtone_menu = !show_ringtone_menu;
        ringtone_scroll_offset = 0;
        return true;
    }
    
    //检查按钮点击
    int button_y = dialog_y + dialog_height - 50;
    int button_width = 100;
    int button_height = 32;
    int spacing = 20;
    
    int cancel_x = dialog_x + dialog_width / 2 - button_width - spacing / 2;
    int start_btn_x = dialog_x + dialog_width / 2 + spacing / 2;
    
    if (mouse_y >= button_y && mouse_y <= button_y + button_height)
    {
        if (mouse_x >= cancel_x && mouse_x <= cancel_x + button_width)
        {
            hide();
            return true;
        }
        else if (mouse_x >= start_btn_x && mouse_x <= start_btn_x + button_width)
        {
            bool can_start = (hours > 0 || minutes > 0 || seconds > 0);
            if (can_start)
            {
                is_confirmed = true;
                result_timer.hours = hours;
                result_timer.minutes = minutes;
                result_timer.seconds = seconds;
                result_timer.label = label_input.empty() ? L"计时器" : label_input;
                result_timer.ringtone_name = ringtone_name;
                hide();
                return true;
            }
        }
    }
    
    return true;
}

void CustomTimerDialog::handle_mouse_move(int mouse_x, int mouse_y)
{
    if (!is_visible || !show_ringtone_menu) return;
    
    int menu_x = dialog_x + 100;
    int menu_width = dialog_width - 120;
    int item_height = 30;
    int menu_height = min(ringtone_count * item_height, 150);
    
    ringtone_hovered_index = -1;
    
    if (mouse_x >= menu_x && mouse_x <= menu_x + menu_width &&
        mouse_y >= ringtone_menu_y && mouse_y <= ringtone_menu_y + menu_height)
    {
        int relative_y = mouse_y - ringtone_menu_y - ringtone_scroll_offset;
        ringtone_hovered_index = relative_y / item_height;
        
        if (ringtone_hovered_index < 0 || ringtone_hovered_index >= ringtone_count)
        {
            ringtone_hovered_index = -1;
        }
    }
}

void CustomTimerDialog::handle_mouse_wheel(int delta)
{
    if (!is_visible || !show_ringtone_menu) return;
    
    int item_height = 30;
    int menu_height = min(ringtone_count * item_height, 150);
    int max_scroll = ringtone_count * item_height - menu_height;
    
    ringtone_scroll_offset += delta / 2;
    
    if (ringtone_scroll_offset > 0) ringtone_scroll_offset = 0;
    if (ringtone_scroll_offset < -max_scroll) ringtone_scroll_offset = -max_scroll;
}

void CustomTimerDialog::process_virtual_key(int vk)
{
    if (!is_visible) return;
    
    if (vk == VK_ESCAPE)
    {
        hide();
        return;
    }
    
    if (vk == VK_BACK)
    {
        if (is_editing_label && !label_input.empty())
        {
            label_input.pop_back();
        }
        return;
    }
    
    if ((vk == VK_UP || vk == VK_DOWN) && current_focus != TIMER_FOCUS_NONE && !is_editing_label)
    {
        bool is_up = (vk == VK_UP);
        
        if (current_focus == TIMER_FOCUS_HOUR)
        {
            if (is_up) { hours++; if (hours > 99) hours = 0; }
            else { hours--; if (hours < 0) hours = 99; }
            hour_input_buffer = -1;
        }
        else if (current_focus == TIMER_FOCUS_MINUTE)
        {
            if (is_up) { minutes++; if (minutes > 59) minutes = 0; }
            else { minutes--; if (minutes < 0) minutes = 59; }
            minute_input_buffer = -1;
        }
        else if (current_focus == TIMER_FOCUS_SECOND)
        {
            if (is_up) { seconds++; if (seconds > 59) seconds = 0; }
            else { seconds--; if (seconds < 0) seconds = 59; }
            second_input_buffer = -1;
        }
        return;
    }
    
    int digit = -1;
    if (vk >= '0' && vk <= '9') digit = vk - '0';
    else if (vk >= VK_NUMPAD0 && vk <= VK_NUMPAD9) digit = vk - VK_NUMPAD0;
    
    if (digit >= 0 && current_focus != TIMER_FOCUS_NONE && !is_editing_label)
    {
        time_t now = time(0);
        
        if (current_focus == TIMER_FOCUS_HOUR)
        {
            if (hour_input_buffer == -1 || (now - last_input_time) >= 1)
            {
                hour_input_buffer = digit;
                last_input_time = now;
                hours = digit;
            }
            else
            {
                int combined = hour_input_buffer * 10 + digit;
                if (combined >= 0 && combined <= 99)
                {
                    hours = combined;
                    hour_input_buffer = -1;
                }
                else
                {
                    hour_input_buffer = digit;
                    last_input_time = now;
                    hours = digit;
                }
            }
        }
        else if (current_focus == TIMER_FOCUS_MINUTE)
        {
            if (minute_input_buffer == -1 || (now - last_input_time) >= 1)
            {
                minute_input_buffer = digit;
                last_input_time = now;
                minutes = digit;
            }
            else
            {
                int combined = minute_input_buffer * 10 + digit;
                if (combined >= 0 && combined <= 59)
                {
                    minutes = combined;
                    minute_input_buffer = -1;
                }
                else
                {
                    minute_input_buffer = digit;
                    last_input_time = now;
                    minutes = digit;
                }
            }
        }
        else if (current_focus == TIMER_FOCUS_SECOND)
        {
            if (second_input_buffer == -1 || (now - last_input_time) >= 1)
            {
                second_input_buffer = digit;
                last_input_time = now;
                seconds = digit;
            }
            else
            {
                int combined = second_input_buffer * 10 + digit;
                if (combined >= 0 && combined <= 59)
                {
                    seconds = combined;
                    second_input_buffer = -1;
                }
                else
                {
                    second_input_buffer = digit;
                    last_input_time = now;
                    seconds = digit;
                }
            }
        }
        return;
    }
    
    if (vk == VK_SPACE && is_editing_label)
    {
        label_input += L' ';
        return;
    }
    
    if (is_editing_label && vk >= 'A' && vk <= 'Z')
    {
        bool shift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
        wchar_t ch = (wchar_t)(shift ? vk : (vk - 'A' + 'a'));
        label_input += ch;
        return;
    }
}

Timer CustomTimerDialog::get_timer()
{
    return result_timer;
}

//到552左右是构造函数和铃声菜单
//铃声选择菜单实现
TimerRingtoneMenu::TimerRingtoneMenu()
{
    menu_width = 250;
    item_height = 40;
    hovered_index = -1;
    scroll_offset = 0;
    
    AlarmSound::get_all_ringtones(&ringtone_list, ringtone_count);
    
    int max_height = (680 - 60) * 3 / 4;
    int full_height = ringtone_count * item_height;
    
    if (full_height > max_height)
    {
        menu_height = max_height;
        can_scroll = true;
    }
    else
    {
        menu_height = full_height;
        can_scroll = false;
    }
}

TimerRingtoneMenu::~TimerRingtoneMenu()
{
    if (ringtone_list != nullptr)
    {
        delete[] ringtone_list;
    }
}

void TimerRingtoneMenu::show(int x, int y)
{
    menu_x = x;
    menu_y = y;
    
    if (menu_x + menu_width > 520)
    {
        menu_x = 520 - menu_width;
    }
    if (menu_y + menu_height > 680)
    {
        menu_y = 680 - menu_height;
    }
}

void TimerRingtoneMenu::draw()
{
    setfillcolor(RGB(60, 60, 60));
    solidroundrect(menu_x, menu_y, menu_x + menu_width, menu_y + menu_height, 5, 5);
    
    setlinecolor(RGB(100, 100, 100));
    setlinestyle(PS_SOLID, 1);  //确保边框细
    roundrect(menu_x, menu_y, menu_x + menu_width, menu_y + menu_height, 5, 5);
    
    HDC hdc = GetImageHDC(NULL);
    HRGN clip_region = CreateRectRgn(menu_x, menu_y, menu_x + menu_width, menu_y + menu_height);
    SelectClipRgn(hdc, clip_region);
    
    for (int i = 0; i < ringtone_count; i++)
    {
        int item_y = menu_y + i * item_height + scroll_offset;
        
        if (item_y + item_height < menu_y || item_y > menu_y + menu_height)
        {
            continue;
        }
        
        if (i == hovered_index)
        {
            setfillcolor(RGB(80, 80, 80));
            solidrectangle(menu_x + 2, item_y + 2, menu_x + menu_width - 2, item_y + item_height - 2);
        }
        
        settextcolor(WHITE);
        settextstyle(16, 0, L"微软雅黑");
        setbkmode(TRANSPARENT);
        outtextxy(menu_x + 15, item_y + 10, ringtone_list[i].display_name.c_str());
    }
    
    SelectClipRgn(hdc, NULL);
    DeleteObject(clip_region);
}

void TimerRingtoneMenu::update_hover(int mouse_x, int mouse_y)
{
    hovered_index = -1;
    
    if (mouse_x < menu_x || mouse_x > menu_x + menu_width || mouse_y < menu_y || mouse_y > menu_y + menu_height)
    {
        return;
    }
    
    int relative_y = mouse_y - menu_y - scroll_offset;
    hovered_index = relative_y / item_height;
    
    if (hovered_index < 0 || hovered_index >= ringtone_count)
    {
        hovered_index = -1;
    }
}

int TimerRingtoneMenu::check_click(int mouse_x, int mouse_y)
{
    if (mouse_x < menu_x || mouse_x > menu_x + menu_width || mouse_y < menu_y || mouse_y > menu_y + menu_height)
    {
        return -1;
    }
    
    int relative_y = mouse_y - menu_y - scroll_offset;
    int index = relative_y / item_height;
    
    if (index >= 0 && index < ringtone_count)
    {
        return index;
    }
    
    return -1;
}

bool TimerRingtoneMenu::is_outside_click(int mouse_x, int mouse_y)
{
    return (mouse_x < menu_x || mouse_x > menu_x + menu_width || mouse_y < menu_y || mouse_y > menu_y + menu_height);
}

void TimerRingtoneMenu::scroll(int delta)
{
    if (!can_scroll) return;
    
    scroll_offset += delta;
    
    int max_scroll = 0;
    int min_scroll = -(ringtone_count * item_height - menu_height);
    
    if (scroll_offset > max_scroll) scroll_offset = max_scroll;
    if (scroll_offset < min_scroll) scroll_offset = min_scroll;
}

//加号菜单实现
TimerAddMenu::TimerAddMenu()
{
    menu_width = 180;
    item_height = 40;
    hovered_index = -1;
    show_preset_submenu = false;
    preset_hovered_index = -1;
    
    //初始化预置项
    preset_items.push_back(PresetMenuItem(L"1分钟", 1));
    preset_items.push_back(PresetMenuItem(L"2分钟", 2));
    preset_items.push_back(PresetMenuItem(L"3分钟", 3));
    preset_items.push_back(PresetMenuItem(L"4分钟", 4));
    preset_items.push_back(PresetMenuItem(L"5分钟", 5));
    preset_items.push_back(PresetMenuItem(L"10分钟", 10));
    preset_items.push_back(PresetMenuItem(L"15分钟", 15));
    preset_items.push_back(PresetMenuItem(L"20分钟", 20));
    preset_items.push_back(PresetMenuItem(L"30分钟", 30));
    preset_items.push_back(PresetMenuItem(L"45分钟", 45));
    preset_items.push_back(PresetMenuItem(L"1小时", 60));
    preset_items.push_back(PresetMenuItem(L"2小时", 120));
    
    preset_menu_width = 120;
    preset_menu_height = preset_items.size() * item_height;
}

TimerAddMenu::~TimerAddMenu()
{
}

void TimerAddMenu::show(int x, int y, const vector<Timer>& recent_timers)
{
    menu_x = x;
    menu_y = y;
    
    //清空菜单项
    menu_items.clear();
    
    //添加"自定义计时器"
    AddMenuItem custom_item;
    custom_item.type = MENU_CUSTOM;
    custom_item.text = L"自定义计时器";
    custom_item.menu_index = 0;
    menu_items.push_back(custom_item);
    
    //添加分隔线
    AddMenuItem sep1;
    sep1.type = MENU_SEPARATOR;
    sep1.menu_index = 1;
    menu_items.push_back(sep1);
    
    //添加"预置"
    AddMenuItem preset_item;
    preset_item.type = MENU_PRESET_TITLE;
    preset_item.text = L"预置";
    preset_item.menu_index = 2;
    menu_items.push_back(preset_item);
    
    //如果有最近使用，添加标题和项
    if (!recent_timers.empty())
    {
        AddMenuItem recent_title;
        recent_title.type = MENU_RECENT_TITLE;
        recent_title.text = L"最近使用";
        recent_title.menu_index = 3;
        menu_items.push_back(recent_title);
        
        for (size_t i = 0; i < recent_timers.size(); i++)
        {
            AddMenuItem recent_item;
            recent_item.type = MENU_RECENT_ITEM;
            recent_item.timer = recent_timers[i];
            recent_item.text = recent_timers[i].get_time_string();
            recent_item.menu_index = 4 + i;
            menu_items.push_back(recent_item);
        }
    }
    
    //计算菜单高度
    menu_height = 0;
    for (size_t i = 0; i < menu_items.size(); i++)
    {
        if (menu_items[i].type == MENU_SEPARATOR)
        {
            menu_height += 1;
        }
        else if (menu_items[i].type == MENU_RECENT_TITLE)
        {
            menu_height += 30;  //最近使用标题更小
        }
        else
        {
            menu_height += item_height;
        }
    }
    
    //调整位置
    if (menu_x + menu_width > 520)
    {
        menu_x = 520 - menu_width - 5;
    }
    if (menu_y + menu_height > 680)
    {
        menu_y = 680 - menu_height;
    }
}

void TimerAddMenu::draw()
{
    //绘制主菜单背景
    setfillcolor(RGB(60, 60, 60));
    solidroundrect(menu_x, menu_y, menu_x + menu_width, menu_y + menu_height, 5, 5);
    
    setlinecolor(RGB(100, 100, 100));
    setlinestyle(PS_SOLID, 1);  //确保边框细
    roundrect(menu_x, menu_y, menu_x + menu_width, menu_y + menu_height, 5, 5);
    
    //绘制菜单项
    int current_y = menu_y;
    for (size_t i = 0; i < menu_items.size(); i++)
    {
        if (menu_items[i].type == MENU_SEPARATOR)
        {
            //绘制分隔线
            setlinecolor(RGB(100, 100, 100));
            setlinestyle(PS_SOLID, 1);
            line(menu_x + 10, current_y, menu_x + menu_width - 10, current_y);
            current_y += 1;
        }
        else if (menu_items[i].type == MENU_RECENT_TITLE)
        {
            //在最近使用标题前绘制分隔线（预置和最近使用之间）
            setlinecolor(RGB(100, 100, 100));
            setlinestyle(PS_SOLID, 1);
            line(menu_x + 10, current_y, menu_x + menu_width - 10, current_y);
            current_y += 1;
            
            //绘制"最近使用"标题（更小的字体，灰色，居左）
            settextcolor(RGB(84, 84, 84));
            settextstyle(12, 0, L"微软雅黑");
            setbkmode(TRANSPARENT);
            outtextxy(menu_x + 15, current_y + 8, menu_items[i].text.c_str());
            current_y += 30;
        }
        else
        {
            int item_height_actual = item_height;
            
            //绘制悬停背景
            if (menu_items[i].is_hovered)
            {
                setfillcolor(RGB(233, 150, 91));
                solidroundrect(menu_x + 2, current_y + 2, menu_x + menu_width - 2, current_y + item_height_actual - 2, 5, 5);
            }
            
            //绘制文字
            settextcolor(WHITE);
            settextstyle(16, 0, L"微软雅黑");
            setbkmode(TRANSPARENT);
            outtextxy(menu_x + 15, current_y + 10, menu_items[i].text.c_str());
            
            //如果是预置项，绘制箭头
            if (menu_items[i].type == MENU_PRESET_TITLE)
            {
                settextcolor(RGB(150, 150, 150));
                outtextxy(menu_x + menu_width - 25, current_y + 10, L"▶");
            }
            
            current_y += item_height_actual;
        }
    }
    
    //绘制预置子菜单
    if (show_preset_submenu)
    {
        setfillcolor(RGB(60, 60, 60));
        solidroundrect(preset_menu_x, preset_menu_y, preset_menu_x + preset_menu_width, preset_menu_y + preset_menu_height, 5, 5);
        
        setlinecolor(RGB(100, 100, 100));
        setlinestyle(PS_SOLID, 1);  //确保边框细
        roundrect(preset_menu_x, preset_menu_y, preset_menu_x + preset_menu_width, preset_menu_y + preset_menu_height, 5, 5);
        
        for (size_t i = 0; i < preset_items.size(); i++)
        {
            int item_y = preset_menu_y + i * item_height;
            
            if (preset_items[i].is_hovered)
            {
                setfillcolor(RGB(233, 150, 91));
                solidroundrect(preset_menu_x + 2, item_y + 2, preset_menu_x + preset_menu_width - 2, item_y + item_height - 2, 5, 5);
            }
            
            settextcolor(WHITE);
            settextstyle(16, 0, L"微软雅黑");
            setbkmode(TRANSPARENT);
            outtextxy(preset_menu_x + 15, item_y + 10, preset_items[i].text.c_str());
        }
    }
}

void TimerAddMenu::update_hover(int mouse_x, int mouse_y)
{
    //重置所有悬停状态
    for (size_t i = 0; i < menu_items.size(); i++)
    {
        menu_items[i].is_hovered = false;
    }
    
    //重置所有预置项悬停状态
    for (size_t i = 0; i < preset_items.size(); i++)
    {
        preset_items[i].is_hovered = false;
    }
    
    hovered_index = -1;
    preset_hovered_index = -1;
    
    //检查预置子菜单悬停
    if (show_preset_submenu)
    {
        if (mouse_x >= preset_menu_x && mouse_x <= preset_menu_x + preset_menu_width && mouse_y >= preset_menu_y && mouse_y <= preset_menu_y + preset_menu_height)
        {
            int relative_y = mouse_y - preset_menu_y;
            preset_hovered_index = relative_y / item_height;
            
            if (preset_hovered_index >= 0 && preset_hovered_index < (int)preset_items.size())
            {
                preset_items[preset_hovered_index].is_hovered = true;
            }
            return;
        }
    }
    
    //检查主菜单悬停
    if (mouse_x < menu_x || mouse_x > menu_x + menu_width || mouse_y < menu_y || mouse_y > menu_y + menu_height)
    {
        show_preset_submenu = false;
        return;
    }
    
    int current_y = menu_y;
    for (size_t i = 0; i < menu_items.size(); i++)
    {
        int item_height_actual = item_height;
        if (menu_items[i].type == MENU_SEPARATOR)
        {
            current_y += 1;
            continue;
        }
        if (menu_items[i].type == MENU_RECENT_TITLE)
        {
            current_y += 30;
            continue;
        }
        
        if (mouse_y >= current_y && mouse_y < current_y + item_height_actual)
        {
            menu_items[i].is_hovered = true;
            hovered_index = i;
            
            //如果悬停在"预置"上，显示子菜单
            if (menu_items[i].type == MENU_PRESET_TITLE)
            {
                show_preset_submenu = true;
                preset_menu_x = menu_x + menu_width;
                preset_menu_y = current_y;
                
                //调整子菜单位置
                if (preset_menu_x + preset_menu_width > 520)
                {
                    preset_menu_x = menu_x - preset_menu_width;
                }
                if (preset_menu_y + preset_menu_height > 680)
                {
                    preset_menu_y = 680 - preset_menu_height;
                }
            }
            else
            {
                show_preset_submenu = false;
            }
            
            break;
        }
        
        current_y += item_height_actual;
    }
}

int TimerAddMenu::check_click(int mouse_x, int mouse_y, int& preset_minutes, Timer& recent_timer, bool& is_custom)
{
    preset_minutes = 0;
    is_custom = false;
    
    //检查预置子菜单点击
    if (show_preset_submenu)
    {
        if (mouse_x >= preset_menu_x && mouse_x <= preset_menu_x + preset_menu_width && mouse_y >= preset_menu_y && mouse_y <= preset_menu_y + preset_menu_height)
        {
            int relative_y = mouse_y - preset_menu_y;
            int index = relative_y / item_height;
            
            if (index >= 0 && index < (int)preset_items.size())
            {
                preset_minutes = preset_items[index].minutes;
                return 1;  //返回预置类型
            }
        }
    }
    
    //检查主菜单点击
    if (mouse_x < menu_x || mouse_x > menu_x + menu_width || mouse_y < menu_y || mouse_y > menu_y + menu_height)
    {
        return -1;
    }
    
    int current_y = menu_y;
    for (size_t i = 0; i < menu_items.size(); i++)
    {
        int item_height_actual = item_height;
        if (menu_items[i].type == MENU_SEPARATOR)
        {
            current_y += 1;
            continue;
        }
        if (menu_items[i].type == MENU_RECENT_TITLE)
        {
            current_y += 30;
            continue;
        }
        
        if (mouse_y >= current_y && mouse_y < current_y + item_height_actual)
        {
            if (menu_items[i].type == MENU_CUSTOM)
            {
                is_custom = true;
                return 2;  //返回自定义类型
            }
            else if (menu_items[i].type == MENU_RECENT_ITEM)
            {
                recent_timer = menu_items[i].timer;
                return 3;  //返回最近使用类型
            }
            else if (menu_items[i].type == MENU_PRESET_TITLE)
            {
                //点击预置不做任何事，只显示子菜单
                return -1;
            }
        }
        
        current_y += item_height_actual;
    }
    
    return -1;
}

bool TimerAddMenu::is_outside_click(int mouse_x, int mouse_y)
{
    bool outside_main = (mouse_x < menu_x || mouse_x > menu_x + menu_width || mouse_y < menu_y || mouse_y > menu_y + menu_height);
    
    if (show_preset_submenu)
    {
        bool outside_preset = (mouse_x < preset_menu_x || mouse_x > preset_menu_x + preset_menu_width || mouse_y < preset_menu_y || mouse_y > preset_menu_y + preset_menu_height);
        return outside_main && outside_preset;
    }
    
    return outside_main;
}

//计时器管理器实现
TimerManager::TimerManager()
{
    hours = 0;
    minutes = 0;
    seconds = 0;
    label = L"计时器";
    ringtone_name = L"做个文明中国人";
    
    current_focus = TIMER_FOCUS_NONE;
    
    hour_input_buffer = -1;
    minute_input_buffer = -1;
    second_input_buffer = -1;
    last_input_time = 0;
    
    show_ringtone_menu = false;
    ringtone_menu = nullptr;
    
    label_input = L"";
    is_editing_label = false;
    
    has_running_timer = false;
    next_timer_id = 1;
    scroll_offset = 0;
}

TimerManager::~TimerManager()
{
    if (ringtone_menu != nullptr)
    {
        delete ringtone_menu;
    }
}

//到1088左右是绘制方法
void TimerManager::draw_default_page()
{
    //设置裁剪区域（导航栏以下）
    HDC hdc = GetImageHDC(NULL);
    HRGN clip_region = CreateRectRgn(0, 60, 520, 680);
    SelectClipRgn(hdc, clip_region);
    
    //所有内容都加上scroll_offset，实现整体滚动
    draw_time_digits();
    draw_label_input_box();
    draw_ringtone_selector();
    draw_action_buttons();
    draw_recent_timers_section();
    
    SelectClipRgn(hdc, NULL);
    DeleteObject(clip_region);
}

void TimerManager::draw_time_digits()
{
    //距离窗口上沿6cm（≈228px）是数字的上端
    int digits_y = 228 + scroll_offset;

    //数字高度1.8cm（≈68px）
    settextstyle(68, 0, L"微软雅黑");

    //格式化时间字符串
    wstringstream wss;
    wss << setfill(L'0') << setw(2) << hours << L":"
        << setw(2) << minutes << L":"
        << setw(2) << seconds;
    wstring time_text = wss.str();

    //计算总宽度（应该是8.8cm ≈ 334px）
    int total_width = textwidth(time_text.c_str());
    int start_x = (520 - total_width) / 2;

    //计算每个数字对的宽度
    wstring hour_str = (hours < 10 ? L"0" : L"") + to_wstring(hours);
    wstring minute_str = (minutes < 10 ? L"0" : L"") + to_wstring(minutes);
    wstring second_str = (seconds < 10 ? L"0" : L"") + to_wstring(seconds);

    int hour_width = textwidth(hour_str.c_str());
    int colon_width = textwidth(L":");
    int minute_width = textwidth(minute_str.c_str());
    int second_width = textwidth(second_str.c_str());

    int hour_x = start_x;
    int colon1_x = hour_x + hour_width;
    int minute_x = colon1_x + colon_width;
    int colon2_x = minute_x + minute_width;
    int second_x = colon2_x + colon_width;

    //绘制小时上方的"小时"标签
    settextstyle(14, 0, L"微软雅黑");
    settextcolor(RGB(154, 154, 154));
    setbkmode(TRANSPARENT);
    wstring hour_label = L"小时";
    int hour_label_width = textwidth(hour_label.c_str());
    outtextxy(hour_x + (hour_width - hour_label_width) / 2, digits_y - 20, hour_label.c_str());

    //绘制分钟上方的"分钟"标签
    wstring minute_label = L"分钟";
    int minute_label_width = textwidth(minute_label.c_str());
    outtextxy(minute_x + (minute_width - minute_label_width) / 2, digits_y - 20, minute_label.c_str());

    //绘制秒上方的"秒"标签
    wstring second_label = L"秒";
    int second_label_width = textwidth(second_label.c_str());
    outtextxy(second_x + (second_width - second_label_width) / 2, digits_y - 20, second_label.c_str());

    //绘制小时背景（如果选中）
    settextstyle(68, 0, L"微软雅黑");
    if (current_focus == TIMER_FOCUS_HOUR)
    {
        setfillcolor(RGB(192, 123, 62));
        solidroundrect(hour_x - 5, digits_y - 5, colon1_x, digits_y + 68, 8, 8);
    }

    //绘制分钟背景（如果选中）
    if (current_focus == TIMER_FOCUS_MINUTE)
    {
        setfillcolor(RGB(192, 123, 62));
        solidroundrect(minute_x, digits_y - 5, colon2_x, digits_y + 68, 8, 8);
    }

    //绘制秒背景（如果选中）
    if (current_focus == TIMER_FOCUS_SECOND)
    {
        setfillcolor(RGB(192, 123, 62));
        solidroundrect(second_x, digits_y - 5, second_x + second_width + 5, digits_y + 68, 8, 8);
    }

    //绘制数字
    settextcolor(RGB(221, 221, 221));
    outtextxy(start_x, digits_y, time_text.c_str());
}

void TimerManager::draw_label_input_box()
{
    //时间数字再往下是输入框
    int input_y = 228 + 68 + 30 + scroll_offset;  
    int input_x = 100;
    int input_width = 320;
    int input_height = 35;

    //绘制输入框背景
    setfillcolor(RGB(50, 50, 50));
    solidroundrect(input_x, input_y, input_x + input_width, input_y + input_height, 5, 5);

    //如果正在编辑，绘制边框
    if (is_editing_label)
    {
        setlinecolor(RGB(192, 123, 62));
        setlinestyle(PS_SOLID, 2);
        roundrect(input_x, input_y, input_x + input_width, input_y + input_height, 5, 5);
    }

    //绘制文字
    settextstyle(16, 0, L"微软雅黑");
    setbkmode(TRANSPARENT);

    if (label_input.empty() && !is_editing_label)
    {
        settextcolor(RGB(154, 154, 154));
        outtextxy(input_x + 10, input_y + 8, L"计时器");
    }
    else
    {
        settextcolor(RGB(221, 221, 221));
        wstring display_text = label_input.empty() ? L"计时器" : label_input;
        outtextxy(input_x + 10, input_y + 8, display_text.c_str());
    }
}

void TimerManager::draw_ringtone_selector()
{
    //输入框再往下是铃声选择框
    int selector_y = 228 + 68 + 30 + 35 + 20 + scroll_offset;
    int selector_x = 100;
    int selector_width = 320;
    int selector_height = 35;

    //绘制选择框背景
    setfillcolor(RGB(50, 50, 50));
    solidroundrect(selector_x, selector_y, selector_x + selector_width, selector_y + selector_height, 5, 5);

    //绘制当前选择
    settextstyle(16, 0, L"微软雅黑");
    settextcolor(RGB(221, 221, 221));
    setbkmode(TRANSPARENT);
    outtextxy(selector_x + 10, selector_y + 8, ringtone_name.c_str());

    //绘制下拉箭头
    settextcolor(RGB(150, 150, 150));
    outtextxy(selector_x + selector_width - 25, selector_y + 8, L"▼");
}

void TimerManager::draw_action_buttons()
{
    //按钮的下沿距离窗口下沿3.3cm（≈125px），距离上沿12.8cm（≈486px）
    int button_y = 486 + scroll_offset;
    int button_height = 40;
    int button_width = 140;
    int spacing = 20;

    int total_width = button_width * 2 + spacing;
    int start_x = (520 - total_width) / 2;

    //取消按钮（左边）
    int cancel_x = start_x;
    setfillcolor(RGB(39, 39, 39));
    solidroundrect(cancel_x, button_y, cancel_x + button_width, button_y + button_height, button_height / 2, button_height / 2);

    settextstyle(16, 0, L"微软雅黑");
    settextcolor(RGB(92, 92, 92));
    setbkmode(TRANSPARENT);
    wstring cancel_text = L"取消";
    int cancel_text_width = textwidth(cancel_text.c_str());
    outtextxy(cancel_x + (button_width - cancel_text_width) / 2, button_y + 10, cancel_text.c_str());

    //开始计时按钮（右边）
    int start_x_btn = start_x + button_width + spacing;
    
    //判断是否可以开始计时（时间不能为0）
    bool can_start = (hours > 0 || minutes > 0 || seconds > 0);
    
    if (can_start)
    {
        setfillcolor(RGB(104, 206, 103));
        solidroundrect(start_x_btn, button_y, start_x_btn + button_width, button_y + button_height, button_height / 2, button_height / 2);
        settextcolor(RGB(255, 255, 255));
    }
    else
    {
        //0时0分0秒时按钮变灰
        setfillcolor(RGB(34, 39, 34));
        solidroundrect(start_x_btn, button_y, start_x_btn + button_width, button_y + button_height, button_height / 2, button_height / 2);
        settextcolor(RGB(92, 92, 92));
    }

    wstring start_text = L"开始计时";
    int start_text_width = textwidth(start_text.c_str());
    outtextxy(start_x_btn + (button_width - start_text_width) / 2, button_y + 10, start_text.c_str());
}

void TimerManager::draw_recent_timers_section()
{
    if (recent_timer_cards.empty())
    {
        return;
    }

    //距离窗口下沿2cm（≈76px）处显示"最近使用"，加上滚动偏移
    int recent_title_y = 680 - 76 + scroll_offset;

    settextstyle(18, 0, L"微软雅黑");
    settextcolor(RGB(254, 254, 254));
    setbkmode(TRANSPARENT);
    outtextxy(20, recent_title_y, L"最近使用");

    //绘制卡片（不再需要额外的裁剪区域，因为整个页面已经设置了裁剪）
    for (size_t i = 0; i < recent_timer_cards.size(); i++)
    {
        int x, y;
        calculate_recent_card_position(i, x, y);

        recent_timer_cards[i].card_x = x;
        recent_timer_cards[i].card_y = y;

        //只绘制可见的卡片
        if (y + recent_timer_cards[i].card_height < 60 || y > 680)
        {
            continue;
        }

        draw_recent_timer_card(recent_timer_cards[i]);
    }
}

void TimerManager::draw_recent_timer_card(const RecentTimerCard& card)
{
    //绘制卡片背景（6cm*6cm ≈ 228px*228px）
    setfillcolor(RGB(50, 50, 50));
    solidroundrect(card.card_x, card.card_y,
        card.card_x + card.card_width,
        card.card_y + card.card_height, 10, 10);

    //绘制中心圆（直径3cm ≈ 114px，厚度8px）- 使用抗锯齿圆环
    int circle_center_x = card.card_x + card.card_width / 2;
    int circle_center_y = card.card_y + card.card_height / 2;
    int circle_radius = 57;

    SDF::draw_aa_ring(circle_center_x, circle_center_y, circle_radius, 8, RGB(72, 72, 75));

    //绘制圆内的第一行文字（00:00格式）
    settextstyle(22, 0, L"微软雅黑");
    settextcolor(RGB(162, 162, 162));
    setbkmode(TRANSPARENT);

    wstring time_str = card.timer.get_card_time_string();
    int time_width = textwidth(time_str.c_str());
    outtextxy(circle_center_x - time_width / 2, circle_center_y - 20, time_str.c_str());

    //绘制圆内的第二行文字（中文格式）
    settextstyle(14, 0, L"微软雅黑");
    wstring chinese_str = card.timer.get_chinese_string();
    int chinese_width = textwidth(chinese_str.c_str());
    outtextxy(circle_center_x - chinese_width / 2, circle_center_y + 5, chinese_str.c_str());

    //绘制左下角删除按钮
    int delete_x = card.card_x + 20;
    int delete_y = card.card_y + card.card_height - 20;
    int delete_radius = 12;

    SDF::draw_aa_circle(delete_x, delete_y, delete_radius, RGB(70, 70, 70));

    //绘制叉叉
    int cross_size = 5;
    SDF::draw_aa_line(delete_x - cross_size, delete_y - cross_size,
        delete_x + cross_size, delete_y + cross_size, 2, RGB(128, 128, 128));
    SDF::draw_aa_line(delete_x - cross_size, delete_y + cross_size,
        delete_x + cross_size, delete_y - cross_size, 2, RGB(128, 128, 128));

    //绘制右下角播放按钮
    int play_x = card.card_x + card.card_width - 20;
    int play_y = card.card_y + card.card_height - 20;
    int play_radius = 12;

    SDF::draw_aa_circle(play_x, play_y, play_radius, RGB(65, 94, 65));

    //绘制三角形
    POINT triangle[3];
    triangle[0] = { play_x - 4, play_y - 6 };
    triangle[1] = { play_x - 4, play_y + 6 };
    triangle[2] = { play_x + 6, play_y };

    setfillcolor(RGB(104, 206, 103));
    solidpolygon(triangle, 3);
}

void TimerManager::draw_running_timer_page()
{
    draw_timer_circle();
    draw_timer_time_text();
    draw_end_time_text();
    draw_timer_label_and_ringtone();
    draw_timer_controls();
}

void TimerManager::draw_timer_circle()
{
    //页面居中偏上的大圆，直径8cm（≈304px）
    int circle_center_x = 260;
    int circle_center_y = 250;
    int circle_radius = 152;
    int thickness = 12;

    //计算进度（已过去的比例）
    double progress = 0.0;
    if (running_timer.total_seconds > 0)
    {
        int elapsed_seconds = running_timer.total_seconds - running_timer.remaining_seconds;
        progress = (double)elapsed_seconds / running_timer.total_seconds;
    }

    //绘制背景圆（灰色底色）- 使用抗锯齿圆环
    SDF::draw_aa_ring(circle_center_x, circle_center_y, circle_radius, thickness, RGB(59, 59, 61));

    //绘制剩余时间圆弧（橘色）
    //缺口从12点钟方向顺时针出现
    //随着时间流逝，缺口越来越大（橘色部分越来越少）
    if (progress < 1.0)
    {
        //剩余比例
        double remaining = 1.0 - progress;
        //剩余角度
        double sweep_angle = 360.0 * remaining;
        
        //缺口从12点钟开始顺时针方向扩大
        //所以橘色圆弧的起点需要顺时针移动
        //起点 = -90度 + 已过去的角度
        double start_angle = -90.0 + (360.0 * progress);
        
        SDF::draw_aa_arc(circle_center_x, circle_center_y, circle_radius, thickness, 
                         start_angle, sweep_angle, RGB(240, 151, 72));
    }
}

void TimerManager::draw_timer_time_text()
{
    //圆里面的倒计时时间
    int circle_center_x = 260;
    int circle_center_y = 250;

    int remaining_hours = running_timer.remaining_seconds / 3600;
    int remaining_minutes = (running_timer.remaining_seconds % 3600) / 60;
    int remaining_secs = running_timer.remaining_seconds % 60;

    wstringstream wss;

    if (remaining_hours > 0)
    {
        //显示小时
        settextstyle(60, 0, L"微软雅黑");
        wss << remaining_hours << L":" << setfill(L'0') << setw(2) << remaining_minutes
            << L":" << setw(2) << remaining_secs;
    }
    else if (remaining_minutes > 0)
    {
        //不显示小时，字变大
        settextstyle(70, 0, L"微软雅黑");
        wss << setfill(L'0') << setw(2) << remaining_minutes << L":" << setw(2) << remaining_secs;
    }
    else
    {
        //少于1分钟
        settextstyle(70, 0, L"微软雅黑");
        wss << L"00:" << setfill(L'0') << setw(2) << remaining_secs;
    }

    wstring time_text = wss.str();
    settextcolor(RGB(240, 151, 72));
    setbkmode(TRANSPARENT);

    int time_width = textwidth(time_text.c_str());
    outtextxy(circle_center_x - time_width / 2, circle_center_y - 35, time_text.c_str());
}

void TimerManager::draw_end_time_text()
{
    //时间上面的小字：铃铛 上午/下午 00:00
    int circle_center_x = 260;
    int text_y = 250 - 80;
    
    if (running_timer.is_paused)
    {
        //暂停时变灰
        settextcolor(RGB(52, 52, 52));
    }
    else
    {
        settextcolor(RGB(151, 151, 151));
    }
    
    settextstyle(14, 0, L"微软雅黑");
    setbkmode(TRANSPARENT);
    
    //计算结束时间
    time_t end_time = running_timer.start_time + running_timer.total_seconds;
    if (running_timer.is_paused)
    {
        //暂停时，基于暂停时刻计算
        int elapsed = running_timer.total_seconds - running_timer.remaining_seconds;
        end_time = running_timer.pause_time + running_timer.remaining_seconds;
    }
    
    struct tm end_tm;
    localtime_s(&end_tm, &end_time);
    
    wstringstream wss;
    wss << L"[铃] ";
    
    if (end_tm.tm_hour < 12)
    {
        wss << L"上午 ";
    }
    else
    {
        wss << L"下午 ";
    }
    
    int display_hour = end_tm.tm_hour % 12;
    if (display_hour == 0) display_hour = 12;
    
    wss << display_hour << L":" << setfill(L'0') << setw(2) << end_tm.tm_min;
    
    wstring end_text = wss.str();
    int end_width = textwidth(end_text.c_str());
    outtextxy(circle_center_x - end_width / 2, text_y, end_text.c_str());
}

void TimerManager::draw_timer_label_and_ringtone()
{
    //大圆参数
    int circle_center_x = 260;
    int circle_center_y = 250;
    int circle_radius = 152;
    
    //调整框的大小和位置，使其在圆内
    int box_width = 200;  //缩小宽度
    int box_height = 28;  //缩小高度
    int box_x = circle_center_x - box_width / 2;  //居中
    
    //标签框位置：时间下方
    int label_y = circle_center_y + 30;

    //绘制标签背景
    setfillcolor(RGB(50, 50, 50));
    solidroundrect(box_x, label_y, box_x + box_width, label_y + box_height, 5, 5);

    //绘制标签文字
    settextstyle(14, 0, L"微软雅黑");
    settextcolor(RGB(221, 221, 221));
    setbkmode(TRANSPARENT);

    wstring display_label = running_timer.label.empty() ? L"计时器" : running_timer.label;
    outtextxy(box_x + 8, label_y + 6, display_label.c_str());

    //铃声选择框
    int ringtone_y = label_y + box_height + 8;

    setfillcolor(RGB(50, 50, 50));
    solidroundrect(box_x, ringtone_y, box_x + box_width, ringtone_y + box_height, 5, 5);

    settextcolor(RGB(221, 221, 221));
    outtextxy(box_x + 8, ringtone_y + 6, running_timer.ringtone_name.c_str());

    settextcolor(RGB(150, 150, 150));
    outtextxy(box_x + box_width - 20, ringtone_y + 6, L"▼");
}

void TimerManager::draw_timer_controls()
{
    //圆下面的两个按钮
    int button_y = 450;
    int button_height = 40;
    int button_width = 140;
    int spacing = 20;

    int total_width = button_width * 2 + spacing;
    int start_x = (520 - total_width) / 2;

    //取消按钮（左边）
    int cancel_x = start_x;
    setfillcolor(RGB(47, 47, 47));
    solidroundrect(cancel_x, button_y, cancel_x + button_width, button_y + button_height, button_height / 2, button_height / 2);

    settextstyle(16, 0, L"微软雅黑");
    settextcolor(RGB(201, 201, 201));
    setbkmode(TRANSPARENT);
    wstring cancel_text = L"取消";
    int cancel_text_width = textwidth(cancel_text.c_str());
    outtextxy(cancel_x + (button_width - cancel_text_width) / 2, button_y + 10, cancel_text.c_str());

    //暂停/继续按钮（右边）
    int pause_x = start_x + button_width + spacing;

    if (running_timer.is_paused)
    {
        setfillcolor(RGB(104, 206, 103));
    }
    else
    {
        setfillcolor(RGB(240, 151, 72));
    }

    solidroundrect(pause_x, button_y, pause_x + button_width, button_y + button_height, button_height / 2, button_height / 2);

    settextcolor(RGB(201, 201, 201));
    wstring pause_text = running_timer.is_paused ? L"继续" : L"暂停";
    int pause_text_width = textwidth(pause_text.c_str());
    outtextxy(pause_x + (button_width - pause_text_width) / 2, button_y + 10, pause_text.c_str());
}

void TimerManager::draw()
{
    if (has_running_timer)
    {
        draw_running_timer_page();

        //绘制铃声菜单（如果显示）
        if (show_ringtone_menu && ringtone_menu != nullptr)
        {
            ringtone_menu->draw();
        }
    }
    else
    {
        draw_default_page();

        //绘制铃声菜单（如果显示）
        if (show_ringtone_menu && ringtone_menu != nullptr)
        {
            ringtone_menu->draw();
        }
    }
}

//到最后是点击检测和输入处理

void TimerManager::calculate_recent_card_position(int index, int& x, int& y)
{
    //一行2个卡片，卡片尺寸228px*228px
    int cards_per_row = 2;
    int card_size = 228;
    int margin = 10;

    int row = index / cards_per_row;
    int col = index % cards_per_row;

    x = margin + col * (card_size + margin);
    y = 680 - 76 + 30 + margin + scroll_offset + row * (card_size + margin);
}

bool TimerManager::check_hour_digit_click(int mouse_x, int mouse_y)
{
    int digits_y = 228 + scroll_offset;

    settextstyle(68, 0, L"微软雅黑");

    wstring hour_str = (hours < 10 ? L"0" : L"") + to_wstring(hours);
    wstring minute_str = (minutes < 10 ? L"0" : L"") + to_wstring(minutes);
    wstring second_str = (seconds < 10 ? L"0" : L"") + to_wstring(seconds);

    wstringstream wss;
    wss << setfill(L'0') << setw(2) << hours << L":"
        << setw(2) << minutes << L":"
        << setw(2) << seconds;
    wstring time_text = wss.str();

    int total_width = textwidth(time_text.c_str());
    int start_x = (520 - total_width) / 2;

    int hour_width = textwidth(hour_str.c_str());
    int colon_width = textwidth(L":");

    int hour_x = start_x;
    int colon1_x = hour_x + hour_width;

    if (mouse_x >= hour_x - 5 && mouse_x <= colon1_x &&
        mouse_y >= digits_y - 5 && mouse_y <= digits_y + 68)
    {
        current_focus = TIMER_FOCUS_HOUR;
        hour_input_buffer = -1;
        is_editing_label = false;
        return true;
    }
    return false;
}

bool TimerManager::check_minute_digit_click(int mouse_x, int mouse_y)
{
    int digits_y = 228 + scroll_offset;

    settextstyle(68, 0, L"微软雅黑");

    wstring hour_str = (hours < 10 ? L"0" : L"") + to_wstring(hours);
    wstring minute_str = (minutes < 10 ? L"0" : L"") + to_wstring(minutes);
    wstring second_str = (seconds < 10 ? L"0" : L"") + to_wstring(seconds);

    wstringstream wss;
    wss << setfill(L'0') << setw(2) << hours << L":"
        << setw(2) << minutes << L":"
        << setw(2) << seconds;
    wstring time_text = wss.str();

    int total_width = textwidth(time_text.c_str());
    int start_x = (520 - total_width) / 2;

    int hour_width = textwidth(hour_str.c_str());
    int colon_width = textwidth(L":");
    int minute_width = textwidth(minute_str.c_str());

    int minute_x = start_x + hour_width + colon_width;
    int colon2_x = minute_x + minute_width;

    if (mouse_x >= minute_x && mouse_x <= colon2_x &&
        mouse_y >= digits_y - 5 && mouse_y <= digits_y + 68)
    {
        current_focus = TIMER_FOCUS_MINUTE;
        minute_input_buffer = -1;
        is_editing_label = false;
        return true;
    }
    return false;
}

bool TimerManager::check_second_digit_click(int mouse_x, int mouse_y)
{
    int digits_y = 228 + scroll_offset;

    settextstyle(68, 0, L"微软雅黑");

    wstring hour_str = (hours < 10 ? L"0" : L"") + to_wstring(hours);
    wstring minute_str = (minutes < 10 ? L"0" : L"") + to_wstring(minutes);
    wstring second_str = (seconds < 10 ? L"0" : L"") + to_wstring(seconds);

    wstringstream wss;
    wss << setfill(L'0') << setw(2) << hours << L":"
        << setw(2) << minutes << L":"
        << setw(2) << seconds;
    wstring time_text = wss.str();

    int total_width = textwidth(time_text.c_str());
    int start_x = (520 - total_width) / 2;

    int hour_width = textwidth(hour_str.c_str());
    int colon_width = textwidth(L":");
    int minute_width = textwidth(minute_str.c_str());
    int second_width = textwidth(second_str.c_str());

    int second_x = start_x + hour_width + colon_width + minute_width + colon_width;

    if (mouse_x >= second_x && mouse_x <= second_x + second_width + 5 &&
        mouse_y >= digits_y - 5 && mouse_y <= digits_y + 68)
    {
        current_focus = TIMER_FOCUS_SECOND;
        second_input_buffer = -1;
        is_editing_label = false;
        return true;
    }
    return false;
}

bool TimerManager::check_label_input_click(int mouse_x, int mouse_y)
{
    int input_y = 228 + 68 + 30 + scroll_offset;
    int input_x = 100;
    int input_width = 320;
    int input_height = 35;

    if (mouse_x >= input_x && mouse_x <= input_x + input_width &&
        mouse_y >= input_y && mouse_y <= input_y + input_height)
    {
        is_editing_label = true;
        current_focus = TIMER_FOCUS_NONE;
        return true;
    }
    else if (is_editing_label)
    {
        is_editing_label = false;
    }

    return false;
}

bool TimerManager::check_ringtone_selector_click(int mouse_x, int mouse_y)
{
    int selector_y = 228 + 68 + 30 + 35 + 20 + scroll_offset;
    int selector_x = 100;
    int selector_width = 320;
    int selector_height = 35;

    if (mouse_x >= selector_x && mouse_x <= selector_x + selector_width &&
        mouse_y >= selector_y && mouse_y <= selector_y + selector_height)
    {
        if (!show_ringtone_menu)
        {
            ringtone_menu = new TimerRingtoneMenu();
            ringtone_menu->show(selector_x, selector_y + selector_height + 5);
            show_ringtone_menu = true;
        }
        else
        {
            delete ringtone_menu;
            ringtone_menu = nullptr;
            show_ringtone_menu = false;
        }
        return true;
    }

    return false;
}

bool TimerManager::check_start_button_click(int mouse_x, int mouse_y)
{
    int button_y = 486 + scroll_offset;
    int button_height = 40;
    int button_width = 140;
    int spacing = 20;

    int total_width = button_width * 2 + spacing;
    int start_x = (520 - total_width) / 2;

    int start_btn_x = start_x + button_width + spacing;

    if (mouse_x >= start_btn_x && mouse_x <= start_btn_x + button_width &&
        mouse_y >= button_y && mouse_y <= button_y + button_height)
    {
        //判断是否可以开始计时（时间不能为0）
        bool can_start = (hours > 0 || minutes > 0 || seconds > 0);
        if (!can_start)
        {
            return false;  //0时0分0秒不响应点击
        }
        
        //开始计时
        wstring timer_label = label_input.empty() ? L"计时器" : label_input;
        start_timer(hours, minutes, seconds, timer_label, ringtone_name);
        return true;
    }

    return false;
}

bool TimerManager::check_cancel_button_click(int mouse_x, int mouse_y)
{
    int button_y = 486 + scroll_offset;
    int button_height = 40;
    int button_width = 140;
    int spacing = 20;

    int total_width = button_width * 2 + spacing;
    int start_x = (520 - total_width) / 2;

    int cancel_x = start_x;

    if (mouse_x >= cancel_x && mouse_x <= cancel_x + button_width && mouse_y >= button_y && mouse_y <= button_y + button_height)
    {
        //重置所有值
        hours = 0;
        minutes = 0;
        seconds = 0;
        label_input = L"";
        current_focus = TIMER_FOCUS_NONE;
        is_editing_label = false;
        return true;
    }

    return false;
}

bool TimerManager::check_pause_button_click(int mouse_x, int mouse_y)
{
    int button_y = 450;
    int button_height = 40;
    int button_width = 140;
    int spacing = 20;

    int total_width = button_width * 2 + spacing;
    int start_x = (520 - total_width) / 2;

    int pause_x = start_x + button_width + spacing;

    if (mouse_x >= pause_x && mouse_x <= pause_x + button_width && mouse_y >= button_y && mouse_y <= button_y + button_height)
    {
        if (running_timer.is_paused)
        {
            resume_timer();
        }
        else
        {
            pause_timer();
        }
        return true;
    }

    return false;
}

bool TimerManager::check_cancel_running_button_click(int mouse_x, int mouse_y)
{
    int button_y = 450;
    int button_height = 40;
    int button_width = 140;
    int spacing = 20;

    int total_width = button_width * 2 + spacing;
    int start_x = (520 - total_width) / 2;

    int cancel_x = start_x;

    if (mouse_x >= cancel_x && mouse_x <= cancel_x + button_width && mouse_y >= button_y && mouse_y <= button_y + button_height)
    {
        cancel_timer();
        return true;
    }

    return false;
}

bool TimerManager::check_running_ringtone_selector_click(int mouse_x, int mouse_y)
{
    //与draw_timer_label_and_ringtone保持一致的参数
    int circle_center_x = 260;
    int circle_center_y = 250;
    int box_width = 200;
    int box_height = 28;
    int box_x = circle_center_x - box_width / 2;
    int label_y = circle_center_y + 30;
    int ringtone_y = label_y + box_height + 8;

    if (mouse_x >= box_x && mouse_x <= box_x + box_width && mouse_y >= ringtone_y && mouse_y <= ringtone_y + box_height)
    {
        if (!show_ringtone_menu)
        {
            ringtone_menu = new TimerRingtoneMenu();
            ringtone_menu->show(box_x, ringtone_y + box_height + 5);
            show_ringtone_menu = true;
        }
        else
        {
            delete ringtone_menu;
            ringtone_menu = nullptr;
            show_ringtone_menu = false;
        }
        return true;
    }

    return false;
}

int TimerManager::check_recent_delete_click(int mouse_x, int mouse_y)
{
    for (size_t i = 0; i < recent_timer_cards.size(); i++)
    {
        int delete_x = recent_timer_cards[i].card_x + 20;
        int delete_y = recent_timer_cards[i].card_y + recent_timer_cards[i].card_height - 20;
        int delete_radius = 12;

        int dx = mouse_x - delete_x;
        int dy = mouse_y - delete_y;

        if (dx * dx + dy * dy <= delete_radius * delete_radius)
        {
            return recent_timer_cards[i].timer.timer_id;
        }
    }

    return -1;
}

int TimerManager::check_recent_play_click(int mouse_x, int mouse_y)
{
    for (size_t i = 0; i < recent_timer_cards.size(); i++)
    {
        int play_x = recent_timer_cards[i].card_x + recent_timer_cards[i].card_width - 20;
        int play_y = recent_timer_cards[i].card_y + recent_timer_cards[i].card_height - 20;
        int play_radius = 12;

        int dx = mouse_x - play_x;
        int dy = mouse_y - play_y;

        if (dx * dx + dy * dy <= play_radius * play_radius)
        {
            return recent_timer_cards[i].timer.timer_id;
        }
    }

    return -1;
}

void TimerManager::handle_number_input(int digit)
{
    time_t now = time(0);

    if (current_focus == TIMER_FOCUS_HOUR)
    {
        if (hour_input_buffer == -1 || (now - last_input_time) >= 1)
        {
            hour_input_buffer = digit;
            last_input_time = now;
            hours = digit;
        }
        else
        {
            int combined = hour_input_buffer * 10 + digit;
            if (combined >= 0 && combined <= 99)
            {
                hours = combined;
                hour_input_buffer = -1;
            }
            else
            {
                hour_input_buffer = digit;
                last_input_time = now;
                hours = digit;
            }
        }
    }
    else if (current_focus == TIMER_FOCUS_MINUTE)
    {
        if (minute_input_buffer == -1 || (now - last_input_time) >= 1)
        {
            minute_input_buffer = digit;
            last_input_time = now;
            minutes = digit;
        }
        else
        {
            int combined = minute_input_buffer * 10 + digit;
            if (combined >= 0 && combined <= 59)
            {
                minutes = combined;
                minute_input_buffer = -1;
            }
            else
            {
                minute_input_buffer = digit;
                last_input_time = now;
                minutes = digit;
            }
        }
    }
    else if (current_focus == TIMER_FOCUS_SECOND)
    {
        if (second_input_buffer == -1 || (now - last_input_time) >= 1)
        {
            second_input_buffer = digit;
            last_input_time = now;
            seconds = digit;
        }
        else
        {
            int combined = second_input_buffer * 10 + digit;
            if (combined >= 0 && combined <= 59)
            {
                seconds = combined;
                second_input_buffer = -1;
            }
            else
            {
                second_input_buffer = digit;
                last_input_time = now;
                seconds = digit;
            }
        }
    }
}

void TimerManager::handle_arrow_key(bool is_up)
{
    if (current_focus == TIMER_FOCUS_HOUR)
    {
        if (is_up)
        {
            hours++;
            if (hours > 99) hours = 0;
        }
        else
        {
            hours--;
            if (hours < 0) hours = 99;
        }
        hour_input_buffer = -1;
        last_input_time = 0;
    }
    else if (current_focus == TIMER_FOCUS_MINUTE)
    {
        if (is_up)
        {
            minutes++;
            if (minutes > 59) minutes = 0;
        }
        else
        {
            minutes--;
            if (minutes < 0) minutes = 59;
        }
        minute_input_buffer = -1;
        last_input_time = 0;
    }
    else if (current_focus == TIMER_FOCUS_SECOND)
    {
        if (is_up)
        {
            seconds++;
            if (seconds > 59) seconds = 0;
        }
        else
        {
            seconds--;
            if (seconds < 0) seconds = 59;
        }
        second_input_buffer = -1;
        last_input_time = 0;
    }
}

bool TimerManager::handle_mouse_click(int mouse_x, int mouse_y)
{
    //处理铃声菜单点击
    if (show_ringtone_menu && ringtone_menu != nullptr)
    {
        int selected = ringtone_menu->check_click(mouse_x, mouse_y);
        if (selected >= 0)
        {
            RingtoneInfo* list;
            int count;
            AlarmSound::get_all_ringtones(&list, count);

            if (has_running_timer)
            {
                running_timer.ringtone_name = list[selected].display_name;
            }
            else
            {
                ringtone_name = list[selected].display_name;
            }

            delete[] list;
            delete ringtone_menu;
            ringtone_menu = nullptr;
            show_ringtone_menu = false;
            return true;
        }
        else if (ringtone_menu->is_outside_click(mouse_x, mouse_y))
        {
            delete ringtone_menu;
            ringtone_menu = nullptr;
            show_ringtone_menu = false;
        }
    }

    if (has_running_timer)
    {
        //运行页面的点击处理
        if (check_pause_button_click(mouse_x, mouse_y)) return true;
        if (check_cancel_running_button_click(mouse_x, mouse_y)) return true;
        if (check_running_ringtone_selector_click(mouse_x, mouse_y)) return true;
    }
    else
    {
        //默认页面的点击处理
        if (check_hour_digit_click(mouse_x, mouse_y)) return true;
        if (check_minute_digit_click(mouse_x, mouse_y)) return true;
        if (check_second_digit_click(mouse_x, mouse_y)) return true;
        if (check_label_input_click(mouse_x, mouse_y)) return true;
        if (check_ringtone_selector_click(mouse_x, mouse_y)) return true;
        if (check_start_button_click(mouse_x, mouse_y)) return true;
        if (check_cancel_button_click(mouse_x, mouse_y)) return true;

        //检查最近使用卡片点击
        int delete_id = check_recent_delete_click(mouse_x, mouse_y);
        if (delete_id >= 0)
        {
            remove_recent_timer(delete_id);
            return true;
        }

        int play_id = check_recent_play_click(mouse_x, mouse_y);
        if (play_id >= 0)
        {
            //找到对应的计时器并启动
            for (size_t i = 0; i < recent_timer_cards.size(); i++)
            {
                if (recent_timer_cards[i].timer.timer_id == play_id)
                {
                    start_timer_from_timer(recent_timer_cards[i].timer);
                    return true;
                }
            }
        }
    }

    return false;
}

void TimerManager::handle_mouse_move(int mouse_x, int mouse_y)
{
    if (show_ringtone_menu && ringtone_menu != nullptr)
    {
        ringtone_menu->update_hover(mouse_x, mouse_y);
    }
}

void TimerManager::handle_mouse_wheel(int delta)
{
    if (show_ringtone_menu && ringtone_menu != nullptr)
    {
        ringtone_menu->scroll(delta);
    }
    else if (!has_running_timer && !recent_timer_cards.empty())
    {
        scroll_offset += delta / 2;

        if (scroll_offset > 0) scroll_offset = 0;

        int total_rows = (recent_timer_cards.size() + 1) / 2;
        int total_height = total_rows * (228 + 10) + 10;
        int visible_height = 680 - (680 - 76 + 30);
        int max_scroll = total_height - visible_height;

        if (scroll_offset < -max_scroll && max_scroll > 0) scroll_offset = -max_scroll;
    }
}

void TimerManager::process_virtual_key(int vk)
{
    static DWORD last_vk_time[256] = { 0 };
    DWORD now = GetTickCount();
    if (vk >= 0 && vk < 256)
    {
        if (now - last_vk_time[vk] < 120)
            return;
        last_vk_time[vk] = now;
    }

    if (has_running_timer)
    {
        return;  //运行中不处理键盘
    }

    if (vk == VK_BACK)
    {
        if (is_editing_label && !label_input.empty())
        {
            label_input.pop_back();
        }
        return;
    }

    if ((vk == VK_UP || vk == VK_DOWN) && current_focus != TIMER_FOCUS_NONE && !is_editing_label)
    {
        handle_arrow_key(vk == VK_UP);
        return;
    }

    if (vk >= '0' && vk <= '9' && current_focus != TIMER_FOCUS_NONE && !is_editing_label)
    {
        handle_number_input(vk - '0');
        return;
    }

    if (vk >= VK_NUMPAD0 && vk <= VK_NUMPAD9 && current_focus != TIMER_FOCUS_NONE && !is_editing_label)
    {
        handle_number_input(vk - VK_NUMPAD0);
        return;
    }

    if (vk == VK_SPACE && is_editing_label)
    {
        label_input += L' ';
        return;
    }

    if (is_editing_label && vk >= 'A' && vk <= 'Z')
    {
        bool shift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
        wchar_t ch = (wchar_t)(shift ? vk : (vk - 'A' + 'a'));
        label_input += ch;
        return;
    }
}

void TimerManager::update()
{
    if (!has_running_timer || running_timer.is_paused)
    {
        return;
    }

    //计算剩余秒数
    time_t now = time(0);
    int elapsed = (int)(now - running_timer.start_time);
    running_timer.remaining_seconds = running_timer.total_seconds - elapsed;

    if (running_timer.remaining_seconds < 0)
    {
        running_timer.remaining_seconds = 0;
    }
}

Timer* TimerManager::check_timer_finished()
{
    if (!has_running_timer || running_timer.is_paused)
    {
        return nullptr;
    }

    if (running_timer.remaining_seconds <= 0)
    {
        //计时器完成
        return &running_timer;
    }

    return nullptr;
}

void TimerManager::start_timer(int h, int m, int s, const wstring& lbl, const wstring& ring)
{
    running_timer.hours = h;
    running_timer.minutes = m;
    running_timer.seconds = s;
    running_timer.label = lbl;
    running_timer.ringtone_name = ring;

    running_timer.total_seconds = h * 3600 + m * 60 + s;
    running_timer.remaining_seconds = running_timer.total_seconds;
    running_timer.start_time = time(0);
    running_timer.is_running = true;
    running_timer.is_paused = false;
    running_timer.timer_id = next_timer_id++;

    has_running_timer = true;
}

void TimerManager::start_timer_from_timer(const Timer& timer)
{
    start_timer(timer.hours, timer.minutes, timer.seconds, timer.label, timer.ringtone_name);
}

void TimerManager::add_to_recent(const Timer& timer)
{
    //检查是否已存在相同的计时器
    for (size_t i = 0; i < recent_timer_cards.size(); i++)
    {
        if (recent_timer_cards[i].timer.hours == timer.hours &&
            recent_timer_cards[i].timer.minutes == timer.minutes &&
            recent_timer_cards[i].timer.seconds == timer.seconds &&
            recent_timer_cards[i].timer.label == timer.label)
        {
            return;  //已存在，不添加
        }
    }

    //添加到最近使用
    RecentTimerCard card;
    card.timer = timer;
    card.timer.timer_id = next_timer_id++;
    card.card_width = 228;
    card.card_height = 228;

    recent_timer_cards.push_back(card);
}

void TimerManager::pause_timer()
{
    if (!has_running_timer || running_timer.is_paused)
    {
        return;
    }

    running_timer.is_paused = true;
    running_timer.pause_time = time(0);
}

void TimerManager::resume_timer()
{
    if (!has_running_timer || !running_timer.is_paused)
    {
        return;
    }

    running_timer.is_paused = false;

    //重新计算开始时间
    time_t now = time(0);
    int pause_duration = (int)(now - running_timer.pause_time);
    running_timer.start_time += pause_duration;
}

void TimerManager::cancel_timer()
{
    if (!has_running_timer)
    {
        return;
    }

    //添加到最近使用
    Timer finished_timer;
    finished_timer.hours = running_timer.hours;
    finished_timer.minutes = running_timer.minutes;
    finished_timer.seconds = running_timer.seconds;
    finished_timer.label = running_timer.label;
    finished_timer.ringtone_name = running_timer.ringtone_name;

    add_to_recent(finished_timer);

    has_running_timer = false;
    running_timer = Timer();
}

void TimerManager::remove_recent_timer(int timer_id)
{
    for (auto it = recent_timer_cards.begin(); it != recent_timer_cards.end(); ++it)
    {
        if (it->timer.timer_id == timer_id)
        {
            recent_timer_cards.erase(it);
            return;
        }
    }
}