main.cpp

#include <graphics.h>
#include <conio.h>
#include <windows.h>
#include "WorldClockManager.h"
#include "AlarmManager.h"
#include "AlarmEditDialog.h"
#include "AlarmNotification.h"
#include "AlarmSound.h"
#include "UIHelper.h"
#include "Stopwatch.h"
#include "TimerManager.h"
#include "TimerNotification.h"

int main()
{
    //初始化窗口
    initgraph(520, 680);
    setbkcolor(RGB(30, 30, 30));
    cleardevice();

    //创建世界时钟管理器
    WorldClockManager world_clock_mgr;

    //创建闹钟管理器
    AlarmManager alarm_mgr;

    //创建闹钟编辑对话框
    AlarmEditDialog alarm_dialog;

    //创建闹钟通知条
    AlarmNotification alarm_notification;

    //创建秒表管理器
    Stopwatch stopwatch_mgr;

    //创建计时器管理器
    TimerManager timer_mgr;

    //创建计时器通知条
    TimerNotification timer_notification;

    //创建自定义计时器对话框
    CustomTimerDialog custom_timer_dialog;

    //导航栏
    NavigationBar nav_bar;
    nav_bar.bar_width = 272;
    nav_bar.bar_height = 32;
    nav_bar.bar_x = (520 - nav_bar.bar_width) / 2;
    nav_bar.bar_y = (44 - nav_bar.bar_height) / 2;
    nav_bar.current_tab = NAV_WORLD_CLOCK;  //默认世界时钟
    nav_bar.has_hover = false;
    nav_bar.tab_names[0] = L"世界时钟";
    nav_bar.tab_names[1] = L"闹钟";
    nav_bar.tab_names[2] = L"秒表";
    nav_bar.tab_names[3] = L"计时器";

    //添加按钮
    AddButton add_btn;
    add_btn.x = 490;
    add_btn.y = 22;
    add_btn.radius = 12;
    add_btn.is_hovered = false;

    //关闭按钮
    CloseButton close_btn;
    close_btn.x = 20;
    close_btn.y = 22;
    close_btn.radius = 8;
    close_btn.is_hovered = false;

    //城市选择菜单
    CityMenu* city_menu = nullptr;
    bool show_city_menu = false;

    //计时器加号菜单
    TimerAddMenu* timer_add_menu = nullptr;
    bool show_timer_add_menu = false;

    int last_second = -1;

    //鼠标消息
    ExMessage msg;

    //退出标志
    bool should_exit = false;

    //强制重绘标志
    bool force_redraw = false;

    // 轮询按键上升沿状态缓存
    bool prevKeyState[256] = { 0 };

    BeginBatchDraw();

    while (!should_exit)
    {
        //处理鼠标消息
        while (peekmessage(&msg, EM_MOUSE))
        {
            if (msg.message == WM_MOUSEMOVE)
            {
                //添加按钮悬停（秒表页面不显示）
                if (nav_bar.current_tab != NAV_STOPWATCH)
                {
                    add_btn.is_hovered = UIHelper::is_mouse_on_add_button(
                        msg.x, msg.y, add_btn.x, add_btn.y, add_btn.radius);
                }
                else
                {
                    add_btn.is_hovered = false;
                }

                close_btn.is_hovered = UIHelper::is_mouse_on_close_button(
                    msg.x, msg.y, close_btn.x, close_btn.y, close_btn.radius);

                int hovered = UIHelper::check_tab_hover(msg.x, msg.y, nav_bar);
                if (hovered >= 0)
                {
                    nav_bar.has_hover = true;
                    nav_bar.hovered_tab = (NavTab)hovered;
                }
                else
                {
                    nav_bar.has_hover = false;
                }

                if (show_city_menu && city_menu != nullptr)
                    city_menu->update_hover(msg.x, msg.y);

                if (show_timer_add_menu && timer_add_menu != nullptr)
                    timer_add_menu->update_hover(msg.x, msg.y);

                if (alarm_dialog.is_visible)
                    alarm_dialog.handle_mouse_move(msg.x, msg.y);

                if (alarm_notification.visible())
                    alarm_notification.handle_mouse_move(msg.x, msg.y);

                if (timer_notification.visible())
                    timer_notification.handle_mouse_move(msg.x, msg.y);

                //自定义计时器对话框鼠标移动
                if (custom_timer_dialog.is_visible)
                    custom_timer_dialog.handle_mouse_move(msg.x, msg.y);

                //秒表鼠标移动
                if (nav_bar.current_tab == NAV_STOPWATCH)
                    stopwatch_mgr.handle_mouse_move(msg.x, msg.y);

                //计时器鼠标移动
                if (nav_bar.current_tab == NAV_TIMER)
                    timer_mgr.handle_mouse_move(msg.x, msg.y);
            }
            else if (msg.message == WM_MOUSEWHEEL)
            {
                int delta = msg.wheel;
                if (custom_timer_dialog.is_visible)
                {
                    custom_timer_dialog.handle_mouse_wheel(delta);
                    force_redraw = true;
                }
                else if (alarm_dialog.is_visible)
                {
                    alarm_dialog.handle_mouse_wheel(delta);
                    force_redraw = true;
                }
                else if (nav_bar.current_tab == NAV_WORLD_CLOCK)
                {
                    world_clock_mgr.scroll(delta / 2);
                    force_redraw = true;
                }
                else if (nav_bar.current_tab == NAV_ALARM)
                {
                    alarm_mgr.scroll(delta / 2);
                    force_redraw = true;
                }
                else if (nav_bar.current_tab == NAV_STOPWATCH)
                {
                    stopwatch_mgr.handle_mouse_wheel(delta);
                    force_redraw = true;
                }
                else if (nav_bar.current_tab == NAV_TIMER)
                {
                    timer_mgr.handle_mouse_wheel(delta);
                    force_redraw = true;
                }
            }
            else if (msg.message == WM_LBUTTONDOWN)
            {
                //处理自定义计时器对话框点击
                if (custom_timer_dialog.is_visible)
                {
                    if (custom_timer_dialog.handle_mouse_click(msg.x, msg.y))
                    {
                        if (custom_timer_dialog.is_confirmed)
                        {
                            Timer timer = custom_timer_dialog.get_timer();
                            timer_mgr.start_timer(timer.hours, timer.minutes, timer.seconds, 
                                                  timer.label, timer.ringtone_name);
                        }
                        force_redraw = true;
                        continue;
                    }
                }
                
                //处理计时器通知条点击
                if (timer_notification.visible())
                {
                    bool replay_clicked = false, close_clicked = false;
                    if (timer_notification.handle_mouse_click(msg.x, msg.y, replay_clicked, close_clicked))
                    {
                        if (replay_clicked)
                        {
                            //重新开始计时
                            Timer finished = timer_notification.get_finished_timer();
                            timer_mgr.start_timer_from_timer(finished);
                            AlarmSound::stop_alarm();
                            timer_notification.hide();
                        }
                        else if (close_clicked)
                        {
                            //停止计时
                            AlarmSound::stop_alarm();
                            timer_notification.hide();
                        }
                        force_redraw = true;
                        continue;
                    }
                }

                //处理闹钟通知条点击
                if (alarm_notification.visible())
                {
                    bool snooze_clicked = false, close_clicked = false;
                    if (alarm_notification.handle_mouse_click(msg.x, msg.y, snooze_clicked, close_clicked))
                    {
                        if (snooze_clicked)
                        {
                            for (size_t i = 0; i < alarm_mgr.alarm_cards.size(); i++)
                            {
                                Alarm& alarm = alarm_mgr.alarm_cards[i].alarm;
                                if (alarm.last_trigger_time > 0)
                                {
                                    time_t now = time(0);
                                    struct tm trigger_t, now_t;
                                    localtime_s(&trigger_t, &alarm.last_trigger_time);
                                    localtime_s(&now_t, &now);
                                    
                                    if (trigger_t.tm_year == now_t.tm_year &&
                                        trigger_t.tm_mon == now_t.tm_mon &&
                                        trigger_t.tm_mday == now_t.tm_mday &&
                                        trigger_t.tm_hour == now_t.tm_hour &&
                                        trigger_t.tm_min == now_t.tm_min)
                                    {
                                        time_t base_time;
                                        if (alarm.is_snoozed && alarm.snooze_time > 0)
                                        {
                                            base_time = alarm.snooze_time;
                                        }
                                        else
                                        {
                                            base_time = alarm.last_trigger_time;
                                        }
                                        
                                        alarm.is_snoozed = true;
                                        alarm.snooze_time = base_time + (alarm.snooze_duration * 60);
                                        break;
                                    }
                                }
                            }
                            AlarmSound::stop_alarm();
                            alarm_notification.hide();
                        }
                        else if (close_clicked)
                        {
                            Alarm* triggered = alarm_notification.get_triggered_alarm();
                            if (triggered != nullptr)
                            {
                                for (size_t i = 0; i < alarm_mgr.alarm_cards.size(); i++)
                                {
                                    Alarm& alarm = alarm_mgr.alarm_cards[i].alarm;
                                    if (alarm.alarm_id == triggered->alarm_id)
                                    {
                                        bool has_repeat = false;
                                        for (int j = 0; j < 7; j++)
                                        {
                                            if (alarm.repeat_days[j])
                                            {
                                                has_repeat = true;
                                                break;
                                            }
                                        }
                                        
                                        if (!has_repeat)
                                        {
                                            alarm.is_enabled = false;
                                        }
                                        
                                        alarm.is_snoozed = false;
                                        alarm.snooze_time = 0;
                                        break;
                                    }
                                }
                            }
                            AlarmSound::stop_alarm();
                            alarm_notification.hide();
                        }
                        force_redraw = true;
                        continue;
                    }
                }

                if (alarm_dialog.is_visible)
                {
                    if (alarm_dialog.handle_mouse_click(msg.x, msg.y))
                        force_redraw = true;

                    if (!alarm_dialog.is_visible && alarm_dialog.is_saved)
                    {
                        Alarm new_alarm = alarm_dialog.get_alarm();
                        if (new_alarm.alarm_id == 0)
                            alarm_mgr.add_alarm(new_alarm);
                        else
                            alarm_mgr.update_alarm(new_alarm.alarm_id, new_alarm);
                        force_redraw = true;
                    }
                    continue;
                }

                if (UIHelper::is_mouse_on_close_button(msg.x, msg.y, close_btn.x, close_btn.y, close_btn.radius))
                {
                    should_exit = true;
                    continue;
                }

                int clicked_tab = UIHelper::check_tab_hover(msg.x, msg.y, nav_bar);
                if (clicked_tab >= 0)
                {
                    nav_bar.current_tab = (NavTab)clicked_tab;
                    force_redraw = true;
                    continue;
                }

                //添加按钮点击（秒表页面不响应）
                if (nav_bar.current_tab != NAV_STOPWATCH && 
                    UIHelper::is_mouse_on_add_button(msg.x, msg.y, add_btn.x, add_btn.y, add_btn.radius))
                {
                    if (nav_bar.current_tab == NAV_WORLD_CLOCK)
                    {
                        if (!show_city_menu)
                        {
                            city_menu = new CityMenu();
                            city_menu->show(add_btn.x - 100, add_btn.y + 20);
                            show_city_menu = true;
                        }
                        else
                        {
                            delete city_menu;
                            city_menu = nullptr;
                            show_city_menu = false;
                        }
                    }
                    else if (nav_bar.current_tab == NAV_ALARM)
                    {
                        alarm_dialog.show(nullptr);
                    }
                    else if (nav_bar.current_tab == NAV_TIMER)
                    {
                        if (!show_timer_add_menu)
                        {
                            timer_add_menu = new TimerAddMenu();
                            //获取最近使用的计时器列表
                            vector<Timer> recent_timers;
                            for (size_t i = 0; i < timer_mgr.recent_timer_cards.size(); i++)
                            {
                                recent_timers.push_back(timer_mgr.recent_timer_cards[i].timer);
                            }
                            timer_add_menu->show(add_btn.x - 180, add_btn.y + 20, recent_timers);
                            show_timer_add_menu = true;
                        }
                        else
                        {
                            delete timer_add_menu;
                            timer_add_menu = nullptr;
                            show_timer_add_menu = false;
                        }
                    }
                    force_redraw = true;
                }
                else if (show_city_menu && city_menu != nullptr)
                {
                    int selected = city_menu->check_click(msg.x, msg.y);
                    if (selected >= 0)
                    {
                        int count = 0;
                        TimeZoneInfo* zones = TimeZone::get_all_timezones(count);
                        world_clock_mgr.add_city(zones[selected].city_name);
                        delete city_menu; 
                        city_menu = nullptr; 
                        show_city_menu = false; 
                        force_redraw = true;
                    }
                    else if (city_menu->is_outside_click(msg.x, msg.y))
                    {
                        delete city_menu; 
                        city_menu = nullptr; 
                        show_city_menu = false; 
                        force_redraw = true;
                    }
                }
                else if (show_timer_add_menu && timer_add_menu != nullptr)
                {
                    int preset_minutes = 0;
                    Timer recent_timer;
                    bool is_custom = false;
                    
                    int result = timer_add_menu->check_click(msg.x, msg.y, preset_minutes, recent_timer, is_custom);
                    
                    if (result == 1)
                    {
                        //预置计时器
                        int hours = preset_minutes / 60;
                        int minutes = preset_minutes % 60;
                        timer_mgr.start_timer(hours, minutes, 0, L"计时器", L"做个文明中国人");
                        delete timer_add_menu;
                        timer_add_menu = nullptr;
                        show_timer_add_menu = false;
                        force_redraw = true;
                    }
                    else if (result == 2)
                    {
                        //自定义计时器 - 显示对话框
                        custom_timer_dialog.show();
                        delete timer_add_menu;
                        timer_add_menu = nullptr;
                        show_timer_add_menu = false;
                        force_redraw = true;
                    }
                    else if (result == 3)
                    {
                        //最近使用的计时器
                        timer_mgr.start_timer_from_timer(recent_timer);
                        delete timer_add_menu;
                        timer_add_menu = nullptr;
                        show_timer_add_menu = false;
                        force_redraw = true;
                    }
                    else if (timer_add_menu->is_outside_click(msg.x, msg.y))
                    {
                        delete timer_add_menu;
                        timer_add_menu = nullptr;
                        show_timer_add_menu = false;
                        force_redraw = true;
                    }
                }
                else if (nav_bar.current_tab == NAV_WORLD_CLOCK)
                {
                    int delete_index = world_clock_mgr.check_delete_button_click(msg.x, msg.y);
                    if (delete_index >= 0) 
                    { 
                        world_clock_mgr.remove_city(delete_index); 
                        force_redraw = true; 
                    }
                }
                else if (nav_bar.current_tab == NAV_ALARM)
                {
                    int switch_alarm_id = alarm_mgr.check_switch_click(msg.x, msg.y);
                    if (switch_alarm_id >= 0) 
                    { 
                        force_redraw = true; 
                        continue; 
                    }

                    int delete_alarm_id = alarm_mgr.check_delete_button_click(msg.x, msg.y);
                    if (delete_alarm_id >= 0) 
                    { 
                        alarm_mgr.remove_alarm(delete_alarm_id); 
                        force_redraw = true; 
                        continue; 
                    }

                    int edit_alarm_id = alarm_mgr.check_card_click(msg.x, msg.y);
                    if (edit_alarm_id >= 0)
                    {
                        Alarm* alarm_to_edit = alarm_mgr.get_alarm(edit_alarm_id);
                        if (alarm_to_edit != nullptr) 
                        { 
                            alarm_dialog.show(alarm_to_edit); 
                            force_redraw = true; 
                        }
                    }
                }
                else if (nav_bar.current_tab == NAV_STOPWATCH)
                {
                    //秒表按钮点击
                    stopwatch_mgr.handle_mouse_click(msg.x, msg.y);
                    force_redraw = true;
                }
                else if (nav_bar.current_tab == NAV_TIMER)
                {
                    //计时器按钮点击
                    if (timer_mgr.handle_mouse_click(msg.x, msg.y))
                    {
                        force_redraw = true;
                    }
                }
            }
        }

        //轮询键盘
        if (alarm_dialog.is_visible)
        {
            int keysToCheck[] = {
                VK_UP, VK_DOWN, VK_BACK, VK_SPACE,
                '0','1','2','3','4','5','6','7','8','9',
                VK_NUMPAD0,VK_NUMPAD1,VK_NUMPAD2,VK_NUMPAD3,VK_NUMPAD4,VK_NUMPAD5,VK_NUMPAD6,VK_NUMPAD7,VK_NUMPAD8,VK_NUMPAD9,
                'A','B','C','D','E','F','G','H','I','J','K','L','M',
                'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
            };
            for (int vk : keysToCheck)
            {
                SHORT state = GetAsyncKeyState(vk);
                bool down = (state & 0x8000) != 0;
                if (down && !prevKeyState[vk])
                {
                    alarm_dialog.process_virtual_key(vk);
                    force_redraw = true;
                }
                prevKeyState[vk] = down;
            }
        }
        else if (custom_timer_dialog.is_visible)
        {
            //自定义计时器对话框键盘输入
            int keysToCheck[] = {
                VK_UP, VK_DOWN, VK_BACK, VK_SPACE, VK_ESCAPE,
                '0','1','2','3','4','5','6','7','8','9',
                VK_NUMPAD0,VK_NUMPAD1,VK_NUMPAD2,VK_NUMPAD3,VK_NUMPAD4,VK_NUMPAD5,VK_NUMPAD6,VK_NUMPAD7,VK_NUMPAD8,VK_NUMPAD9,
                'A','B','C','D','E','F','G','H','I','J','K','L','M',
                'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
            };
            for (int vk : keysToCheck)
            {
                SHORT state = GetAsyncKeyState(vk);
                bool down = (state & 0x8000) != 0;
                if (down && !prevKeyState[vk])
                {
                    custom_timer_dialog.process_virtual_key(vk);
                    if (custom_timer_dialog.is_confirmed)
                    {
                        Timer timer = custom_timer_dialog.get_timer();
                        timer_mgr.start_timer(timer.hours, timer.minutes, timer.seconds,
                                              timer.label, timer.ringtone_name);
                    }
                    force_redraw = true;
                }
                prevKeyState[vk] = down;
            }
        }
        else if (nav_bar.current_tab == NAV_TIMER && !timer_mgr.is_timer_running())
        {
            //计时器页面键盘输入
            int keysToCheck[] = {
                VK_UP, VK_DOWN, VK_BACK, VK_SPACE,
                '0','1','2','3','4','5','6','7','8','9',
                VK_NUMPAD0,VK_NUMPAD1,VK_NUMPAD2,VK_NUMPAD3,VK_NUMPAD4,VK_NUMPAD5,VK_NUMPAD6,VK_NUMPAD7,VK_NUMPAD8,VK_NUMPAD9,
                'A','B','C','D','E','F','G','H','I','J','K','L','M',
                'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
            };
            for (int vk : keysToCheck)
            {
                SHORT state = GetAsyncKeyState(vk);
                bool down = (state & 0x8000) != 0;
                if (down && !prevKeyState[vk])
                {
                    timer_mgr.process_virtual_key(vk);
                    force_redraw = true;
                }
                prevKeyState[vk] = down;
            }
        }
        else
        {
            for (int i = 0; i < 256; ++i) prevKeyState[i] = false;
        }

        //退出检测
        if (_kbhit()) 
        { 
            should_exit = true; 
        }

        //绘制刷新逻辑
        time_t now = time(0);
        struct tm t; 
        localtime_s(&t, &now);

        //秒表和计时器需要高频刷新
        bool need_redraw = force_redraw || t.tm_sec != last_second;
        if (nav_bar.current_tab == NAV_STOPWATCH)
        {
            stopwatch_mgr.update();
            need_redraw = true;
        }
        else if (nav_bar.current_tab == NAV_TIMER)
        {
            timer_mgr.update();
            need_redraw = true;
        }

        if (need_redraw)
        {
            if (t.tm_sec != last_second) 
                last_second = t.tm_sec;

            world_clock_mgr.update_all_clocks();

            //检查闹钟触发
            if (!alarm_notification.visible())
            {
                Alarm* triggered = alarm_mgr.check_alarm_trigger();
                if (triggered != nullptr)
                {
                    AlarmSound::play_alarm_loop(triggered->ringtone_name);
                    alarm_notification.show(triggered);
                }
            }

            //检查计时器完成
            if (!timer_notification.visible())
            {
                Timer* finished = timer_mgr.check_timer_finished();
                if (finished != nullptr)
                {
                    //添加到最近使用
                    timer_mgr.add_to_recent(*finished);
                    
                    //播放铃声并显示通知
                    AlarmSound::play_alarm_loop(finished->ringtone_name);
                    timer_notification.show(*finished);
                    
                    //取消运行中的计时器
                    timer_mgr.cancel_timer();
                }
            }

            cleardevice();
            UIHelper::draw_navigation_bar(nav_bar);
            UIHelper::draw_close_button(close_btn.x, close_btn.y, close_btn.radius, close_btn.is_hovered);
            
            //秒表页面不绘制添加按钮
            if (nav_bar.current_tab != NAV_STOPWATCH)
            {
                UIHelper::draw_add_button(add_btn.x, add_btn.y, add_btn.radius, add_btn.is_hovered);
            }

            if (nav_bar.current_tab == NAV_WORLD_CLOCK)
                world_clock_mgr.draw_all_clocks();
            else if (nav_bar.current_tab == NAV_ALARM)
                alarm_mgr.draw_all_alarms();
            else if (nav_bar.current_tab == NAV_STOPWATCH)
                stopwatch_mgr.draw();
            else if (nav_bar.current_tab == NAV_TIMER)
                timer_mgr.draw();
            else
            {
                settextcolor(RGB(150, 150, 150));
                settextstyle(20, 0, L"微软雅黑");
                setbkmode(TRANSPARENT);
                wstring text = L"功能开发中...";
                int text_width = textwidth(text.c_str());
                outtextxy(260 - text_width / 2, 340, text.c_str());
            }

            if (show_city_menu && city_menu != nullptr) 
                city_menu->draw();
            
            if (show_timer_add_menu && timer_add_menu != nullptr)
                timer_add_menu->draw();
            
            if (alarm_dialog.is_visible) 
                alarm_dialog.draw();
            
            if (custom_timer_dialog.is_visible)
                custom_timer_dialog.draw();
            
            if (alarm_notification.visible()) 
                alarm_notification.draw();
            
            if (timer_notification.visible())
                timer_notification.draw();

            FlushBatchDraw();
            force_redraw = false;
        }

        Sleep(30);
    }

    EndBatchDraw();

    if (city_menu != nullptr) 
        delete city_menu;
    
    if (timer_add_menu != nullptr)
        delete timer_add_menu;
    
    AlarmSound::stop_alarm();
    closegraph();
    return 0;
}