Tithify.cpp

#ifndef UNICODE
#define UNICODE
#endif

#include <windows.h>
#include <winhttp.h>
#include <gdiplus.h>
#include <ctime>
#include <string>
#include <vector>
#include <stdint.h>
#include <stdio.h>
#include <shlobj.h>
#include <commdlg.h>

#pragma comment(lib, "gdiplus.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "advapi32.lib")
#pragma comment(lib, "winhttp.lib")
#pragma comment(lib, "shell32.lib")
#pragma comment(lib, "comdlg32.lib")

using namespace Gdiplus;

// ── App Version ──────────────────────────────────────────────────────────────
#define APP_VERSION L"3.6.3"
#define GITHUB_REPO_API L"/repos/aayushlbef/Tithify/releases/latest"
#define GITHUB_RELEASE_URL L"https://github.com/aayushlbef/Tithify/releases/tag/"
#define WM_UPDATE_AVAILABLE      (WM_USER + 2)
#define WM_UPDATE_NOT_FOUND      (WM_USER + 3)
#define WM_UPDATE_ERROR          (WM_USER + 4)
#define WM_HOLIDAYS_LOADED       (WM_USER + 5)
#define WM_HOLIDAYS_FAILED       (WM_USER + 6)
#define WM_UPDATE_DOWNLOADING    (WM_USER + 7)
#define WM_UPDATE_INSTALL_FAILED (WM_USER + 8)

// ── Global State ─────────────────────────────────────────────────────────────
ULONG_PTR g_gdiplusToken;
HWND g_hWnd = NULL;
extern HWND g_hCalWnd;
extern bool g_isCalendarOpen;
bool g_setupMode = true;
int g_xPos = 500, g_yPos = 1000;
POINT g_dragStart = { 0, 0 };
bool g_isDragging = false;
bool g_isMenuOpen = false;
bool g_showDay = true;

// DPI scale factor (1.0 = 96 DPI, 1.25 = 120 DPI, 1.5 = 144 DPI, etc.)
float g_dpiScale = 1.0f;

bool g_hiddenForFullscreen = false;
bool g_hiddenForTaskbar = false;
bool g_isOnTaskbar = true;
int g_currentShiftX = 0;
int g_currentShiftY = 0;

// ── Background Customization State ───────────────────────────────────────────
int g_bgPresetMode = 0;            // 0 = Transparent (Default), 1 = Custom Color, 2 = Dark Glass, 3 = Light Glass, 4 = Solid Black, 5 = Solid White, 6 = Red Accent, 7 = Blue Accent
COLORREF g_bgColorRGB = RGB(31, 31, 31);
int g_bgOpacity = 200;             // Opacity level (0..255)

// ── Custom Menu State ────────────────────────────────────────────────────────
HWND g_hMenuWnd = NULL;
int g_menuXPos = 0, g_menuYPos = 0;
int g_menuHoverIndex = -1;

// ── Theme Detection ──────────────────────────────────────────────────────────
bool g_isLightTheme = false;   // true = Windows light theme, false = dark
wchar_t g_latestVersion[64] = {0};  // Filled by update-check thread

bool DetectWindowsTheme() {
    // Returns true if Windows is using a light taskbar/system theme
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER,
            L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
            0, KEY_READ, &hKey) == ERROR_SUCCESS) {
        DWORD value = 0, size = sizeof(DWORD), type = REG_DWORD;
        // SystemUsesLightTheme controls the taskbar/system chrome color
        if (RegQueryValueExW(hKey, L"SystemUsesLightTheme", NULL, &type,
                             (LPBYTE)&value, &size) == ERROR_SUCCESS) {
            RegCloseKey(hKey);
            return (value != 0);
        }
        RegCloseKey(hKey);
    }
    return false;  // Default to dark theme if registry read fails
}

// ── Update Checker ───────────────────────────────────────────────────────────
// Compare "3.3.0" vs "3.4.0" style version strings
bool IsVersionNewer(const wchar_t* current, const wchar_t* latest) {
    int cMaj = 0, cMin = 0, cPat = 0;
    int lMaj = 0, lMin = 0, lPat = 0;
    const wchar_t* c = current;
    const wchar_t* l = latest;
    if (*c == L'v' || *c == L'V') c++;
    if (*l == L'v' || *l == L'V') l++;
    swscanf(c, L"%d.%d.%d", &cMaj, &cMin, &cPat);
    swscanf(l, L"%d.%d.%d", &lMaj, &lMin, &lPat);
    if (lMaj != cMaj) return lMaj > cMaj;
    if (lMin != cMin) return lMin > cMin;
    return lPat > cPat;
}

// Minimal JSON extractor: finds "key":"value" and writes value into out[]
bool ExtractJsonString(const char* json, const char* key, wchar_t* out, int outLen) {
    char needle[128];
    snprintf(needle, sizeof(needle), "\"%s\"", key);
    const char* p = strstr(json, needle);
    if (!p) return false;
    p += strlen(needle);
    while (*p == ' ' || *p == ':' || *p == '\t' || *p == '\n' || *p == '\r') p++;
    if (*p != '"') return false;
    p++;  // skip opening quote
    int i = 0;
    while (*p && *p != '"' && i < outLen - 1) {
        out[i++] = (wchar_t)(*p++);
    }
    out[i] = 0;
    return i > 0;
}

DWORD WINAPI CheckForUpdateThread(LPVOID lpParam) {
    bool isManual = (bool)(INT_PTR)lpParam;

    HINTERNET hSession = WinHttpOpen(L"Tithify/" APP_VERSION,
        WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) {
        if (isManual) PostMessage(g_hWnd, WM_UPDATE_ERROR, 0, 0);
        return 0;
    }

    HINTERNET hConnect = WinHttpConnect(hSession, L"api.github.com",
        INTERNET_DEFAULT_HTTPS_PORT, 0);
    if (!hConnect) {
        WinHttpCloseHandle(hSession);
        if (isManual) PostMessage(g_hWnd, WM_UPDATE_ERROR, 0, 0);
        return 0;
    }

    HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", GITHUB_REPO_API,
        NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);
    if (!hRequest) {
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        if (isManual) PostMessage(g_hWnd, WM_UPDATE_ERROR, 0, 0);
        return 0;
    }

    if (!WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
            WINHTTP_NO_REQUEST_DATA, 0, 0, 0) ||
        !WinHttpReceiveResponse(hRequest, NULL)) {
        WinHttpCloseHandle(hRequest);
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        if (isManual) PostMessage(g_hWnd, WM_UPDATE_ERROR, 0, 0);
        return 0;
    }

    // Read the full response body
    std::string response;
    char buf[4096];
    DWORD bytesRead = 0;
    while (WinHttpReadData(hRequest, buf, sizeof(buf) - 1, &bytesRead) && bytesRead > 0) {
        buf[bytesRead] = 0;
        response += buf;
        bytesRead = 0;
    }

    WinHttpCloseHandle(hRequest);
    WinHttpCloseHandle(hConnect);
    WinHttpCloseHandle(hSession);

    // Extract tag_name from the JSON response
    wchar_t tagName[64] = {0};
    if (ExtractJsonString(response.c_str(), "tag_name", tagName, 64)) {
        if (IsVersionNewer(APP_VERSION, tagName)) {
            wcscpy_s(g_latestVersion, tagName);
            PostMessage(g_hWnd, WM_UPDATE_AVAILABLE, 0, 0);
        } else {
            if (isManual) PostMessage(g_hWnd, WM_UPDATE_NOT_FOUND, 0, 0);
        }
    } else {
        if (isManual) PostMessage(g_hWnd, WM_UPDATE_ERROR, 0, 0);
    }
    return 0;
}

// ── Auto-Updater: Visible Console Window ─────────────────────────────────────
// Writes a PowerShell script to %TEMP% and opens it in a visible console
// window so the user can watch the download progress and installation steps.
static void LaunchUpdaterConsole(const wchar_t* version) {
    // ── Build the temp .ps1 path ──────────────────────────────────────────────
    wchar_t tempDir[MAX_PATH] = {0};
    GetTempPathW(MAX_PATH, tempDir);
    wchar_t ps1Path[MAX_PATH] = {0};
    swprintf(ps1Path, MAX_PATH, L"%sTithify_Updater.ps1", tempDir);

    // Convert version to narrow for snprintf
    char versionA[64] = {0};
    WideCharToMultiByte(CP_UTF8, 0, version, -1, versionA, sizeof(versionA), NULL, NULL);

    // ── Build the PowerShell script content ──────────────────────────────────
    char script[4096] = {0};
    snprintf(script, sizeof(script),
        "$ErrorActionPreference = 'Stop'\r\n"
        "$version = '%s'\r\n"
        "$url     = \"https://github.com/aayushlbef/Tithify/releases/download/$version/Tithify_Setup.exe\"\r\n"
        "$tmp     = \"$env:TEMP\\Tithify_Update_$version.exe\"\r\n"
        "$appExe  = \"$env:LOCALAPPDATA\\Tithify\\Tithify.exe\"\r\n"
        "\r\n"
        "Write-Host ''\r\n"
        "Write-Host '  ==================================================' -ForegroundColor Cyan\r\n"
        "Write-Host '   Tithify -- Auto Updater' -ForegroundColor Cyan\r\n"
        "Write-Host '  ==================================================' -ForegroundColor DarkGray\r\n"
        "Write-Host ''\r\n"
        "Write-Host \"  New version : $version\" -ForegroundColor White\r\n"
        "Write-Host \"  Source      : $url\" -ForegroundColor DarkGray\r\n"
        "Write-Host ''\r\n"
        "\r\n"
        "# -- Step 1: Download ------------------------------------------------\r\n"
        "Write-Host '[1/3] Downloading installer...' -ForegroundColor Cyan\r\n"
        "Write-Host ''\r\n"
        "try {\r\n"
        "    if (Get-Command curl.exe -ErrorAction SilentlyContinue) {\r\n"
        "        curl.exe -L --progress-bar -o $tmp $url\r\n"
        "        if ($LASTEXITCODE -ne 0) { throw \"curl exited with code $LASTEXITCODE\" }\r\n"
        "    } else {\r\n"
        "        $ProgressPreference = 'Continue'\r\n"
        "        Invoke-WebRequest -Uri $url -OutFile $tmp -UseBasicParsing\r\n"
        "    }\r\n"
        "} catch {\r\n"
        "    Write-Host ''\r\n"
        "    Write-Host \"[-] Download failed: $_\" -ForegroundColor Red\r\n"
        "    Write-Host ''\r\n"
        "    Read-Host 'Press Enter to close'\r\n"
        "    exit 1\r\n"
        "}\r\n"
        "\r\n"
        "if (-not (Test-Path $tmp) -or (Get-Item $tmp).Length -lt 100000) {\r\n"
        "    Write-Host '[-] Downloaded file appears corrupted. Please try again.' -ForegroundColor Red\r\n"
        "    Read-Host 'Press Enter to close'\r\n"
        "    exit 1\r\n"
        "}\r\n"
        "\r\n"
        "Write-Host ''\r\n"
        "Write-Host '[+] Download complete!' -ForegroundColor Green\r\n"
        "Write-Host ''\r\n"
        "\r\n"
        "# -- Step 2: Install -------------------------------------------------\r\n"
        "Write-Host '[2/3] Installing Tithify...' -ForegroundColor Cyan\r\n"
        "Write-Host '      Running installer silently, please wait...' -ForegroundColor DarkGray\r\n"
        "Write-Host ''\r\n"
        "Start-Process -FilePath $tmp -ArgumentList '/VERYSILENT /SUPPRESSMSGBOXES /NORESTART /SP-' -Wait\r\n"
        "Remove-Item $tmp -Force -ErrorAction SilentlyContinue\r\n"
        "Write-Host '[+] Installation complete!' -ForegroundColor Green\r\n"
        "Write-Host ''\r\n"
        "\r\n"
        "# -- Step 3: Relaunch ------------------------------------------------\r\n"
        "Write-Host '[3/3] Launching Tithify...' -ForegroundColor Cyan\r\n"
        "Start-Sleep -Seconds 1\r\n"
        "if (Test-Path $appExe) {\r\n"
        "    Start-Process -FilePath $appExe\r\n"
        "    Write-Host '[+] Widget launched successfully.' -ForegroundColor Green\r\n"
        "} else {\r\n"
        "    Write-Host \"[!] Could not find widget at: $appExe\" -ForegroundColor Yellow\r\n"
        "}\r\n"
        "\r\n"
        "Write-Host ''\r\n"
        "Write-Host '  Update complete! This window will close in 5 seconds.' -ForegroundColor Cyan\r\n"
        "Write-Host '  ==================================================' -ForegroundColor DarkGray\r\n"
        "Start-Sleep -Seconds 5\r\n",
        versionA
    );

    // ── Write the script file to disk ────────────────────────────────────────
    HANDLE hFile = CreateFileW(ps1Path, GENERIC_WRITE, 0, NULL,
        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE) return;
    DWORD written = 0;
    WriteFile(hFile, script, (DWORD)strlen(script), &written, NULL);
    CloseHandle(hFile);

    // ── Launch in a visible PowerShell console window ─────────────────────────
    wchar_t args[MAX_PATH + 128] = {0};
    swprintf(args, MAX_PATH + 128,
        L"-NoProfile -ExecutionPolicy Bypass -File \"%ls\"",
        ps1Path);

    ShellExecuteW(NULL, L"open", L"powershell.exe", args, NULL, SW_NORMAL);
}


// ── Fullscreen App Detection ─────────────────────────────────────────────────
bool IsShellProcess(DWORD pid) {
    if (pid == 0) return true;

    // Check explorer process id
    DWORD explorerPid = 0;
    HWND hShell = GetShellWindow();
    if (hShell) {
        GetWindowThreadProcessId(hShell, &explorerPid);
    } else {
        HWND hTb = FindWindow(L"Shell_TrayWnd", NULL);
        if (hTb) GetWindowThreadProcessId(hTb, &explorerPid);
    }
    if (pid == explorerPid) return true;

    // Check process executable name
    HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
    if (hProcess) {
        wchar_t exePath[MAX_PATH] = {0};
        DWORD size = MAX_PATH;
        if (QueryFullProcessImageNameW(hProcess, 0, exePath, &size)) {
            const wchar_t* fileName = wcsrchr(exePath, L'\\');
            if (fileName) fileName++;
            else fileName = exePath;

            if (_wcsicmp(fileName, L"explorer.exe") == 0 ||
                _wcsicmp(fileName, L"StartMenuExperienceHost.exe") == 0 ||
                _wcsicmp(fileName, L"SearchHost.exe") == 0 ||
                _wcsicmp(fileName, L"ShellExperienceHost.exe") == 0 ||
                _wcsicmp(fileName, L"TextInputHost.exe") == 0 ||
                _wcsicmp(fileName, L"ScreenClippingHost.exe") == 0 ||
                _wcsicmp(fileName, L"SnippingTool.exe") == 0 ||
                _wcsicmp(fileName, L"SnippingToolApp.exe") == 0 ||
                _wcsicmp(fileName, L"SnipAndSketch.exe") == 0 ||
                _wcsicmp(fileName, L"GameBar.exe") == 0 ||
                _wcsicmp(fileName, L"GameBarFTServer.exe") == 0 ||
                _wcsicmp(fileName, L"LockApp.exe") == 0 ||
                _wcsicmp(fileName, L"SystemSettings.exe") == 0 ||
                wcsstr(fileName, L"ScreenClip") != NULL ||
                wcsstr(fileName, L"Snipping") != NULL) {
                CloseHandle(hProcess);
                return true;
            }
        }
        CloseHandle(hProcess);
    }
    return false;
}

// Returns true if the foreground window is in true fullscreen mode
// (e.g. YouTube fullscreen, media players, games, F11 browser) on the same monitor as Tithify.
bool IsFullscreenAppRunning() {
    if (!g_hWnd || g_setupMode) return false;

    // 1. Primary Check: Windows notification state
    // When in standard desktop mode (working with apps, browsing web, Start menu, Show Desktop):
    // SHQueryUserNotificationState reports QUNS_ACCEPTS_NOTIFICATIONS (5) or QUNS_APP (7).
    // Windows only sets QUNS_BUSY (2), QUNS_RUNNING_D3D_FULL_SCREEN (3), or QUNS_PRESENTATION_MODE (4)
    // when a genuine full-screen application (like YouTube fullscreen, video players, games) is active.
    QUERY_USER_NOTIFICATION_STATE quns = (QUERY_USER_NOTIFICATION_STATE)0;
    if (SUCCEEDED(SHQueryUserNotificationState(&quns))) {
        if (quns != QUNS_BUSY &&
            quns != QUNS_RUNNING_D3D_FULL_SCREEN &&
            quns != QUNS_PRESENTATION_MODE) {
            return false;
        }
    }

    // 2. Verify the active foreground window
    HWND hForeground = GetForegroundWindow();
    if (!hForeground) return false;

    // Desktop and shell windows are never fullscreen apps
    if (hForeground == GetDesktopWindow() || hForeground == GetShellWindow())
        return false;

    // Ignore our own widget windows
    if (hForeground == g_hWnd || hForeground == g_hCalWnd || hForeground == g_hMenuWnd)
        return false;

    // Ignore transparent / click-through overlay windows (e.g. snipping tool overlay)
    LONG_PTR exStyle = GetWindowLongPtrW(hForeground, GWL_EXSTYLE);
    if (exStyle & WS_EX_TRANSPARENT) {
        return false;
    }

    // Ignore Windows Explorer / Desktop / Taskbar / Shell / Snipping window classes
    wchar_t cls[256] = {0};
    if (GetClassNameW(hForeground, cls, 256) > 0) {
        if (wcscmp(cls, L"WorkerW") == 0 ||
            wcscmp(cls, L"Progman") == 0 ||
            wcscmp(cls, L"Shell_TrayWnd") == 0 ||
            wcscmp(cls, L"Shell_SecondaryTrayWnd") == 0 ||
            wcscmp(cls, L"SHELLDLL_DefView") == 0 ||
            wcscmp(cls, L"SysListView32") == 0 ||
            wcscmp(cls, L"Windows.UI.Core.CoreWindow") == 0 ||
            wcscmp(cls, L"XamlExplorerHostIslandWindow") == 0 ||
            wcscmp(cls, L"Xaml_WindowedPopupClass") == 0 ||
            wcscmp(cls, L"TopLevelWindowForOverflowXamlIsland") == 0 ||
            wcscmp(cls, L"ScreenClippingHost") == 0 ||
            wcscmp(cls, L"SnippingTool") == 0 ||
            wcsstr(cls, L"ScreenClip") != NULL ||
            wcsstr(cls, L"Snipping") != NULL) {
            return false;
        }
    }

    // Check window title for snipping tools
    wchar_t title[256] = {0};
    if (GetWindowTextW(hForeground, title, 256) > 0) {
        if (wcsstr(title, L"Snipping") != NULL ||
            wcsstr(title, L"Screen Clipping") != NULL ||
            wcsstr(title, L"Snip & Sketch") != NULL) {
            return false;
        }
    }

    // Check process ID: never consider shell host or snipping tool processes as fullscreen apps
    DWORD fgPid = 0;
    GetWindowThreadProcessId(hForeground, &fgPid);
    if (IsShellProcess(fgPid)) {
        return false;
    }

    // 3. Multi-Monitor Awareness: only hide if fullscreen app is on the same monitor as Tithify
    HMONITOR hMonApp = MonitorFromWindow(hForeground, MONITOR_DEFAULTTONEAREST);
    HMONITOR hMonWidget = MonitorFromWindow(g_hWnd, MONITOR_DEFAULTTONEAREST);
    if (!hMonApp || !hMonWidget || hMonApp != hMonWidget) {
        return false;
    }

    MONITORINFO mi = { sizeof(mi) };
    if (!GetMonitorInfo(hMonApp, &mi)) return false;

    RECT rcWnd;
    if (!GetWindowRect(hForeground, &rcWnd)) return false;

    // 4. Geometry Check: ensure window covers the entire monitor
    bool coversMonitor = (rcWnd.left   <= mi.rcMonitor.left  &&
                          rcWnd.top    <= mi.rcMonitor.top   &&
                          rcWnd.right  >= mi.rcMonitor.right &&
                          rcWnd.bottom >= mi.rcMonitor.bottom);
    if (!coversMonitor) return false;

    return true;
}

// ── Desktop Host Window Resolver ──────────────────────────────────────────────
HWND GetDesktopHostWindow() {
    HWND hProgman = FindWindowW(L"Progman", NULL);
    if (hProgman && FindWindowExW(hProgman, NULL, L"SHELLDLL_DefView", NULL)) {
        return hProgman;
    }
    HWND hWorker = NULL;
    while ((hWorker = FindWindowExW(NULL, hWorker, L"WorkerW", NULL)) != NULL) {
        if (FindWindowExW(hWorker, NULL, L"SHELLDLL_DefView", NULL)) {
            return hWorker;
        }
    }
    return hProgman ? hProgman : GetShellWindow();
}

// ── Real-Time Shell / Foreground Event Hook ──────────────────────────────────
HWINEVENTHOOK g_hEventHook = NULL;

void CALLBACK WinEventProc(HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd,
                           LONG idObject, LONG idChild, DWORD dwEventThread, DWORD dwmsEventTime) {
    if (!g_hWnd || !IsWindow(g_hWnd) || g_hiddenForFullscreen || g_hiddenForTaskbar) return;

    // When foreground window or focus changes across the system (Start, Search, Taskbar, Show Desktop),
    // immediately ensure Tithify is not iconic and sits in the proper z-order.
    if (IsIconic(g_hWnd)) {
        ShowWindow(g_hWnd, SW_RESTORE);
    }
    if (!g_isMenuOpen && !g_isCalendarOpen) {
        if (g_setupMode || g_isOnTaskbar) {
            SetWindowPos(g_hWnd, HWND_TOPMOST, 0, 0, 0, 0,
                         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
        } else {
            HWND hDesktop = GetDesktopHostWindow();
            if (hDesktop && (HWND)GetWindowLongPtr(g_hWnd, GWLP_HWNDPARENT) != hDesktop) {
                SetWindowLongPtr(g_hWnd, GWLP_HWNDPARENT, (LONG_PTR)hDesktop);
            }
            SetWindowPos(g_hWnd, HWND_BOTTOM, 0, 0, 0, 0,
                         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
        }
    }
}

// ── Auto-Hide Taskbar Sync & Animation State ─────────────────────────────────
struct TaskbarSyncState {
    bool isAutoHide = false;
    bool isCompletelyHidden = false;
    int shiftX = 0;
    int shiftY = 0;
};

TaskbarSyncState GetTaskbarSyncState() {
    TaskbarSyncState state;
    APPBARDATA abd = { sizeof(APPBARDATA) };
    UINT abState = (UINT)SHAppBarMessage(ABM_GETSTATE, &abd);
    state.isAutoHide = (abState & ABS_AUTOHIDE) != 0;
    if (!state.isAutoHide) return state;

    HWND hTaskbar = FindWindowW(L"Shell_TrayWnd", NULL);
    if (!hTaskbar) return state;

    RECT rcTaskbar;
    if (!GetWindowRect(hTaskbar, &rcTaskbar)) return state;

    HMONITOR hMon = MonitorFromWindow(hTaskbar, MONITOR_DEFAULTTONEAREST);
    MONITORINFO mi = { sizeof(mi) };
    GetMonitorInfo(hMon, &mi);

    static int s_expandedHeight = 48;
    static int s_expandedWidth = 48;

    int tbHeight = rcTaskbar.bottom - rcTaskbar.top;
    int tbWidth = rcTaskbar.right - rcTaskbar.left;
    if (tbHeight > 10) s_expandedHeight = tbHeight;
    if (tbWidth > 10) s_expandedWidth = tbWidth;

    // Bottom Taskbar:
    if (rcTaskbar.bottom >= mi.rcMonitor.bottom - 10) {
        int normalTop = mi.rcMonitor.bottom - s_expandedHeight;
        state.shiftY = rcTaskbar.top - normalTop;
        if (state.shiftY < 0) state.shiftY = 0;
        if (tbHeight <= 4 || rcTaskbar.top >= mi.rcMonitor.bottom - 4) {
            state.isCompletelyHidden = true;
        }
    }
    // Top Taskbar:
    else if (rcTaskbar.top <= mi.rcMonitor.top + 10) {
        int normalBottom = mi.rcMonitor.top + s_expandedHeight;
        state.shiftY = rcTaskbar.bottom - normalBottom;
        if (state.shiftY > 0) state.shiftY = 0;
        if (tbHeight <= 4 || rcTaskbar.bottom <= mi.rcMonitor.top + 4) {
            state.isCompletelyHidden = true;
        }
    }
    // Right Taskbar:
    else if (rcTaskbar.right >= mi.rcMonitor.right - 10) {
        int normalLeft = mi.rcMonitor.right - s_expandedWidth;
        state.shiftX = rcTaskbar.left - normalLeft;
        if (state.shiftX < 0) state.shiftX = 0;
        if (tbWidth <= 4 || rcTaskbar.left >= mi.rcMonitor.right - 4) {
            state.isCompletelyHidden = true;
        }
    }
    // Left Taskbar:
    else if (rcTaskbar.left <= mi.rcMonitor.left + 10) {
        int normalRight = mi.rcMonitor.left + s_expandedWidth;
        state.shiftX = rcTaskbar.right - normalRight;
        if (state.shiftX > 0) state.shiftX = 0;
        if (tbWidth <= 4 || rcTaskbar.right <= mi.rcMonitor.left + 4) {
            state.isCompletelyHidden = true;
        }
    }

    return state;
}

// ── Taskbar vs Desktop Location Auto-Detection ───────────────────────────────
bool IsPositionOnTaskbar(int x, int y, int w, int h) {
    RECT rcWidget = { x, y, x + w, y + h };
    POINT center = { x + w / 2, y + h / 2 };

    HMONITOR hMon = MonitorFromRect(&rcWidget, MONITOR_DEFAULTTONEAREST);
    if (!hMon) return false;

    MONITORINFO mi = { sizeof(mi) };
    if (!GetMonitorInfo(hMon, &mi)) return false;

    HWND hTaskbar = FindWindowW(L"Shell_TrayWnd", NULL);
    RECT rcTaskbar = { 0 };
    bool taskbarFound = false;
    if (hTaskbar) {
        taskbarFound = (GetWindowRect(hTaskbar, &rcTaskbar) != 0);
    }

    int tbHeight = rcTaskbar.bottom - rcTaskbar.top;
    int tbWidth = rcTaskbar.right - rcTaskbar.left;

    RECT rcTaskbarArea = { 0 };

    // 1. Standard taskbar: Monitor work area differs from monitor rect
    if (mi.rcWork.bottom < mi.rcMonitor.bottom) {
        rcTaskbarArea = { mi.rcMonitor.left, mi.rcWork.bottom, mi.rcMonitor.right, mi.rcMonitor.bottom };
    } else if (mi.rcWork.top > mi.rcMonitor.top) {
        rcTaskbarArea = { mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right, mi.rcWork.top };
    } else if (mi.rcWork.left > mi.rcMonitor.left) {
        rcTaskbarArea = { mi.rcMonitor.left, mi.rcMonitor.top, mi.rcWork.left, mi.rcMonitor.bottom };
    } else if (mi.rcWork.right < mi.rcMonitor.right) {
        rcTaskbarArea = { mi.rcWork.right, mi.rcMonitor.top, mi.rcMonitor.right, mi.rcMonitor.bottom };
    } else if (taskbarFound) {
        // 2. Auto-hide taskbar (work area equals monitor rect)
        if (tbHeight > 10 && tbWidth > 10) {
            rcTaskbarArea = rcTaskbar;
        } else {
            // Taskbar is collapsed auto-hide bar: synthesize expanded rect at the monitor edge
            int defH = (int)(48 * g_dpiScale);
            if (rcTaskbar.bottom >= mi.rcMonitor.bottom - 10) {
                rcTaskbarArea = { mi.rcMonitor.left, mi.rcMonitor.bottom - defH, mi.rcMonitor.right, mi.rcMonitor.bottom };
            } else if (rcTaskbar.top <= mi.rcMonitor.top + 10) {
                rcTaskbarArea = { mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right, mi.rcMonitor.top + defH };
            } else if (rcTaskbar.right >= mi.rcMonitor.right - 10) {
                rcTaskbarArea = { mi.rcMonitor.right - defH, mi.rcMonitor.top, mi.rcMonitor.right, mi.rcMonitor.bottom };
            } else if (rcTaskbar.left <= mi.rcMonitor.left + 10) {
                rcTaskbarArea = { mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.left + defH, mi.rcMonitor.bottom };
            }
        }
    } else {
        // 3. Fallback: bottom 48px of primary monitor
        int defH = (int)(48 * g_dpiScale);
        rcTaskbarArea = { mi.rcMonitor.left, mi.rcMonitor.bottom - defH, mi.rcMonitor.right, mi.rcMonitor.bottom };
    }

    // Test if widget center point or >30% overlap lies in taskbar area
    if (PtInRect(&rcTaskbarArea, center)) {
        return true;
    }

    RECT rcIntersect;
    if (IntersectRect(&rcIntersect, &rcWidget, &rcTaskbarArea)) {
        int intersectArea = (rcIntersect.right - rcIntersect.left) * (rcIntersect.bottom - rcIntersect.top);
        int widgetArea = w * h;
        if (intersectArea > widgetArea / 3) {
            return true;
        }
    }

    return false;
}

void UpdateWidgetMode() {
    if (!g_hWnd) return;
    int winW = (int)((g_showDay ? 190 : 155) * g_dpiScale);
    int winH = (int)(48 * g_dpiScale);

    g_isOnTaskbar = IsPositionOnTaskbar(g_xPos, g_yPos, winW, winH);

    // In Win32, an owned popup window is always placed above its owner in Z-order.
    // - When on taskbar: owner is Shell_TrayWnd so Tithify stays naturally above the taskbar.
    // - When on desktop: owner is Progman / WorkerW (desktop host) so Tithify stays directly
    //   above the desktop wallpaper and never disappears when "Show Desktop" (Win+D) is invoked.
    HWND hTaskbar = FindWindowW(L"Shell_TrayWnd", NULL);
    HWND hDesktop = GetDesktopHostWindow();

    if (g_isOnTaskbar) {
        if (hTaskbar) SetWindowLongPtr(g_hWnd, GWLP_HWNDPARENT, (LONG_PTR)hTaskbar);
        else SetWindowLongPtr(g_hWnd, GWLP_HWNDPARENT, 0);
    } else {
        if (hDesktop) SetWindowLongPtr(g_hWnd, GWLP_HWNDPARENT, (LONG_PTR)hDesktop);
        else SetWindowLongPtr(g_hWnd, GWLP_HWNDPARENT, 0);
    }

    LONG_PTR exStyle = GetWindowLongPtr(g_hWnd, GWL_EXSTYLE);
    if (g_setupMode || g_isOnTaskbar) {
        // Setup mode (unlocked for dragging) or taskbar mode: keep TOPMOST
        if (!(exStyle & WS_EX_TOPMOST)) {
            SetWindowLongPtr(g_hWnd, GWL_EXSTYLE, exStyle | WS_EX_TOPMOST);
        }
        SetWindowPos(g_hWnd, HWND_TOPMOST, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
    } else {
        // Locked on desktop: behave like a desktop icon (bottom of window stack)
        if (exStyle & WS_EX_TOPMOST) {
            SetWindowLongPtr(g_hWnd, GWL_EXSTYLE, exStyle & ~WS_EX_TOPMOST);
        }
        SetWindowPos(g_hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
        SetWindowPos(g_hWnd, HWND_BOTTOM, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
    }
}



std::wstring GetConfigPath() {
    wchar_t path[MAX_PATH];
    GetModuleFileNameW(NULL, path, MAX_PATH);
    std::wstring ws(path);
    size_t pos = ws.find_last_of(L"\\/");
    if (pos != std::wstring::npos) {
        ws = ws.substr(0, pos);
    }
    return ws + L"\\tithify.cfg";
}

void RenderWidget(HWND hWnd);

void LoadConfig() {
    std::wstring path = GetConfigPath();
    std::string npath(path.begin(), path.end());
    FILE* file = fopen(npath.c_str(), "r");
    if (!file) {
        // Fallback for legacy widget.cfg
        wchar_t exePath[MAX_PATH];
        GetModuleFileNameW(NULL, exePath, MAX_PATH);
        std::wstring ws(exePath);
        size_t pos = ws.find_last_of(L"\\/");
        if (pos != std::wstring::npos) ws = ws.substr(0, pos);
        std::wstring legacyPath = ws + L"\\widget.cfg";
        std::string nLegacy(legacyPath.begin(), legacyPath.end());
        file = fopen(nLegacy.c_str(), "r");
    }
    if (file) {
        int x, y, setup, showDay = 1, bgPreset = 0, opacity = 200;
        unsigned int colorVal = (unsigned int)RGB(31, 31, 31);
        int n = fscanf(file, "%d,%d,%d,%d,%u,%d,%d", &x, &y, &setup, &showDay, &colorVal, &opacity, &bgPreset);
        if (n >= 3) {
            g_xPos = x;
            g_yPos = y;
            g_setupMode = (setup != 0);
            if (n >= 4) g_showDay = (showDay != 0);
            if (n >= 5) g_bgColorRGB = (COLORREF)colorVal;
            if (n >= 6) g_bgOpacity = opacity;
            if (n >= 7) g_bgPresetMode = bgPreset;
        }
        fclose(file);
    }
}

void SaveConfig() {
    std::wstring path = GetConfigPath();
    std::string npath(path.begin(), path.end());
    FILE* file = fopen(npath.c_str(), "w");
    if (file) {
        fprintf(file, "%d,%d,%d,%d,%u,%d,%d",
                g_xPos, g_yPos, g_setupMode ? 1 : 0, g_showDay ? 1 : 0,
                (unsigned int)g_bgColorRGB, g_bgOpacity, g_bgPresetMode);
        fclose(file);
    }
}

bool PickCustomBackgroundColor(HWND hWndOwner) {
    static COLORREF custColors[16] = {
        RGB(255,255,255), RGB(0,0,0), RGB(240,240,240), RGB(32,32,32),
        RGB(230,50,50), RGB(50,180,50), RGB(50,120,240), RGB(240,180,50),
        RGB(150,50,200), RGB(50,200,200), RGB(255,128,0), RGB(128,128,128),
        RGB(64,64,64), RGB(192,192,192), RGB(255,192,203), RGB(128,0,0)
    };

    CHOOSECOLORW cc = { sizeof(CHOOSECOLORW) };
    cc.hwndOwner = hWndOwner;
    cc.lpCustColors = custColors;
    cc.rgbResult = g_bgColorRGB;
    cc.Flags = CC_FULLOPEN | CC_RGBINIT;

    if (ChooseColorW(&cc)) {
        g_bgColorRGB = cc.rgbResult;
        g_bgPresetMode = 1; // Custom color mode
        SaveConfig();
        if (g_hWnd) RenderWidget(g_hWnd);
        return true;
    }
    return false;
}

// ── Startup Registry Helpers ────────────────────────────────────────────────
static const wchar_t* STARTUP_REG_KEY = L"Software\\Microsoft\\Windows\\CurrentVersion\\Run";
static const wchar_t* STARTUP_REG_VALUE = L"Tithify";

bool IsStartupEnabled() {
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, STARTUP_REG_KEY, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
        return false;
    DWORD type = 0, size = 0;
    bool exists = (RegQueryValueExW(hKey, STARTUP_REG_VALUE, NULL, &type, NULL, &size) == ERROR_SUCCESS);
    RegCloseKey(hKey);
    return exists;
}

void SetStartupEnabled(bool enable) {
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, STARTUP_REG_KEY, 0, KEY_SET_VALUE, &hKey) != ERROR_SUCCESS)
        return;
    if (enable) {
        wchar_t exePath[MAX_PATH];
        GetModuleFileNameW(NULL, exePath, MAX_PATH);
        std::wstring val = std::wstring(L"\"") + exePath + L"\"";
        RegSetValueExW(hKey, STARTUP_REG_VALUE, 0, REG_SZ,
                       (const BYTE*)val.c_str(), (DWORD)((val.size() + 1) * sizeof(wchar_t)));
    } else {
        RegDeleteValueW(hKey, STARTUP_REG_VALUE);
    }
    RegCloseKey(hKey);
}

// ── Nepali Date Calculator (Pure C++) ────────────────────────────────────────
#include "bs_data.h"

const wchar_t* kNepaliMonthNamesEN[] = {
    L"Baisakh", L"Jestha", L"Ashadh", L"Shrawan", L"Bhadra", L"Ashwin",
    L"Kartik", L"Mangsir", L"Poush", L"Magh", L"Falgun", L"Chaitra"
};

const wchar_t* kNepaliMonthNamesNP[] = {
    L"\u092C\u0948\u0936\u093E\u0916",             // Baisakh (बैशाख)
    L"\u091C\u0947\u0920",                         // Jestha (जेठ)
    L"\u0905\u0938\u093E\u0930",                   // Ashadh (असार)
    L"\u0936\u094D\u0930\u093E\u0935\u0923",       // Shrawan (श्रावण)
    L"\u092D\u0926\u094C",                         // Bhadra (भदौ)
    L"\u0905\u0938\u094B\u091C",                   // Ashwin (असोज)
    L"\u0915\u093E\u0930\u094D\u0924\u093F\u0915", // Kartik (कार्तिक)
    L"\u092E\u0902\u0938\u093F\u0930",             // Mangsir (मंसिर)
    L"\u092A\u0941\u0937",                         // Poush (पुष)
    L"\u092E\u093E\u0918",                         // Magh (माघ)
    L"\u092B\u093E\u0932\u094D\u0917\u0941\u0928", // Falgun (फाल्गुन)
    L"\u091A\u0948\u0924"                          // Chaitra (चैत)
};

const wchar_t* kEnglishMonthNames[] = {
    L"January", L"February", L"March", L"April", L"May", L"June",
    L"July", L"August", L"September", L"October", L"November", L"December"
};

const wchar_t* kNepaliDayNamesEN[] = {
    L"Sunday", L"Monday", L"Tuesday", L"Wednesday", L"Thursday", L"Friday", L"Saturday"
};

const wchar_t* kNepaliDayNamesNP[] = {
    L"\u0906\u0907\u0924\u092C\u093E\u0930",  // Sunday (आइतबार)
    L"\u0938\u094B\u092E\u092C\u093E\u0930",  // Monday (सोमबार)
    L"\u092E\u0902\u0917\u0932\u092C\u093E\u0930", // Tuesday (मंगलबार)
    L"\u092C\u0941\u0927\u092C\u093E\u0930",  // Wednesday (बुधबार)
    L"\u092C\u093F\u0939\u0940\u092C\u093E\u0930", // Thursday (बिहीबार)
    L"\u0936\u0941\u0915\u094D\u0930\u092C\u093E\u0930", // Friday (शुक्रबार)
    L"\u0936\u0928\u093F\u092C\u093E\u0930"   // Saturday (शनिबार)
};

// ── Forward declaration for Calendar window handle ───────────────────────────
extern HWND g_hCalWnd;

// ── Nepali Public Holidays & Notable Festivals Engine ────────────────────────
struct NepaliHoliday {
    int month;          // 1 = Baisakh, ..., 12 = Chaitra
    int day;            // Day of BS month (1..32)
    bool isPublicHoliday;
    std::wstring titleNP;
    std::wstring titleEN;
    std::wstring category;
    std::wstring description;
};

enum HolidayFetchState {
    FETCH_IDLE,
    FETCH_SUCCESS,
    FETCH_DOWNLOADING,
    FETCH_ERROR_OFFLINE
};

#define HOLIDAY_FILE_MAGIC 0x4857444E
#define HOLIDAY_FILE_VERSION 1
#define ENCODE_XOR_KEY 0x5A

int g_loadedHolidayYear = 0;
std::vector<NepaliHoliday> g_currentYearHolidays;
HolidayFetchState g_holidayFetchState = FETCH_IDLE;
bool g_isHolidayFetchInProgress = false;
DWORD g_lastHolidayFetchAttemptTime = 0;

std::string WideToUtf8(const std::wstring& wstr) {
    if (wstr.empty()) return "";
    int len = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.size(), NULL, 0, NULL, NULL);
    std::string str(len, 0);
    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.size(), &str[0], len, NULL, NULL);
    return str;
}

std::wstring Utf8ToWide(const std::string& str) {
    if (str.empty()) return L"";
    int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), NULL, 0);
    std::wstring wstr(len, 0);
    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), &wstr[0], len);
    return wstr;
}

std::wstring GetHolidayCachePath(int bsYear) {
    wchar_t appDataPath[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath))) {
        std::wstring dir = std::wstring(appDataPath) + L"\\Tithify";
        CreateDirectoryW(dir.c_str(), NULL);
        return dir + L"\\holidays_" + std::to_wstring(bsYear) + L".dat";
    }
    wchar_t path[MAX_PATH];
    GetModuleFileNameW(NULL, path, MAX_PATH);
    std::wstring ws(path);
    size_t pos = ws.find_last_of(L"\\/");
    if (pos != std::wstring::npos) {
        ws = ws.substr(0, pos);
    }
    return ws + L"\\holidays_" + std::to_wstring(bsYear) + L".dat";
}

bool SaveEncodedHolidayFile(int bsYear, const std::vector<NepaliHoliday>& holidays) {
    std::wstring filePath = GetHolidayCachePath(bsYear);
    FILE* f = _wfopen(filePath.c_str(), L"wb");
    if (!f) return false;

    uint32_t magic = HOLIDAY_FILE_MAGIC;
    uint16_t version = HOLIDAY_FILE_VERSION;
    uint16_t year = (uint16_t)bsYear;
    uint16_t count = (uint16_t)holidays.size();

    fwrite(&magic, sizeof(magic), 1, f);
    fwrite(&version, sizeof(version), 1, f);
    fwrite(&year, sizeof(year), 1, f);
    fwrite(&count, sizeof(count), 1, f);

    for (const auto& h : holidays) {
        uint8_t m = (uint8_t)h.month;
        uint8_t d = (uint8_t)h.day;
        uint8_t pub = h.isPublicHoliday ? 1 : 0;
        fwrite(&m, sizeof(m), 1, f);
        fwrite(&d, sizeof(d), 1, f);
        fwrite(&pub, sizeof(pub), 1, f);

        auto writeEncStr = [&](const std::wstring& ws) {
            std::string utf8 = WideToUtf8(ws);
            uint16_t len = (uint16_t)utf8.size();
            fwrite(&len, sizeof(len), 1, f);
            for (size_t i = 0; i < utf8.size(); ++i) {
                uint8_t b = (uint8_t)utf8[i] ^ ENCODE_XOR_KEY;
                fwrite(&b, 1, 1, f);
            }
        };

        writeEncStr(h.titleNP);
        writeEncStr(h.titleEN);
        writeEncStr(h.category);
        writeEncStr(h.description);
    }
    fclose(f);
    return true;
}

bool LoadEncodedHolidayFile(int bsYear, std::vector<NepaliHoliday>& outHolidays) {
    std::wstring filePath = GetHolidayCachePath(bsYear);
    FILE* f = _wfopen(filePath.c_str(), L"rb");
    if (!f) return false;

    uint32_t magic = 0;
    uint16_t version = 0;
    uint16_t year = 0;
    uint16_t count = 0;

    if (fread(&magic, sizeof(magic), 1, f) != 1 || magic != HOLIDAY_FILE_MAGIC) { fclose(f); return false; }
    if (fread(&version, sizeof(version), 1, f) != 1 || version != HOLIDAY_FILE_VERSION) { fclose(f); return false; }
    if (fread(&year, sizeof(year), 1, f) != 1 || year != bsYear) { fclose(f); return false; }
    if (fread(&count, sizeof(count), 1, f) != 1) { fclose(f); return false; }

    outHolidays.clear();
    for (uint16_t i = 0; i < count; ++i) {
        NepaliHoliday h;
        uint8_t m = 0, d = 0, pub = 0;
        if (fread(&m, sizeof(m), 1, f) != 1) break;
        if (fread(&d, sizeof(d), 1, f) != 1) break;
        if (fread(&pub, sizeof(pub), 1, f) != 1) break;
        h.month = m;
        h.day = d;
        h.isPublicHoliday = (pub != 0);

        auto readEncStr = [&]() -> std::wstring {
            uint16_t len = 0;
            if (fread(&len, sizeof(len), 1, f) != 1) return L"";
            std::string utf8(len, '\0');
            for (uint16_t j = 0; j < len; ++j) {
                uint8_t b = 0;
                if (fread(&b, 1, 1, f) != 1) break;
                utf8[j] = (char)(b ^ ENCODE_XOR_KEY);
            }
            return Utf8ToWide(utf8);
        };

        h.titleNP = readEncStr();
        h.titleEN = readEncStr();
        h.category = readEncStr();
        h.description = readEncStr();
        outHolidays.push_back(h);
    }
    fclose(f);
    return !outHolidays.empty();
}

bool ParseHolidaysJson(const std::string& json, int expectedYear, std::vector<NepaliHoliday>& outHolidays) {
    outHolidays.clear();
    const char* p = json.c_str();
    const char* holArray = strstr(p, "\"holidays\"");
    if (!holArray) return false;

    const char* openBracket = strchr(holArray, '[');
    if (!openBracket) return false;

    p = openBracket + 1;
    while (*p && *p != ']') {
        const char* objStart = strchr(p, '{');
        if (!objStart) break;
        const char* objEnd = strchr(objStart, '}');
        if (!objEnd) break;

        std::string obj(objStart, objEnd - objStart + 1);
        NepaliHoliday h;
        h.month = 0;
        h.day = 0;
        h.isPublicHoliday = false;

        const char* mStr = strstr(obj.c_str(), "\"month\"");
        if (mStr) {
            mStr += 7;
            while (*mStr == ' ' || *mStr == ':') mStr++;
            h.month = atoi(mStr);
        }

        const char* dStr = strstr(obj.c_str(), "\"day\"");
        if (dStr) {
            dStr += 5;
            while (*dStr == ' ' || *dStr == ':') dStr++;
            h.day = atoi(dStr);
        }

        const char* pubStr = strstr(obj.c_str(), "\"isPublicHoliday\"");
        if (pubStr) {
            pubStr += 17;
            while (*pubStr == ' ' || *pubStr == ':') pubStr++;
            if (strncmp(pubStr, "true", 4) == 0) h.isPublicHoliday = true;
        }

        auto extractStr = [](const std::string& src, const char* key) -> std::wstring {
            std::string searchKey = std::string("\"") + key + "\"";
            const char* kPos = strstr(src.c_str(), searchKey.c_str());
            if (!kPos) return L"";
            kPos += searchKey.size();
            while (*kPos == ' ' || *kPos == ':') kPos++;
            if (*kPos != '"') return L"";
            kPos++;

            std::string val = "";
            while (*kPos && *kPos != '"') {
                if (*kPos == '\\' && *(kPos + 1)) {
                    kPos++;
                    if (*kPos == 'u' && isxdigit(*(kPos+1)) && isxdigit(*(kPos+2)) && isxdigit(*(kPos+3)) && isxdigit(*(kPos+4))) {
                        char hex[5] = { *(kPos+1), *(kPos+2), *(kPos+3), *(kPos+4), 0 };
                        wchar_t wc = (wchar_t)strtol(hex, NULL, 16);
                        wchar_t tempW[2] = { wc, 0 };
                        char tempUtf8[8] = { 0 };
                        WideCharToMultiByte(CP_UTF8, 0, tempW, 1, tempUtf8, sizeof(tempUtf8), NULL, NULL);
                        val += tempUtf8;
                        kPos += 4;
                    } else if (*kPos == 'n') {
                        val += '\n';
                    } else if (*kPos == 't') {
                        val += '\t';
                    } else if (*kPos == '"') {
                        val += '"';
                    } else if (*kPos == '\\') {
                        val += '\\';
                    } else {
                        val += *kPos;
                    }
                } else {
                    val += *kPos;
                }
                kPos++;
            }
            return Utf8ToWide(val);
        };

        h.titleNP = extractStr(obj, "titleNP");
        h.titleEN = extractStr(obj, "titleEN");
        h.category = extractStr(obj, "category");
        h.description = extractStr(obj, "description");

        if (h.month >= 1 && h.month <= 12 && h.day >= 1 && h.day <= 32) {
            outHolidays.push_back(h);
        }

        p = objEnd + 1;
    }

    return !outHolidays.empty();
}

bool HttpDownloadString(const wchar_t* host, const wchar_t* path, std::string& outBody) {
    HINTERNET hSession = WinHttpOpen(L"Tithify/" APP_VERSION,
        WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) return false;

    // Fast timeouts so offline / DNS failures return quickly and never freeze threads
    WinHttpSetTimeouts(hSession, 2000, 2500, 3000, 3000);

    HINTERNET hConnect = WinHttpConnect(hSession, host, INTERNET_DEFAULT_HTTPS_PORT, 0);
    if (!hConnect) {
        WinHttpCloseHandle(hSession);
        return false;
    }

    HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", path,
        NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);
    if (!hRequest) {
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        return false;
    }

    bool success = false;
    if (WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0) &&
        WinHttpReceiveResponse(hRequest, NULL)) {
        
        DWORD statusCode = 0;
        DWORD statusSize = sizeof(statusCode);
        WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
                            WINHTTP_HEADER_NAME_BY_INDEX, &statusCode, &statusSize, WINHTTP_NO_HEADER_INDEX);

        if (statusCode == 200) {
            std::string response;
            char buf[4096];
            DWORD bytesRead = 0;
            while (WinHttpReadData(hRequest, buf, sizeof(buf) - 1, &bytesRead) && bytesRead > 0) {
                buf[bytesRead] = 0;
                response.append(buf, bytesRead);
                bytesRead = 0;
            }
            if (!response.empty()) {
                outBody = response;
                success = true;
            }
        }
    }

    WinHttpCloseHandle(hRequest);
    WinHttpCloseHandle(hConnect);
    WinHttpCloseHandle(hSession);
    return success;
}

DWORD WINAPI FetchHolidaysThread(LPVOID lpParam) {
    int bsYear = (int)(INT_PTR)lpParam;
    g_isHolidayFetchInProgress = true;
    g_holidayFetchState = FETCH_DOWNLOADING;
    g_lastHolidayFetchAttemptTime = GetTickCount();

    std::string jsonBody;
    bool downloaded = false;

    // 1. Try primary GitHub raw URL
    std::wstring path1 = L"/aayushlbef/Tithify/main/data/holidays_" + std::to_wstring(bsYear) + L".json";
    if (HttpDownloadString(L"raw.githubusercontent.com", path1.c_str(), jsonBody)) {
        downloaded = true;
    }

    // 2. Try secondary jsDelivr CDN
    if (!downloaded) {
        std::wstring path2 = L"/gh/aayushlbef/Tithify@main/data/holidays_" + std::to_wstring(bsYear) + L".json";
        if (HttpDownloadString(L"cdn.jsdelivr.net", path2.c_str(), jsonBody)) {
            downloaded = true;
        }
    }

    if (downloaded) {
        std::vector<NepaliHoliday> parsed;
        if (ParseHolidaysJson(jsonBody, bsYear, parsed)) {
            SaveEncodedHolidayFile(bsYear, parsed);
            g_currentYearHolidays = parsed;
            g_loadedHolidayYear = bsYear;
            g_holidayFetchState = FETCH_SUCCESS;
            g_isHolidayFetchInProgress = false;
            if (g_hWnd) PostMessage(g_hWnd, WM_HOLIDAYS_LOADED, (WPARAM)bsYear, 0);
            return 0;
        }
    }

    // Failed to download and not available in cache
    g_holidayFetchState = FETCH_ERROR_OFFLINE;
    g_isHolidayFetchInProgress = false;
    if (g_hWnd) PostMessage(g_hWnd, WM_HOLIDAYS_FAILED, (WPARAM)bsYear, 0);
    return 0;
}

void EnsureHolidaysLoadedForCurrentYear(int bsYear, bool forceRefresh = false) {
    if (!forceRefresh && g_loadedHolidayYear == bsYear && g_holidayFetchState == FETCH_SUCCESS) {
        return;
    }

    // 1. Try encoded cache file first if not force refresh
    if (!forceRefresh) {
        std::vector<NepaliHoliday> cached;
        if (LoadEncodedHolidayFile(bsYear, cached)) {
            g_currentYearHolidays = cached;
            g_loadedHolidayYear = bsYear;
            g_holidayFetchState = FETCH_SUCCESS;
            return;
        }
    }

    // 2. Prevent multiple concurrent fetch threads
    if (g_isHolidayFetchInProgress) {
        return;
    }

    // 3. If offline failure already occurred and not force refresh, rate-limit retries (30-second cooldown)
    if (!forceRefresh && g_holidayFetchState == FETCH_ERROR_OFFLINE) {
        DWORD now = GetTickCount();
        if (now - g_lastHolidayFetchAttemptTime < 30000) {
            return;
        }
    }

    g_lastHolidayFetchAttemptTime = GetTickCount();
    HANDLE hThread = CreateThread(NULL, 0, FetchHolidaysThread, (LPVOID)(INT_PTR)bsYear, 0, NULL);
    if (hThread) CloseHandle(hThread);
}

const NepaliHoliday* GetHolidayForBS(int bsYear, int bsMonth, int bsDay) {
    if (g_holidayFetchState != FETCH_SUCCESS || g_loadedHolidayYear != bsYear) {
        return NULL;
    }
    for (size_t i = 0; i < g_currentYearHolidays.size(); ++i) {
        if (g_currentYearHolidays[i].month == bsMonth && g_currentYearHolidays[i].day == bsDay) {
            return &g_currentYearHolidays[i];
        }
    }
    return NULL;
}

inline int GetBSDaysInMonth(int bsYear, int bsMonth) {
    if (bsYear < 1975 || bsYear > 2100 || bsMonth < 1 || bsMonth > 12) return 30;
    return bs_month_days[bsYear - 1975][bsMonth - 1];
}

inline long long BSToDaysSinceEpoch(int bsYear, int bsMonth, int bsDay) {
    if (bsYear < 1975 || bsYear > 2100 || bsMonth < 1 || bsMonth > 12) return -1;
    long long days = 0;
    for (int y = 1975; y < bsYear; ++y) {
        for (int m = 0; m < 12; ++m) {
            days += bs_month_days[y - 1975][m];
        }
    }
    for (int m = 1; m < bsMonth; ++m) {
        days += bs_month_days[bsYear - 1975][m - 1];
    }
    days += (bsDay - 1);
    return days;
}

inline int GetBSMonthStartDayOfWeek(int bsYear, int bsMonth) {
    long long days = BSToDaysSinceEpoch(bsYear, bsMonth, 1);
    if (days < 0) return 0;
    return (int)((6 + days) % 7); // 0 = Sun, 1 = Mon, ..., 6 = Sat
}

inline bool BSToAD(int bsYear, int bsMonth, int bsDay, int& adYear, int& adMonth, int& adDay, int& outDayOfWeek) {
    long long days = BSToDaysSinceEpoch(bsYear, bsMonth, bsDay);
    if (days < 0) return false;
    outDayOfWeek = (int)((6 + days) % 7);

    SYSTEMTIME stRef = { 0 };
    stRef.wYear = 1918;
    stRef.wMonth = 4;
    stRef.wDay = 13;
    FILETIME ftRef;
    SystemTimeToFileTime(&stRef, &ftRef);

    ULARGE_INTEGER uRef;
    uRef.LowPart = ftRef.dwLowDateTime;
    uRef.HighPart = ftRef.dwHighDateTime;
    uRef.QuadPart += (ULONGLONG)days * 864000000000ULL;

    FILETIME ftTarget;
    ftTarget.dwLowDateTime = uRef.LowPart;
    ftTarget.dwHighDateTime = uRef.HighPart;
    SYSTEMTIME stTarget;
    FileTimeToSystemTime(&ftTarget, &stTarget);

    adYear = stTarget.wYear;
    adMonth = stTarget.wMonth;
    adDay = stTarget.wDay;
    return true;
}

inline bool ADToBS(int adYear, int adMonth, int adDay, int& bsYear, int& bsMonth, int& bsDay, int& outDayOfWeek) {
    SYSTEMTIME stNow = { 0 };
    stNow.wYear = (WORD)adYear;
    stNow.wMonth = (WORD)adMonth;
    stNow.wDay = (WORD)adDay;
    FILETIME ftNow;
    SystemTimeToFileTime(&stNow, &ftNow);

    SYSTEMTIME stRef = { 0 };
    stRef.wYear = 1918;
    stRef.wMonth = 4;
    stRef.wDay = 13;
    FILETIME ftRef;
    SystemTimeToFileTime(&stRef, &ftRef);

    ULARGE_INTEGER uNow, uRef;
    uNow.LowPart = ftNow.dwLowDateTime;
    uNow.HighPart = ftNow.dwHighDateTime;
    uRef.LowPart = ftRef.dwLowDateTime;
    uRef.HighPart = ftRef.dwHighDateTime;

    if (uNow.QuadPart < uRef.QuadPart) return false;
    long long diff = uNow.QuadPart - uRef.QuadPart;
    long long days = diff / 864000000000LL;
    outDayOfWeek = (int)((6 + days) % 7);

    int y = 1975;
    int m = 1;
    int d = 1;

    while (y <= 2100) {
        int dim = bs_month_days[y - 1975][m - 1];
        if (days >= dim) {
            days -= dim;
            m++;
            if (m > 12) {
                m = 1;
                y++;
            }
        } else {
            break;
        }
    }
    d += (int)days;
    if (y > 2100) return false;

    bsYear = y;
    bsMonth = m;
    bsDay = d;
    return true;
}

inline void GetCurrentBSDate(int& outYear, int& outMonth, int& outDay, int& outDayOfWeek) {
    SYSTEMTIME st;
    GetLocalTime(&st);
    ADToBS(st.wYear, st.wMonth, st.wDay, outYear, outMonth, outDay, outDayOfWeek);
}

inline std::wstring ToDevanagariNum(int num) {
    static const wchar_t devanagariDigits[] = { L'०', L'१', L'२', L'३', L'४', L'५', L'६', L'७', L'८', L'९' };
    wchar_t buf[32];
    swprintf(buf, 32, L"%d", num);
    std::wstring result = L"";
    for (int i = 0; buf[i] != 0; ++i) {
        if (buf[i] >= L'0' && buf[i] <= L'9') {
            result += devanagariDigits[buf[i] - L'0'];
        } else {
            result += buf[i];
        }
    }
    return result;
}

std::wstring GetNepaliDateString() {
    static WORD s_lastDay = 0, s_lastMonth = 0, s_lastYear = 0;
    static std::wstring s_cachedDateStr = L"";

    SYSTEMTIME st;
    GetLocalTime(&st);
    
    // Minimal resource check: only recalculate if the day has changed!
    if (st.wDay == s_lastDay && st.wMonth == s_lastMonth && st.wYear == s_lastYear && !s_cachedDateStr.empty()) {
        return s_cachedDateStr;
    }
    
    s_lastDay = st.wDay;
    s_lastMonth = st.wMonth;
    s_lastYear = st.wYear;
    
    int bs_year, bs_month, bs_day, bs_dow;
    if (!ADToBS(st.wYear, st.wMonth, st.wDay, bs_year, bs_month, bs_day, bs_dow)) {
        return L"Date Error";
    }
    
    wchar_t buffer[64];
    swprintf(buffer, 64, L"%d / %02d / %02d", bs_year, bs_month, bs_day);
    s_cachedDateStr = std::wstring(buffer);
    
    return s_cachedDateStr;
}

// ── Shared Drawing Helpers ───────────────────────────────────────────────────
void AddRoundedRectangle(GraphicsPath& path, REAL x, REAL y, REAL w, REAL h, REAL r) {
    REAL d = r * 2.0f;
    if (d > w) d = w;
    if (d > h) d = h;
    path.AddArc(x, y, d, d, 180, 90);
    path.AddArc(x + w - d, y, d, d, 270, 90);
    path.AddArc(x + w - d, y + h - d, d, d, 0, 90);
    path.AddArc(x, y + h - d, d, d, 90, 90);
    path.CloseFigure();
}

void DrawNepaliFlag(Graphics& graphics, REAL cx, REAL top, REAL h) {
    REAL flagWidth = 0.822f * h;
    SolidBrush blueBrush(Color(255, 0, 56, 147));
    SolidBrush crimsonBrush(Color(255, 220, 20, 60));
    SolidBrush whiteBrush(Color(255, 255, 255, 255));

    PointF polyOuter[5] = {
        PointF(cx, top),
        PointF(cx + 0.765f * h, top + 0.543f * h),
        PointF(cx + 0.266f * h, top + 0.543f * h),
        PointF(cx + 0.822f * h, top + h),
        PointF(cx, top + h)
    };
    graphics.FillPolygon(&blueBrush, polyOuter, 5);

    PointF polyInner[5] = {
        PointF(cx + 0.042f * h, top + 0.073f * h),
        PointF(cx + 0.674f * h, top + 0.501f * h),
        PointF(cx + 0.232f * h, top + 0.501f * h),
        PointF(cx + 0.715f * h, top + 0.958f * h),
        PointF(cx + 0.042f * h, top + 0.958f * h)
    };
    graphics.FillPolygon(&crimsonBrush, polyInner, 5);
    
    // Moon
    REAL moonOuterDiam = 0.20f * h;
    REAL moonOuterX = cx + 0.22f * h - (moonOuterDiam / 2.0f);
    REAL moonOuterY = top + 0.32f * h - (moonOuterDiam / 2.0f);
    graphics.FillEllipse(&whiteBrush, moonOuterX, moonOuterY, moonOuterDiam, moonOuterDiam);
    
    REAL moonInnerDiam = 0.18f * h;
    REAL moonInnerX = moonOuterX + 0.01f * h;
    REAL moonInnerY = moonOuterY - 0.04f * h;
    graphics.FillEllipse(&crimsonBrush, moonInnerX, moonInnerY, moonInnerDiam, moonInnerDiam);
    
    REAL moonStarDiam = 0.09f * h;
    REAL moonStarX = cx + 0.22f * h - (moonStarDiam / 2.0f);
    REAL moonStarY = top + 0.33f * h - (moonStarDiam / 2.0f);
    graphics.FillEllipse(&whiteBrush, moonStarX, moonStarY, moonStarDiam, moonStarDiam);

    // Sun
    REAL sunDiam = 0.18f * h;
    REAL sunX = cx + 0.26f * h - (sunDiam / 2.0f);
    REAL sunY = top + 0.73f * h - (sunDiam / 2.0f);
    graphics.FillEllipse(&whiteBrush, sunX, sunY, sunDiam, sunDiam);
}

void DrawIconButton(Graphics& graphics, const RectF& rect, const wchar_t* text, bool isHovered, bool isLight, Font& font) {
    GraphicsPath path;
    AddRoundedRectangle(path, rect.X, rect.Y, rect.Width, rect.Height, 6.0f * g_dpiScale);
    
    if (isHovered) {
        SolidBrush hoverBg(isLight ? Color(35, 0, 0, 0) : Color(45, 255, 255, 255));
        graphics.FillPath(&hoverBg, &path);
        Pen hoverBorder(isLight ? Color(70, 0, 0, 0) : Color(70, 255, 255, 255), 1.0f);
        graphics.DrawPath(&hoverBorder, &path);
    } else {
        SolidBrush normalBg(isLight ? Color(15, 0, 0, 0) : Color(20, 255, 255, 255));
        graphics.FillPath(&normalBg, &path);
    }

    SolidBrush textBrush(isLight ? (isHovered ? Color(255, 0, 0, 0) : Color(220, 40, 40, 40))
                                 : (isHovered ? Color(255, 255, 255, 255) : Color(220, 220, 220, 220)));
    StringFormat format;
    format.SetAlignment(StringAlignmentCenter);
    format.SetLineAlignment(StringAlignmentCenter);
    graphics.DrawString(text, -1, &font, rect, &format, &textBrush);
}

// ── Calendar Popup State & Engine ────────────────────────────────────────────
HWND g_hCalWnd = NULL;
bool g_isCalendarOpen = false;
DWORD g_lastCalCloseTime = 0;
int g_calBaseX = 0, g_calBaseY = 0;
bool g_flyoutOnLeft = false;
int g_calYear = 2082;
int g_calMonth = 11;
int g_calSelectedDay = 9;
int g_hoveredBtn = -1;
int g_hoveredCell = -1;
bool g_hasDragged = false;

RECT g_rcCalCard = { 0, 0, 0, 0 };
RECT g_rcCalEventCard = { 0, 0, 0, 0 };
bool g_calHasEvent = false;

bool IsPointInCalendar(POINT pt) {
    if (!g_isCalendarOpen) return false;
    if (PtInRect(&g_rcCalCard, pt)) return true;
    if (g_calHasEvent && PtInRect(&g_rcCalEventCard, pt)) return true;
    return false;
}

enum CalendarButtonId {
    BTN_NONE = -1,
    BTN_PREV_MONTH = 102,
    BTN_NEXT_MONTH = 103,
    BTN_TODAY = 105,
    BTN_CLOSE = 106,
    BTN_RETRY_FETCH = 107
};

enum CalendarAnimState {
    CAL_ANIM_CLOSED = 0,
    CAL_ANIM_OPENING,
    CAL_ANIM_OPEN,
    CAL_ANIM_CLOSING
};

CalendarAnimState g_calAnimState = CAL_ANIM_CLOSED;
DWORD g_calAnimStartTime = 0;
const DWORD CAL_ANIM_OPEN_MS = 180;
const DWORD CAL_ANIM_CLOSE_MS = 140;

void HideCalendar();
void HideCalendarImmediate();
void ShowCalendar(HWND hWidgetWnd);
void ToggleCalendar(HWND hWidgetWnd);

void RenderCalendar(HWND hWnd, BYTE alpha = 255, int overrideX = -1, int overrideY = -1) {
    if (!hWnd) return;

    // Enforce calendar strictly to current BS year
    int curBSY = 0, curBSM = 0, curBSD = 0, curBSDOW = 0;
    GetCurrentBSDate(curBSY, curBSM, curBSD, curBSDOW);
    g_calYear = curBSY;

    if (g_calMonth < 1) g_calMonth = 1;
    if (g_calMonth > 12) g_calMonth = 12;

    int totalD = GetBSDaysInMonth(g_calYear, g_calMonth);
    if (g_calSelectedDay < 1) g_calSelectedDay = 1;
    if (g_calSelectedDay > totalD) g_calSelectedDay = totalD;

    EnsureHolidaysLoadedForCurrentYear(g_calYear);

    const NepaliHoliday* selHoliday = GetHolidayForBS(g_calYear, g_calMonth, g_calSelectedDay);
    bool isOfflineMode = (g_holidayFetchState == FETCH_ERROR_OFFLINE && g_currentYearHolidays.empty());
    bool isDownloading = (g_holidayFetchState == FETCH_DOWNLOADING && g_currentYearHolidays.empty());
    bool hasEvent = (selHoliday != NULL || isOfflineMode || isDownloading);

    HMONITOR hMon = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
    MONITORINFO mi = { sizeof(mi) };
    GetMonitorInfo(hMon, &mi);

    int baseW = 420;
    int baseH = 440;
    float s = g_dpiScale;

    float flyoutW = 380.0f;
    float flyoutH = 290.0f;
    float arrowW = 12.0f;
    float flyoutTotalW = (flyoutW + (isOfflineMode || isDownloading ? 12.0f : arrowW)) * s;

    // Determine if flyout fits on right or should flip to left side
    bool isFlyoutOnLeft = false;
    if (hasEvent) {
        if (g_calBaseX + (int)(baseW * s) + (int)flyoutTotalW > mi.rcWork.right) {
            isFlyoutOnLeft = true;
        }
    }
    g_flyoutOnLeft = isFlyoutOnLeft;

    int rawW = (int)((hasEvent ? (baseW + arrowW + flyoutW + 12.0f) : baseW) * s);
    int rawH = (int)(baseH * s);

    int baseX = (overrideX != -1) ? overrideX : g_calBaseX;
    int baseY = (overrideY != -1) ? overrideY : g_calBaseY;

    int screenX = baseX;
    float calCardOffsetX = 0.0f;
    if (hasEvent && isFlyoutOnLeft) {
        screenX = baseX - (int)flyoutTotalW;
        if (screenX < mi.rcWork.left) screenX = mi.rcWork.left;
        calCardOffsetX = (float)(baseX - screenX);
    }
    int screenY = baseY;

    g_rcCalCard.left = screenX + (int)calCardOffsetX;
    g_rcCalCard.top = screenY;
    g_rcCalCard.right = g_rcCalCard.left + (int)(baseW * s);
    g_rcCalCard.bottom = g_rcCalCard.top + (int)(baseH * s);
    g_calHasEvent = hasEvent;
    if (!hasEvent) {
        g_rcCalEventCard = { 0, 0, 0, 0 };
    }

    HDC hdcScreen = GetDC(NULL);
    HDC hdcMem = CreateCompatibleDC(hdcScreen);

    BITMAPINFO bmi = {};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = rawW;
    bmi.bmiHeader.biHeight = -rawH;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;
    void* pBits = NULL;
    HBITMAP hBitmap = CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, &pBits, NULL, 0);
    HBITMAP hOldBitmap = (HBITMAP)SelectObject(hdcMem, hBitmap);

    Graphics graphics(hdcMem);
    graphics.SetSmoothingMode(SmoothingModeHighQuality);
    graphics.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
    graphics.SetPixelOffsetMode(PixelOffsetModeHighQuality);
    graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
    graphics.Clear(Color(0, 0, 0, 0));

    FontFamily fontFamily(L"Segoe UI");
    Font fontTitle(&fontFamily, 14.0f * s, FontStyleBold, UnitPixel);
    Font fontSubTitle(&fontFamily, 11.0f * s, FontStyleRegular, UnitPixel);
    Font fontButton(&fontFamily, 12.0f * s, FontStyleBold, UnitPixel);
    Font fontNavTitle(&fontFamily, 15.5f * s, FontStyleBold, UnitPixel);
    Font fontNavSub(&fontFamily, 11.5f * s, FontStyleRegular, UnitPixel);
    Font fontDayHeader(&fontFamily, 12.5f * s, FontStyleBold, UnitPixel);
    Font fontBSDay(&fontFamily, 16.5f * s, FontStyleBold, UnitPixel);
    Font fontADDay(&fontFamily, 11.0f * s, FontStyleRegular, UnitPixel);
    Font fontDetailL1(&fontFamily, 16.5f * s, FontStyleBold, UnitPixel);
    Font fontDetailL2(&fontFamily, 13.0f * s, FontStyleBold, UnitPixel);
    Font fontDetailL3(&fontFamily, 12.5f * s, FontStyleRegular, UnitPixel);
    Font fontBadge(&fontFamily, 10.0f * s, FontStyleBold, UnitPixel);

    StringFormat formatNear, formatCenter, formatFar;
    formatNear.SetAlignment(StringAlignmentNear);
    formatNear.SetLineAlignment(StringAlignmentCenter);
    formatCenter.SetAlignment(StringAlignmentCenter);
    formatCenter.SetLineAlignment(StringAlignmentCenter);
    formatFar.SetAlignment(StringAlignmentFar);
    formatFar.SetLineAlignment(StringAlignmentCenter);

    // ── 1. Render Calendar Base Card ─────────────────────────────────────────
    graphics.TranslateTransform(calCardOffsetX, 0.0f);

    GraphicsPath cardPath;
    AddRoundedRectangle(cardPath, 1.0f * s, 1.0f * s, (baseW - 2.0f) * s, (baseH - 2.0f) * s, 14.0f * s);
    
    if (g_isLightTheme) {
        SolidBrush cardBrush(Color(255, 255, 255, 255));
        graphics.FillPath(&cardBrush, &cardPath);
        Pen cardPen(Color(50, 0, 0, 0), 1.0f * s);
        graphics.DrawPath(&cardPen, &cardPath);
    } else {
        SolidBrush cardBrush(Color(255, 30, 30, 36));
        graphics.FillPath(&cardBrush, &cardPath);
        Pen cardPen(Color(65, 255, 255, 255), 1.0f * s);
        graphics.DrawPath(&cardPen, &cardPath);
    }

    // Top Header (Flag + Title + Today Button + Close Button)
    DrawNepaliFlag(graphics, 18.0f * s, 16.0f * s, 26.0f * s);

    SolidBrush textPrimary(g_isLightTheme ? Color(255, 20, 20, 20) : Color(255, 255, 255, 255));
    SolidBrush textSubtle(g_isLightTheme ? Color(180, 100, 100, 100) : Color(180, 170, 170, 175));
    SolidBrush crimsonText(Color(255, 235, 35, 65));

    RectF titleRect(48.0f * s, 14.0f * s, 240.0f * s, 18.0f * s);
    graphics.DrawString(L"Nepali Calendar", -1, &fontTitle, titleRect, &formatNear, &textPrimary);

    RectF subTitleRect(48.0f * s, 33.0f * s, 240.0f * s, 16.0f * s);
    graphics.DrawString(L"\u0928\u0947\u092A\u093E\u0932\u0940 \u092A\u093E\u0924\u094D\u0930\u094B \u2022 Bikram Sambat", -1, &fontSubTitle, subTitleRect, &formatNear, &textSubtle);

    RectF todayBtnRect(300.0f * s, 14.0f * s, 68.0f * s, 30.0f * s);
    DrawIconButton(graphics, todayBtnRect, L"Today", g_hoveredBtn == BTN_TODAY, g_isLightTheme, fontButton);

    RectF closeBtnRect(374.0f * s, 14.0f * s, 30.0f * s, 30.0f * s);
    DrawIconButton(graphics, closeBtnRect, L"\u2715", g_hoveredBtn == BTN_CLOSE, g_isLightTheme, fontButton);

    // Navigation Bar (< Prev Month, Month Year, Next Month >)
    RectF prevMonthRect(18.0f * s, 60.0f * s, 36.0f * s, 34.0f * s);
    DrawIconButton(graphics, prevMonthRect, L"\u2039", g_hoveredBtn == BTN_PREV_MONTH, g_isLightTheme, fontButton);

    RectF nextMonthRect(366.0f * s, 60.0f * s, 36.0f * s, 34.0f * s);
    DrawIconButton(graphics, nextMonthRect, L"\u203A", g_hoveredBtn == BTN_NEXT_MONTH, g_isLightTheme, fontButton);

    int mIdx = g_calMonth - 1;
    std::wstring navTitle = std::wstring(kNepaliMonthNamesEN[mIdx]) + L" " + std::to_wstring(g_calYear) +
                           L"  \u2022  " + kNepaliMonthNamesNP[mIdx] + L" " + ToDevanagariNum(g_calYear);
    RectF navTitleRect(58.0f * s, 58.0f * s, 304.0f * s, 22.0f * s);
    graphics.DrawString(navTitle.c_str(), -1, &fontNavTitle, navTitleRect, &formatCenter, &textPrimary);

    int adY1 = 0, adM1 = 0, adD1 = 0, dow1 = 0;
    int adY2 = 0, adM2 = 0, adD2 = 0, dow2 = 0;
    BSToAD(g_calYear, g_calMonth, 1, adY1, adM1, adD1, dow1);
    BSToAD(g_calYear, g_calMonth, totalD, adY2, adM2, adD2, dow2);

    std::wstring adRangeStr;
    if (adM1 == adM2) {
        adRangeStr = std::wstring(kEnglishMonthNames[adM1 - 1]) + L" " + std::to_wstring(adD1) +
                     L" - " + std::to_wstring(adD2) + L", " + std::to_wstring(adY1);
    } else {
        adRangeStr = std::wstring(kEnglishMonthNames[adM1 - 1]) + L" " + std::to_wstring(adD1) +
                     L" - " + kEnglishMonthNames[adM2 - 1] + L" " + std::to_wstring(adD2) +
                     L", " + std::to_wstring(adY2);
    }
    RectF navSubRect(58.0f * s, 80.0f * s, 304.0f * s, 16.0f * s);
    graphics.DrawString(adRangeStr.c_str(), -1, &fontNavSub, navSubRect, &formatCenter, &textSubtle);

    // Days of Week Header Row
    const wchar_t* dowNames[] = { L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat" };
    float colW = 55.0f * s;
    float rowH = 48.0f * s;
    float gridLeft = 18.0f * s;
    float gridTop = 104.0f * s;

    for (int i = 0; i < 7; i++) {
        RectF headerRect(gridLeft + i * colW, gridTop, colW, 26.0f * s);
        SolidBrush dowBrush(i == 6 ? Color(255, 235, 35, 65) : (i == 0 ? (g_isLightTheme ? Color(255, 200, 30, 30) : Color(255, 255, 100, 100)) : (g_isLightTheme ? Color(255, 100, 100, 100) : Color(255, 170, 170, 175))));
        graphics.DrawString(dowNames[i], -1, &fontDayHeader, headerRect, &formatCenter, &dowBrush);
    }

    // Month Days Grid (6 Rows x 7 Columns)
    int startDow = GetBSMonthStartDayOfWeek(g_calYear, g_calMonth);
    float cellsTop = 138.0f * s;

    float selectedCellCenterY = cellsTop + 24.0f * s;

    for (int r = 0; r < 6; r++) {
        for (int c = 0; c < 7; c++) {
            int cellIdx = r * 7 + c;
            int dayNum = cellIdx - startDow + 1;

            if (dayNum >= 1 && dayNum <= totalD) {
                float cellX = gridLeft + c * colW;
                float cellY = cellsTop + r * rowH;
                RectF cellRect(cellX + 2.0f * s, cellY + 2.0f * s, colW - 4.0f * s, rowH - 4.0f * s);

                bool isToday = (g_calYear == curBSY && g_calMonth == curBSM && dayNum == curBSD);
                bool isSelected = (dayNum == g_calSelectedDay);
                bool isHovered = (g_hoveredCell == cellIdx);
                bool isSaturday = (c == 6);

                const NepaliHoliday* hInfo = GetHolidayForBS(g_calYear, g_calMonth, dayNum);
                bool isHoliday = (hInfo != NULL && hInfo->isPublicHoliday);
                bool isFestival = (hInfo != NULL && !hInfo->isPublicHoliday);

                if (isSelected) {
                    selectedCellCenterY = cellY + (rowH / 2.0f);
                }

                // Cell Background Styling
                GraphicsPath cellPath;
                AddRoundedRectangle(cellPath, cellRect.X, cellRect.Y, cellRect.Width, cellRect.Height, 8.0f * s);

                if (isToday) {
                    SolidBrush todayBg(Color(255, 220, 20, 60));
                    graphics.FillPath(&todayBg, &cellPath);
                } else if (isSelected) {
                    SolidBrush selBg(g_isLightTheme ? Color(40, 0, 56, 147) : Color(50, 255, 255, 255));
                    graphics.FillPath(&selBg, &cellPath);
                    Pen selPen(g_isLightTheme ? Color(180, 0, 56, 147) : Color(180, 255, 255, 255), 1.5f * s);
                    graphics.DrawPath(&selPen, &cellPath);
                } else if (isHovered) {
                    SolidBrush hovBg(g_isLightTheme ? Color(25, 0, 0, 0) : Color(30, 255, 255, 255));
                    graphics.FillPath(&hovBg, &cellPath);
                }

                // BS Day Number
                std::wstring bsDayStr = std::to_wstring(dayNum);
                RectF bsDayRect(cellRect.X, cellRect.Y + 4.0f * s, cellRect.Width, 22.0f * s);

                SolidBrush bsDayBrush(isToday ? Color(255, 255, 255, 255) :
                                      (isHoliday || isSaturday ? Color(255, 235, 35, 65) :
                                      (g_isLightTheme ? Color(255, 20, 20, 20) : Color(255, 255, 255, 255))));

                graphics.DrawString(bsDayStr.c_str(), -1, &fontBSDay, bsDayRect, &formatCenter, &bsDayBrush);

                // English AD Day Sub-Number
                int cAdY = 0, cAdM = 0, cAdD = 0, cDow = 0;
                BSToAD(g_calYear, g_calMonth, dayNum, cAdY, cAdM, cAdD, cDow);
                std::wstring adDayStr = std::to_wstring(cAdD);
                RectF adDayRect(cellRect.X, cellRect.Y + 26.0f * s, cellRect.Width, 14.0f * s);

                SolidBrush adDayBrush(isToday ? Color(220, 255, 255, 255) :
                                      (g_isLightTheme ? Color(160, 100, 100, 100) : Color(160, 170, 170, 175)));

                graphics.DrawString(adDayStr.c_str(), -1, &fontADDay, adDayRect, &formatCenter, &adDayBrush);

                // Indicator dot for Holidays/Events
                if (isHoliday || isFestival) {
                    float dotDiam = 4.5f * s;
                    float dotX = cellRect.X + (cellRect.Width - dotDiam) / 2.0f;
                    float dotY = cellRect.Y + cellRect.Height - dotDiam - 2.0f * s;

                    SolidBrush dotBrush(isToday ? Color(255, 255, 255, 255) :
                                        (isHoliday ? Color(255, 235, 35, 65) : Color(255, 0, 120, 215)));
                    graphics.FillEllipse(&dotBrush, dotX, dotY, dotDiam, dotDiam);
                }
            }
        }
    }

    graphics.ResetTransform();

    // ── 2. Render Event Card / Offline Notice Flyout ─────────────────────────
    if (hasEvent) {
        float fx, fy;
        if (isFlyoutOnLeft) {
            fx = 6.0f * s;
            fy = (isOfflineMode || isDownloading) ? (14.0f * s) : std::max(14.0f * s, std::min((baseH - flyoutH - 14.0f) * s, selectedCellCenterY - (flyoutH / 2.0f) * s));
        } else {
            fx = calCardOffsetX + (baseW + (isOfflineMode || isDownloading ? 12.0f : arrowW)) * s;
            fy = (isOfflineMode || isDownloading) ? (14.0f * s) : std::max(14.0f * s, std::min((baseH - flyoutH - 14.0f) * s, selectedCellCenterY - (flyoutH / 2.0f) * s));
        }
        float fw = flyoutW * s;
        float fh = flyoutH * s;
        float r = 12.0f * s;

        if (isFlyoutOnLeft) {
            g_rcCalEventCard.left = screenX + (int)fx;
            g_rcCalEventCard.top = screenY + (int)fy;
            g_rcCalEventCard.right = screenX + (int)(fx + fw + arrowW * s);
            g_rcCalEventCard.bottom = screenY + (int)(fy + fh);
        } else {
            g_rcCalEventCard.left = screenX + (int)(fx - arrowW * s);
            g_rcCalEventCard.top = screenY + (int)fy;
            g_rcCalEventCard.right = screenX + (int)(fx + fw);
            g_rcCalEventCard.bottom = screenY + (int)(fy + fh);
        }

        std::wstring cardTitleNP;
        std::wstring cardTitleEN;
        std::wstring cardDescription;
        bool isPubHol = false;
        bool isOffline = false;

        if (isOfflineMode) {
            isOffline = true;
            cardTitleNP = L"\u0907\u0928\u094D\u091F\u0930\u0928\u0947\u091F \u091C\u0921\u093E\u0928 \u0906\u0935\u0936\u094D\u092F\u0915";
            cardTitleEN = L"Internet Connection Required";
            cardDescription = L"Please connect to the internet to load all events and public holidays for Bikram Sambat " +
                              std::to_wstring(g_calYear) + L". The calendar will automatically sync and cache once connected.";
        } else if (isDownloading) {
            cardTitleNP = L"\u0924\u093E\u0932\u093F\u0915\u093E \u0921\u093E\u0909\u0928\u0932\u094B\u0921 \u0939\u0941\u0901\u0926\u0948\u091B...";
            cardTitleEN = L"Downloading Holidays Schedule...";
            cardDescription = L"Fetching official Bikram Sambat " + std::to_wstring(g_calYear) +
                              L" public holidays and events in background. Please wait a moment...";
        } else if (selHoliday) {
            cardTitleNP = selHoliday->titleNP;
            cardTitleEN = selHoliday->titleEN;
            cardDescription = selHoliday->description;
            isPubHol = selHoliday->isPublicHoliday;
        }

        // Measure needed height for description
        StringFormat formatDesc;
        formatDesc.SetAlignment(StringAlignmentNear);
        formatDesc.SetLineAlignment(StringAlignmentNear);
        RectF layoutDesc(0, 0, (flyoutW - 48.0f) * s, 1000.0f);
        RectF measuredDesc;
        graphics.MeasureString(cardDescription.c_str(), -1, &fontDetailL3, layoutDesc, &formatDesc, &measuredDesc);

        float neededDescH = measuredDesc.Height;
        float dynamicH = 145.0f + (neededDescH / s) + (isOffline ? 45.0f : 20.0f);
        if (dynamicH < 220.0f) dynamicH = 220.0f;
        if (dynamicH > 380.0f) dynamicH = 380.0f;
        fh = dynamicH * s;

        GraphicsPath bubblePath;
        if (isOfflineMode || isDownloading) {
            AddRoundedRectangle(bubblePath, fx, fy, fw, fh, r);
        } else if (isFlyoutOnLeft) {
            // Speech bubble with triangle arrow on the RIGHT pointing to the calendar cell
            float tipX = calCardOffsetX - 2.0f * s;
            float tipY = selectedCellCenterY;
            float topY = tipY - 10.0f * s;
            float botY = tipY + 10.0f * s;

            bubblePath.AddArc(fx, fy, r * 2.0f, r * 2.0f, 180, 90);
            bubblePath.AddArc(fx + fw - r * 2.0f, fy, r * 2.0f, r * 2.0f, 270, 90);
            bubblePath.AddLine(fx + fw, fy + r, fx + fw, topY);
            bubblePath.AddLine(fx + fw, topY, tipX, tipY);
            bubblePath.AddLine(tipX, tipY, fx + fw, botY);
            bubblePath.AddLine(fx + fw, botY, fx + fw, fy + fh - r);
            bubblePath.AddArc(fx + fw - r * 2.0f, fy + fh - r * 2.0f, r * 2.0f, r * 2.0f, 0, 90);
            bubblePath.AddArc(fx, fy + fh - r * 2.0f, r * 2.0f, r * 2.0f, 90, 90);
            bubblePath.CloseFigure();
        } else {
            // Speech bubble with triangle arrow on the LEFT pointing to the calendar cell
            float tipX = calCardOffsetX + baseW * s + 2.0f * s;
            float tipY = selectedCellCenterY;
            float topY = tipY - 10.0f * s;
            float botY = tipY + 10.0f * s;

            bubblePath.AddArc(fx, fy, r * 2.0f, r * 2.0f, 180, 90);
            bubblePath.AddArc(fx + fw - r * 2.0f, fy, r * 2.0f, r * 2.0f, 270, 90);
            bubblePath.AddArc(fx + fw - r * 2.0f, fy + fh - r * 2.0f, r * 2.0f, r * 2.0f, 0, 90);
            bubblePath.AddArc(fx, fy + fh - r * 2.0f, r * 2.0f, r * 2.0f, 90, 90);
            bubblePath.AddLine(fx, fy + fh - r, fx, botY);
            bubblePath.AddLine(fx, botY, tipX, tipY);
            bubblePath.AddLine(tipX, tipY, fx, topY);
            bubblePath.AddLine(fx, topY, fx, fy + r);
            bubblePath.CloseFigure();
        }

        SolidBrush flyoutBg(g_isLightTheme ? Color(255, 255, 255, 255) : Color(255, 30, 30, 36));
        graphics.FillPath(&flyoutBg, &bubblePath);
        Pen flyoutPen(g_isLightTheme ? Color(60, 0, 0, 0) : Color(70, 255, 255, 255), 1.0f * s);
        graphics.DrawPath(&flyoutPen, &bubblePath);

        // Left accent strip
        GraphicsPath stripPath;
        AddRoundedRectangle(stripPath, fx + 12.0f * s, fy + 16.0f * s, 4.0f * s, fh - 32.0f * s, 2.0f * s);
        SolidBrush stripBrush(isPubHol ? Color(255, 220, 20, 60) : (isOffline ? Color(255, 220, 140, 20) : Color(255, 0, 120, 215)));
        graphics.FillPath(&stripBrush, &stripPath);

        int selAdY = 0, selAdM = 0, selAdD = 0, selDow = 0;
        BSToAD(g_calYear, g_calMonth, g_calSelectedDay, selAdY, selAdM, selAdD, selDow);

        StringFormat formatNearNoWrap;
        formatNearNoWrap.SetAlignment(StringAlignmentNear);
        formatNearNoWrap.SetLineAlignment(StringAlignmentCenter);
        formatNearNoWrap.SetFormatFlags(StringFormatFlagsNoWrap);

        // Top Section Line 1: Devanagari BS Date or Status Header
        std::wstring npDateStr;
        if (isOffline || isDownloading) {
            npDateStr = ToDevanagariNum(g_calYear) + L" BS \u2022 \u091A\u093E\u0921\u092A\u0930\u094D\u0935 \u0930 \u092C\u093F\u0926\u093E";
        } else {
            npDateStr = ToDevanagariNum(g_calYear) + L" " + kNepaliMonthNamesNP[mIdx] + L" " +
                        ToDevanagariNum(g_calSelectedDay) + L" \u0917\u0924\u0947, " + kNepaliDayNamesNP[selDow];
        }

        RectF npDateRect(fx + 26.0f * s, fy + 16.0f * s, fw - 165.0f * s, 22.0f * s);
        graphics.DrawString(npDateStr.c_str(), -1, &fontDetailL2, npDateRect, &formatNearNoWrap, &textPrimary);

        // Top Section Line 2: English AD Date or Sub-Header
        std::wstring enDateStr;
        if (isOffline || isDownloading) {
            enDateStr = L"Events & Public Holidays";
        } else {
            enDateStr = std::to_wstring(selAdD) + L" " + kEnglishMonthNames[selAdM - 1] + L" " +
                        std::to_wstring(selAdY) + L", " + kNepaliDayNamesEN[selDow];
        }

        RectF enDateRect(fx + 26.0f * s, fy + 40.0f * s, fw - 165.0f * s, 20.0f * s);
        graphics.DrawString(enDateStr.c_str(), -1, &fontNavSub, enDateRect, &formatNearNoWrap, &textSubtle);

        // Top Section: Category Badge on right
        RectF badgeRect(fx + fw - 132.0f * s, fy + 22.0f * s, 118.0f * s, 28.0f * s);
        GraphicsPath badgePath;
        AddRoundedRectangle(badgePath, badgeRect.X, badgeRect.Y, badgeRect.Width, badgeRect.Height, 5.0f * s);
        
        if (isPubHol) {
            SolidBrush badgeBg(Color(50, 220, 20, 60));
            graphics.FillPath(&badgeBg, &badgePath);
            Pen badgePen(Color(180, 220, 20, 60), 1.0f * s);
            graphics.DrawPath(&badgePen, &badgePath);
            graphics.DrawString(L"PUBLIC HOLIDAY", -1, &fontBadge, badgeRect, &formatCenter, &crimsonText);
        } else if (isOffline) {
            SolidBrush badgeBg(Color(50, 220, 140, 20));
            graphics.FillPath(&badgeBg, &badgePath);
            Pen badgePen(Color(180, 220, 140, 20), 1.0f * s);
            graphics.DrawPath(&badgePen, &badgePath);
            SolidBrush amberText(Color(255, 230, 140, 30));
            graphics.DrawString(L"\u26A0 OFFLINE", -1, &fontBadge, badgeRect, &formatCenter, &amberText);
        } else if (isDownloading) {
            SolidBrush badgeBg(Color(50, 0, 120, 215));
            graphics.FillPath(&badgeBg, &badgePath);
            Pen badgePen(Color(180, 0, 120, 215), 1.0f * s);
            graphics.DrawPath(&badgePen, &badgePath);
            SolidBrush blueText(Color(255, 60, 140, 255));
            graphics.DrawString(L"\u21BB SYNCING", -1, &fontBadge, badgeRect, &formatCenter, &blueText);
        } else {
            SolidBrush badgeBg(g_isLightTheme ? Color(40, 0, 56, 147) : Color(60, 0, 56, 147));
            graphics.FillPath(&badgeBg, &badgePath);
            Pen badgePen(Color(180, 0, 80, 200), 1.0f * s);
            graphics.DrawPath(&badgePen, &badgePath);
            SolidBrush blueText(Color(255, 60, 140, 255));
            graphics.DrawString(L"FESTIVAL / \u092A\u0930\u094D\u0935", -1, &fontBadge, badgeRect, &formatCenter, &blueText);
        }

        // Divider line
        Pen dividerPen(g_isLightTheme ? Color(25, 0, 0, 0) : Color(40, 255, 255, 255), 1.0f * s);
        graphics.DrawLine(&dividerPen, fx + 22.0f * s, fy + 68.0f * s, fx + fw - 14.0f * s, fy + 68.0f * s);

        // Event Title: Nepali & English
        RectF holTitleRect(fx + 26.0f * s, fy + 78.0f * s, fw - 42.0f * s, 28.0f * s);
        SolidBrush holTitleBrush(isPubHol ? Color(255, 240, 45, 75) : (g_isLightTheme ? Color(255, 0, 56, 147) : Color(255, 90, 170, 255)));
        graphics.DrawString(cardTitleNP.c_str(), -1, &fontDetailL1, holTitleRect, &formatNear, &holTitleBrush);

        RectF holSubTitleRect(fx + 26.0f * s, fy + 108.0f * s, fw - 42.0f * s, 24.0f * s);
        graphics.DrawString(cardTitleEN.c_str(), -1, &fontDetailL2, holSubTitleRect, &formatNear, &textPrimary);

        // Event Description
        RectF holDescRect(fx + 26.0f * s, fy + 138.0f * s, (flyoutW - 48.0f) * s, (neededDescH + 4.0f) * s);
        SolidBrush descTextBrush(g_isLightTheme ? Color(255, 45, 45, 50) : Color(255, 235, 235, 240));
        graphics.DrawString(cardDescription.c_str(), -1, &fontDetailL3, holDescRect, &formatDesc, &descTextBrush);

        // Retry button if offline
        if (isOffline) {
            RectF retryBtnRect(fx + 26.0f * s, fy + fh - 50.0f * s, 140.0f * s, 30.0f * s);
            DrawIconButton(graphics, retryBtnRect, L"\u21BB Retry / \u092A\u0941\u0928\u0903 \u092A\u094D\u0930\u092F\u093E\u0938", g_hoveredBtn == BTN_RETRY_FETCH, g_isLightTheme, fontButton);
        }
    }

    // Apply per-pixel alpha channel
    POINT ptDst = { screenX, screenY };
    SIZE sizeDst = { rawW, rawH };
    POINT ptSrc = { 0, 0 };
    BLENDFUNCTION blend = { AC_SRC_OVER, 0, alpha, AC_SRC_ALPHA };

    UpdateLayeredWindow(hWnd, hdcScreen, &ptDst, &sizeDst, hdcMem, &ptSrc, 0, &blend, ULW_ALPHA);
    SetWindowPos(hWnd, NULL, screenX, screenY, rawW, rawH,
                 SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSENDCHANGING);

    SelectObject(hdcMem, hOldBitmap);
    DeleteObject(hBitmap);
    DeleteDC(hdcMem);
    ReleaseDC(NULL, hdcScreen);
}

LRESULT CALLBACK CalendarWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_MOUSEMOVE: {
        int x = LOWORD(lParam);
        int y = HIWORD(lParam);
        float s = g_dpiScale;
        float calOffset = (g_flyoutOnLeft ? (380.0f + 12.0f) : 0.0f);
        float bx = x / s - calOffset;
        float by = y / s;

        int newBtn = BTN_NONE;
        int newCell = -1;

        float retryX = (g_flyoutOnLeft ? (6.0f + 26.0f) : (420.0f + 12.0f + 26.0f));

        if (bx >= 18.0f && bx <= 54.0f && by >= 60.0f && by <= 94.0f) {
            newBtn = BTN_PREV_MONTH;
        } else if (bx >= 366.0f && bx <= 402.0f && by >= 60.0f && by <= 94.0f) {
            newBtn = BTN_NEXT_MONTH;
        } else if (bx >= 300.0f && bx <= 368.0f && by >= 14.0f && by <= 44.0f) {
            newBtn = BTN_TODAY;
        } else if (bx >= 374.0f && bx <= 404.0f && by >= 14.0f && by <= 44.0f) {
            newBtn = BTN_CLOSE;
        } else if (g_holidayFetchState == FETCH_ERROR_OFFLINE && g_currentYearHolidays.empty() &&
                   (x / s) >= retryX && (x / s) <= (retryX + 140.0f) &&
                   by >= 190.0f && by <= 270.0f) {
            newBtn = BTN_RETRY_FETCH;
        } else if (bx >= 18.0f && bx < 403.0f && by >= 138.0f && by < 426.0f) {
            int c = (int)((bx - 18.0f) / 55.0f);
            int r = (int)((by - 138.0f) / 48.0f);
            if (c >= 0 && c < 7 && r >= 0 && r < 6) {
                int cellIdx = r * 7 + c;
                int startDow = GetBSMonthStartDayOfWeek(g_calYear, g_calMonth);
                int totalD = GetBSDaysInMonth(g_calYear, g_calMonth);
                int dayNum = cellIdx - startDow + 1;
                if (dayNum >= 1 && dayNum <= totalD) {
                    newCell = cellIdx;
                }
            }
        }

        if (newBtn != g_hoveredBtn || newCell != g_hoveredCell) {
            g_hoveredBtn = newBtn;
            g_hoveredCell = newCell;
            RenderCalendar(hWnd);
        }

        TRACKMOUSEEVENT tme = { sizeof(tme) };
        tme.dwFlags = TME_LEAVE;
        tme.hwndTrack = hWnd;
        TrackMouseEvent(&tme);
        break;
    }

    case WM_MOUSELEAVE:
        if (g_hoveredBtn != BTN_NONE || g_hoveredCell != -1) {
            g_hoveredBtn = BTN_NONE;
            g_hoveredCell = -1;
            RenderCalendar(hWnd);
        }
        break;

    case WM_LBUTTONDOWN: {
        int x = LOWORD(lParam);
        int y = HIWORD(lParam);
        float s = g_dpiScale;
        float calOffset = (g_flyoutOnLeft ? (380.0f + 12.0f) : 0.0f);
        float bx = x / s - calOffset;
        float by = y / s;
        float retryX = (g_flyoutOnLeft ? (6.0f + 26.0f) : (420.0f + 12.0f + 26.0f));

        if (bx >= 18.0f && bx <= 54.0f && by >= 60.0f && by <= 94.0f) {
            if (g_calMonth > 1) {
                g_calMonth--;
                RenderCalendar(hWnd);
            }
        } else if (bx >= 366.0f && bx <= 402.0f && by >= 60.0f && by <= 94.0f) {
            if (g_calMonth < 12) {
                g_calMonth++;
                RenderCalendar(hWnd);
            }
        } else if (bx >= 300.0f && bx <= 368.0f && by >= 14.0f && by <= 44.0f) {
            int cy, cm, cd, cdow;
            GetCurrentBSDate(cy, cm, cd, cdow);
            g_calYear = cy;
            g_calMonth = cm;
            g_calSelectedDay = cd;
            RenderCalendar(hWnd);
        } else if (bx >= 374.0f && bx <= 404.0f && by >= 14.0f && by <= 44.0f) {
            HideCalendar();
        } else if (g_hoveredBtn == BTN_RETRY_FETCH ||
                  (g_holidayFetchState == FETCH_ERROR_OFFLINE && g_currentYearHolidays.empty() &&
                   (x / s) >= retryX && (x / s) <= (retryX + 140.0f) &&
                   by >= 190.0f && by <= 270.0f)) {
            EnsureHolidaysLoadedForCurrentYear(g_calYear, true);
            RenderCalendar(hWnd);
        } else if (bx >= 18.0f && bx < 403.0f && by >= 138.0f && by < 426.0f) {
            int c = (int)((bx - 18.0f) / 55.0f);
            int r = (int)((by - 138.0f) / 48.0f);
            if (c >= 0 && c < 7 && r >= 0 && r < 6) {
                int cellIdx = r * 7 + c;
                int startDow = GetBSMonthStartDayOfWeek(g_calYear, g_calMonth);
                int totalD = GetBSDaysInMonth(g_calYear, g_calMonth);
                int dayNum = cellIdx - startDow + 1;
                if (dayNum >= 1 && dayNum <= totalD) {
                    g_calSelectedDay = dayNum;
                    RenderCalendar(hWnd);
                }
            }
        }
        break;
    }

    case WM_MOUSEWHEEL: {
        short delta = GET_WHEEL_DELTA_WPARAM(wParam);
        if (delta > 0 && g_calMonth > 1) g_calMonth--;
        else if (delta < 0 && g_calMonth < 12) g_calMonth++;
        RenderCalendar(hWnd);
        break;
    }

    case WM_KEYDOWN:
        if (wParam == VK_ESCAPE) HideCalendar();
        else if (wParam == VK_LEFT) { if (g_calSelectedDay > 1) g_calSelectedDay--; RenderCalendar(hWnd); }
        else if (wParam == VK_RIGHT) { int maxD = GetBSDaysInMonth(g_calYear, g_calMonth); if (g_calSelectedDay < maxD) g_calSelectedDay++; RenderCalendar(hWnd); }
        else if (wParam == VK_UP) { if (g_calSelectedDay > 7) g_calSelectedDay -= 7; RenderCalendar(hWnd); }
        else if (wParam == VK_DOWN) { int maxD = GetBSDaysInMonth(g_calYear, g_calMonth); if (g_calSelectedDay + 7 <= maxD) g_calSelectedDay += 7; RenderCalendar(hWnd); }
        break;

    case WM_TIMER:
        if (wParam == 100) {
            DWORD elapsed = GetTickCount() - g_calAnimStartTime;
            float scale = g_dpiScale;

            if (g_calAnimState == CAL_ANIM_OPENING) {
                if (elapsed >= CAL_ANIM_OPEN_MS) {
                    g_calAnimState = CAL_ANIM_OPEN;
                    KillTimer(hWnd, 100);
                    RenderCalendar(hWnd, 255, g_calBaseX, g_calBaseY);
                } else {
                    float progress = (float)elapsed / (float)CAL_ANIM_OPEN_MS;
                    float ease = 1.0f - powf(1.0f - progress, 3.0f); // Cubic Ease-Out
                    BYTE alpha = (BYTE)(ease * 255.0f);
                    int offset = (int)((1.0f - ease) * (18.0f * scale));
                    int animY = g_calBaseY + offset;
                    RenderCalendar(hWnd, alpha, g_calBaseX, animY);
                }
            } else if (g_calAnimState == CAL_ANIM_CLOSING) {
                if (elapsed >= CAL_ANIM_CLOSE_MS) {
                    g_calAnimState = CAL_ANIM_CLOSED;
                    KillTimer(hWnd, 100);
                    ShowWindow(hWnd, SW_HIDE);
                } else {
                    float progress = (float)elapsed / (float)CAL_ANIM_CLOSE_MS;
                    float ease = progress * progress * progress; // Cubic Ease-In
                    BYTE alpha = (BYTE)((1.0f - ease) * 255.0f);
                    int offset = (int)(ease * (14.0f * scale));
                    int animY = g_calBaseY + offset;
                    RenderCalendar(hWnd, alpha, g_calBaseX, animY);
                }
            }
        }
    case WM_ACTIVATE:
        if (LOWORD(wParam) == WA_INACTIVE) {
            if (GetTickCount() - g_calAnimStartTime > 300) {
                HideCalendar();
            }
        }
        break;

    case WM_KILLFOCUS:
        if (GetTickCount() - g_calAnimStartTime > 300) {
            HideCalendar();
        }
        break;

    case WM_DESTROY:
        g_hCalWnd = NULL;
        break;

    default:
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }
    return 0;
}

void HideCalendarImmediate() {
    g_isCalendarOpen = false;
    g_calAnimState = CAL_ANIM_CLOSED;
    g_lastCalCloseTime = GetTickCount();
    if (g_hCalWnd) {
        KillTimer(g_hCalWnd, 100);
        ShowWindow(g_hCalWnd, SW_HIDE);
    }
}

void HideCalendar() {
    if (!g_isCalendarOpen || g_calAnimState == CAL_ANIM_CLOSED) return;
    if (g_calAnimState == CAL_ANIM_CLOSING) return;

    g_calAnimState = CAL_ANIM_CLOSING;
    g_calAnimStartTime = GetTickCount();
    g_isCalendarOpen = false;
    g_lastCalCloseTime = GetTickCount();

    if (g_hCalWnd) {
        SetTimer(g_hCalWnd, 100, 16, NULL);
    }
}

void ShowCalendar(HWND hWidgetWnd) {
    if (!g_hCalWnd) return;
    KillTimer(g_hCalWnd, 100);
    
    int cy, cm, cd, cdow;
    GetCurrentBSDate(cy, cm, cd, cdow);
    g_calYear = cy;
    g_calMonth = cm;
    g_calSelectedDay = cd;
    g_hoveredBtn = BTN_NONE;
    g_hoveredCell = -1;

    EnsureHolidaysLoadedForCurrentYear(cy);

    int calW = (int)(420 * g_dpiScale);
    int calH = (int)(440 * g_dpiScale);

    RECT rcWidget;
    GetWindowRect(hWidgetWnd, &rcWidget);

    HMONITOR hMon = MonitorFromWindow(hWidgetWnd, MONITOR_DEFAULTTONEAREST);
    MONITORINFO mi = { sizeof(mi) };
    GetMonitorInfo(hMon, &mi);

    int widgetCenterX = rcWidget.left + (rcWidget.right - rcWidget.left) / 2;
    int x = widgetCenterX - calW / 2;
    int y = rcWidget.top - calH - (int)(10 * g_dpiScale);

    // Position below widget if above screen top or work area
    if (y < mi.rcWork.top) {
        y = rcWidget.bottom + (int)(10 * g_dpiScale);
    }
    // Clamp inside vertical screen bounds
    if (y + calH > mi.rcWork.bottom) {
        y = mi.rcWork.bottom - calH - (int)(8 * g_dpiScale);
    }
    
    // Clamp inside horizontal screen bounds for the 420px calendar card
    if (x + calW > mi.rcWork.right - (int)(10 * g_dpiScale)) {
        x = mi.rcWork.right - calW - (int)(10 * g_dpiScale);
    }
    if (x < mi.rcWork.left + (int)(10 * g_dpiScale)) {
        x = mi.rcWork.left + (int)(10 * g_dpiScale);
    }

    g_calBaseX = x;
    g_calBaseY = y;
    g_isCalendarOpen = true;

    g_calAnimState = CAL_ANIM_OPEN;
    g_calAnimStartTime = GetTickCount();
    RenderCalendar(g_hCalWnd, 255, g_calBaseX, g_calBaseY);
    SetWindowPos(g_hCalWnd, HWND_TOPMOST, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
    ShowWindow(g_hCalWnd, SW_SHOW);
    SetForegroundWindow(g_hCalWnd);
    SetFocus(g_hCalWnd);
}

void ToggleCalendar(HWND hWidgetWnd) {
    if (g_isCalendarOpen) {
        HideCalendar();
    } else {
        ShowCalendar(hWidgetWnd);
    }
}

// ── Custom Drawing Engine (Per-Pixel Alpha) ──────────────────────────────────
void RenderWidget(HWND hWnd) {
    // Automatically ensure holiday data is loaded for the current BS year
    static int s_lastCheckedBSYear = 0;
    int curBSY = 0, curBSM = 0, curBSD = 0, curBSDOW = 0;
    GetCurrentBSDate(curBSY, curBSM, curBSD, curBSDOW);
    if (curBSY != s_lastCheckedBSYear) {
        s_lastCheckedBSYear = curBSY;
        EnsureHolidaysLoadedForCurrentYear(curBSY);
    }

    // Use DPI-scaled dimensions for the render surface to get crisp pixels
    int baseWidth = g_showDay ? 190 : 155;
    int rawWidth = (int)(baseWidth * g_dpiScale);
    int rawHeight = (int)(48 * g_dpiScale);

    HDC hdcScreen = GetDC(NULL);
    HDC hdcMem = CreateCompatibleDC(hdcScreen);

    // Create a 32-bit ARGB DIB section for proper per-pixel alpha
    BITMAPINFO bmi = {};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = rawWidth;
    bmi.bmiHeader.biHeight = -rawHeight;  // Top-down
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;
    void* pBits = NULL;
    HBITMAP hBitmap = CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, &pBits, NULL, 0);
    HBITMAP hOldBitmap = (HBITMAP)SelectObject(hdcMem, hBitmap);

    Graphics graphics(hdcMem);
    graphics.SetSmoothingMode(SmoothingModeHighQuality);
    graphics.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
    graphics.SetPixelOffsetMode(PixelOffsetModeHighQuality);
    graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);

    // Clear background with per-pixel transparency
    graphics.Clear(Color(0, 0, 0, 0));

    float s = g_dpiScale;  // Shorthand for scale factor

    Color bgColor(0, 0, 0, 0);

    if (g_setupMode) {
        // Adapt background to theme so it's visible on both light and dark taskbars
        bgColor = g_isLightTheme ? Color(210, 230, 230, 230) : Color(230, 31, 31, 31);
    } else {
        BYTE a = (BYTE)g_bgOpacity;
        switch (g_bgPresetMode) {
        case 0: // Transparent / Default
            bgColor = Color(0, 0, 0, 0);
            break;
        case 1: { // Custom Color
            BYTE r = GetRValue(g_bgColorRGB);
            BYTE g = GetGValue(g_bgColorRGB);
            BYTE b = GetBValue(g_bgColorRGB);
            bgColor = Color(a, r, g, b);
            break;
        }
        case 2: // Dark Glass
            bgColor = Color(a, 31, 31, 31);
            break;
        case 3: // Light Glass
            bgColor = Color(a, 230, 230, 230);
            break;
        case 4: // Solid Black
            bgColor = Color(a, 0, 0, 0);
            break;
        case 5: // Solid White
            bgColor = Color(a, 255, 255, 255);
            break;
        case 6: // Red Accent
            bgColor = Color(a, 180, 40, 40);
            break;
        case 7: // Blue Accent
            bgColor = Color(a, 30, 110, 200);
            break;
        }
    }

    if (bgColor.GetAlpha() > 0) {
        SolidBrush bgBrush(bgColor);
        GraphicsPath bgPath;
        REAL r = 8.0f * s;
        REAL d = r * 2.0f;
        REAL w = (REAL)rawWidth;
        REAL h = (REAL)rawHeight;
        bgPath.AddArc(0.0f, 0.0f, d, d, 180.0f, 90.0f);
        bgPath.AddArc(w - d, 0.0f, d, d, 270.0f, 90.0f);
        bgPath.AddArc(w - d, h - d, d, d, 0.0f, 90.0f);
        bgPath.AddArc(0.0f, h - d, d, d, 90.0f, 90.0f);
        bgPath.CloseFigure();
        graphics.FillPath(&bgBrush, &bgPath);
    } else {
        // Invisible hit-test box: Alpha 1 ensures Windows registers mouse clicks (left click to toggle
        // calendar, right click for context menu, and dragging) across the entire widget bounds,
        // rather than letting clicks pass through transparent pixels to the taskbar.
        SolidBrush hitTestBrush(Color(1, 0, 0, 0));
        graphics.FillRectangle(&hitTestBrush, 0, 0, rawWidth, rawHeight);
    }

    // Determine text contrast based on background brightness
    bool useDarkText = g_isLightTheme;
    if (!g_setupMode && g_bgPresetMode != 0 && bgColor.GetAlpha() > 50) {
        double luminance = (0.299 * bgColor.GetR() + 0.587 * bgColor.GetG() + 0.114 * bgColor.GetB());
        useDarkText = (luminance > 140.0);
    }

    // Pre-calculate positions to create a tight, sequential layout: [Day] [Gap] [Flag] [Gap] [Date]
    REAL h = 24.0f * s;
    REAL flagWidth = 0.822f * h;
    
    // Y coordinates
    REAL cy = rawHeight / 2.0f;
    REAL top = cy - h / 2.0f;

    // 1. Measure Text and Calculate Sequential Coordinates
    FontFamily fontFamily(L"Segoe UI");
    Font font(&fontFamily, 12.0f * s, FontStyleBold, UnitPixel);
    std::wstring dateStr = GetNepaliDateString();

    StringFormat formatNear;
    formatNear.SetAlignment(StringAlignmentNear);
    formatNear.SetLineAlignment(StringAlignmentCenter);

    REAL gap = 12.0f * s;
    REAL cx, dateX;

    if (g_showDay) {
        SYSTEMTIME st;
        GetLocalTime(&st);
        const wchar_t* daysOfWeek[] = { L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat" };
        const wchar_t* dayStr = daysOfWeek[st.wDayOfWeek];

        // Measure day string
        RectF dayMeasure;
        graphics.MeasureString(dayStr, -1, &font, RectF(0,0,1000,100), &formatNear, &dayMeasure);

        // Day box on the left
        REAL boxPaddingX = 5.0f * s;
        REAL boxWidth = dayMeasure.Width + boxPaddingX * 2.0f;
        REAL boxHeight = h - 2.0f * s;
        REAL boxX = 10.0f * s;
        REAL boxY = (rawHeight - boxHeight) / 2.0f;

        // Flag in the middle
        cx = boxX + boxWidth + gap;
        dateX = cx + flagWidth + gap;

        // 2. Render Day Box
        SolidBrush boxBrush(useDarkText ? Color(25, 0, 0, 0) : Color(35, 255, 255, 255));
        GraphicsPath path;
        REAL r = 4.0f * s;
        REAL d = r * 2.0f;
        path.AddArc(boxX, boxY, d, d, 180, 90);
        path.AddArc(boxX + boxWidth - d, boxY, d, d, 270, 90);
        path.AddArc(boxX + boxWidth - d, boxY + boxHeight - d, d, d, 0, 90);
        path.AddArc(boxX, boxY + boxHeight - d, d, d, 90, 90);
        path.CloseFigure();
        graphics.FillPath(&boxBrush, &path);

        // Draw day text centered in the box
        SolidBrush dayTextBrush(useDarkText ? Color(255, 20, 20, 20) : Color(255, 255, 255, 255));
        StringFormat formatCenter;
        formatCenter.SetAlignment(StringAlignmentCenter);
        formatCenter.SetLineAlignment(StringAlignmentCenter);
        RectF dayTextRect(boxX, boxY, boxWidth, boxHeight);
        graphics.DrawString(dayStr, -1, &font, dayTextRect, &formatCenter, &dayTextBrush);
    } else {
        // No day box: flag on the left, date after it
        cx = 10.0f * s;
        dateX = cx + flagWidth + gap;
    }

    SolidBrush textBrush(useDarkText ? Color(255, 20, 20, 20) : Color(255, 255, 255, 255));

    // 3. Render Flag
    DrawNepaliFlag(graphics, cx, top, h);

    // 4. Render Date Text
    RectF dateRect(dateX, 0.0f, (REAL)rawWidth - dateX, (REAL)rawHeight);
    graphics.DrawString(dateStr.c_str(), -1, &font, dateRect, &formatNear, &textBrush);

    // Apply per-pixel alpha channel to OS Window
    POINT ptDst = { g_xPos + g_currentShiftX, g_yPos + g_currentShiftY };
    SIZE sizeDst = { rawWidth, rawHeight };
    POINT ptSrc = { 0, 0 };
    BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

    UpdateLayeredWindow(hWnd, hdcScreen, &ptDst, &sizeDst, hdcMem, &ptSrc, 0, &blend, ULW_ALPHA);

    SelectObject(hdcMem, hOldBitmap);
    DeleteObject(hBitmap);
    DeleteDC(hdcMem);
    ReleaseDC(NULL, hdcScreen);
}

// ── System Tray Icon Setup ───────────────────────────────────────────────────
#define WM_TRAYICON (WM_USER + 1)
NOTIFYICONDATAW g_nid = {};

void AddTrayIcon(HWND hWnd) {
    g_nid.cbSize = sizeof(NOTIFYICONDATAW);
    g_nid.hWnd = hWnd;
    g_nid.uID = 1;
    g_nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
    g_nid.uCallbackMessage = WM_TRAYICON;
    g_nid.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(1)); // Custom embedded logo
    wcscpy_s(g_nid.szTip, L"Tithify \u2014 Nepali Date Widget");
    Shell_NotifyIconW(NIM_ADD, &g_nid);
}

void RemoveTrayIcon() {
    Shell_NotifyIconW(NIM_DELETE, &g_nid);
}

// ── Custom GDI+ Context Menu Engine ──────────────────────────────────────────
void HideCustomMenu() {
    if (g_hMenuWnd && IsWindowVisible(g_hMenuWnd)) {
        ShowWindow(g_hMenuWnd, SW_HIDE);
        g_isMenuOpen = false;
    }
}

void RenderCustomMenu(HWND hWnd) {
    if (!hWnd) return;

    float s = g_dpiScale;
    int rawWidth = (int)(385 * s);
    int rawHeight = (int)(260 * s);

    HDC hdcScreen = GetDC(NULL);
    HDC hdcMem = CreateCompatibleDC(hdcScreen);

    BITMAPINFO bmi = {};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = rawWidth;
    bmi.bmiHeader.biHeight = -rawHeight;  // Top-down
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;
    void* pBits = NULL;
    HBITMAP hBitmap = CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, &pBits, NULL, 0);
    HBITMAP hOldBitmap = (HBITMAP)SelectObject(hdcMem, hBitmap);

    Graphics graphics(hdcMem);
    graphics.SetSmoothingMode(SmoothingModeHighQuality);
    graphics.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
    graphics.SetPixelOffsetMode(PixelOffsetModeHighQuality);
    graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);

    graphics.Clear(Color(0, 0, 0, 0));

    // ── Main Background Panel Card ───────────────────────────────────────────
    Color bgCardColor = g_isLightTheme ? Color(248, 245, 245, 248) : Color(245, 24, 24, 28);
    Color borderColor = g_isLightTheme ? Color(60, 0, 0, 0) : Color(60, 255, 255, 255);

    SolidBrush cardBrush(bgCardColor);
    GraphicsPath cardPath;
    REAL r = 14.0f * s;
    REAL d = r * 2.0f;
    REAL w = (REAL)rawWidth;
    REAL h = (REAL)rawHeight;
    cardPath.AddArc(0.0f, 0.0f, d, d, 180.0f, 90.0f);
    cardPath.AddArc(w - d, 0.0f, d, d, 270.0f, 90.0f);
    cardPath.AddArc(w - d, h - d, d, d, 0.0f, 90.0f);
    cardPath.AddArc(0.0f, h - d, d, d, 90.0f, 90.0f);
    cardPath.CloseFigure();

    graphics.FillPath(&cardBrush, &cardPath);
    Pen borderPen(borderColor, 1.5f * s);
    graphics.DrawPath(&borderPen, &cardPath);

    // ── Header Text ──────────────────────────────────────────────────────────
    FontFamily fontFamily(L"Segoe UI");
    Font titleFont(&fontFamily, 14.0f * s, FontStyleBold, UnitPixel);
    Font subFont(&fontFamily, 10.0f * s, FontStyleBold, UnitPixel);

    Color textColor = g_isLightTheme ? Color(255, 20, 20, 20) : Color(255, 255, 255, 255);
    Color subTextColor = g_isLightTheme ? Color(180, 80, 80, 80) : Color(180, 180, 180, 180);

    SolidBrush textBrush(textColor);
    SolidBrush subTextBrush(subTextColor);

    StringFormat formatNear;
    formatNear.SetAlignment(StringAlignmentNear);
    formatNear.SetLineAlignment(StringAlignmentCenter);

    StringFormat formatCenter;
    formatCenter.SetAlignment(StringAlignmentCenter);
    formatCenter.SetLineAlignment(StringAlignmentCenter);

    StringFormat formatFar;
    formatFar.SetAlignment(StringAlignmentFar);
    formatFar.SetLineAlignment(StringAlignmentCenter);

    REAL headerH = 38.0f * s;
    RectF headerLeftRect(18.0f * s, 0.0f, (w - 36.0f * s) / 2.0f, headerH);
    RectF headerRightRect(18.0f * s, 0.0f, w - 36.0f * s, headerH);

    graphics.DrawString(L"TITHIFY", -1, &titleFont, headerLeftRect, &formatNear, &textBrush);
    wchar_t versionStr[64];
    swprintf(versionStr, 64, L"Nepali Date Widget v%ls", APP_VERSION);
    graphics.DrawString(versionStr, -1, &subFont, headerRightRect, &formatFar, &subTextBrush);

    // Header horizontal line
    Color lineHorizColor = g_isLightTheme ? Color(40, 0, 0, 0) : Color(40, 255, 255, 255);
    Pen lineHorizPen(lineHorizColor, 1.0f * s);
    graphics.DrawLine(&lineHorizPen, 16.0f * s, headerH, w - 16.0f * s, headerH);

    // ── Center Vertical Divider Line (Theme Changeable) ──────────────────────
    Color dividerColor = g_isLightTheme ? Color(140, 0, 0, 0) : Color(140, 255, 255, 255);
    Pen dividerPen(dividerColor, 1.5f * s);
    graphics.DrawLine(&dividerPen, 172.0f * s, 48.0f * s, 172.0f * s, h - 16.0f * s);

    // ── Left Column: ON / OFF Toggles ────────────────────────────────────────
    Font labelFont(&fontFamily, 12.5f * s, FontStyleBold, UnitPixel);

    struct ToggleItem {
        const wchar_t* label;
        bool state;
    } toggles[3] = {
        { L"Run at Startup", IsStartupEnabled() },
        { L"Show Day", g_showDay },
        { L"Lock Position", !g_setupMode }
    };

    for (int i = 0; i < 3; i++) {
        REAL rowY = (52.0f + i * 62.0f) * s;
        REAL rowH = 48.0f * s;

        // Label (tight gap before toggle)
        RectF textRect(16.0f * s, rowY, 102.0f * s, rowH);
        graphics.DrawString(toggles[i].label, -1, &labelFont, textRect, &formatNear, &textBrush);

        // iOS Toggle Pill Switch
        REAL pillX = 120.0f * s;
        REAL pillY = rowY + (rowH - 24.0f * s) / 2.0f;
        REAL pillW = 44.0f * s;
        REAL pillH = 24.0f * s;
        REAL pillR = pillH / 2.0f;
        REAL pillD = pillR * 2.0f;

        GraphicsPath pillPath;
        pillPath.AddArc(pillX, pillY, pillD, pillD, 90.0f, 180.0f);
        pillPath.AddArc(pillX + pillW - pillD, pillY, pillD, pillD, 270.0f, 180.0f);
        pillPath.CloseFigure();

        Color pillBg = toggles[i].state ? Color(255, 52, 199, 89) : (g_isLightTheme ? Color(255, 200, 200, 204) : Color(255, 90, 90, 95));
        SolidBrush pillBrush(pillBg);
        graphics.FillPath(&pillBrush, &pillPath);

        // Circular Knob
        REAL knobSize = 20.0f * s;
        REAL knobY = pillY + (pillH - knobSize) / 2.0f;
        REAL knobX = toggles[i].state ? (pillX + pillW - knobSize - 2.0f * s) : (pillX + 2.0f * s);

        SolidBrush knobBrush(Color(255, 255, 255, 255));
        graphics.FillEllipse(&knobBrush, knobX, knobY, knobSize, knobSize);
    }

    // ── Right Column: Compact Action Buttons ─────────────────────────────────
    FontFamily fontMDL2(L"Segoe MDL2 Assets");
    Font iconFont(&fontMDL2, 11.0f * s, FontStyleRegular, UnitPixel);
    Font btnFont(&fontFamily, 11.5f * s, FontStyleBold, UnitPixel);

    struct ActionBtn {
        const wchar_t* icon;
        const wchar_t* label;
        int id;
    } buttons[5] = {
        { L"\uE787", L"Open Full Calendar", 7 },
        { L"\uE790", L"Background Color", 101 },
        { L"\uE72C", L"Check for Updates", 4 },
        { L"\uEB51", L"Support / Donate", 6 },
        { L"\uE711", L"Exit Widget", 2 }
    };

    for (int i = 0; i < 5; i++) {
        REAL btnX = 184.0f * s;
        REAL btnY = (48.0f + i * 39.0f) * s;
        REAL btnW = 185.0f * s;
        REAL btnH = 33.0f * s;

        bool isHovered = (g_menuHoverIndex == (3 + i));

        Color btnBg;
        if (g_isLightTheme) {
            btnBg = isHovered ? Color(60, 0, 0, 0) : Color(25, 0, 0, 0);
        } else {
            btnBg = isHovered ? Color(80, 255, 255, 255) : Color(35, 255, 255, 255);
        }

        SolidBrush btnBrush(btnBg);
        GraphicsPath btnPath;
        REAL br = 6.0f * s;
        REAL bd = br * 2.0f;
        btnPath.AddArc(btnX, btnY, bd, bd, 180.0f, 90.0f);
        btnPath.AddArc(btnX + btnW - bd, btnY, bd, bd, 270.0f, 90.0f);
        btnPath.AddArc(btnX + btnW - bd, btnY + btnH - bd, bd, bd, 0.0f, 90.0f);
        btnPath.AddArc(btnX, btnY + btnH - bd, bd, bd, 90.0f, 90.0f);
        btnPath.CloseFigure();

        graphics.FillPath(&btnBrush, &btnPath);

        // Icon (Segoe MDL2 Assets glyph)
        RectF iconRect(btnX + 6.0f * s, btnY, 20.0f * s, btnH);
        graphics.DrawString(buttons[i].icon, -1, &iconFont, iconRect, &formatCenter, &textBrush);

        // Text Label
        RectF btnTextRect(btnX + 28.0f * s, btnY, btnW - 32.0f * s, btnH);
        graphics.DrawString(buttons[i].label, -1, &btnFont, btnTextRect, &formatNear, &textBrush);
    }

    // Apply per-pixel alpha channel to OS Window
    POINT ptDst = { g_menuXPos, g_menuYPos };
    SIZE sizeDst = { rawWidth, rawHeight };
    POINT ptSrc = { 0, 0 };
    BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

    UpdateLayeredWindow(hWnd, hdcScreen, &ptDst, &sizeDst, hdcMem, &ptSrc, 0, &blend, ULW_ALPHA);

    SelectObject(hdcMem, hOldBitmap);
    DeleteObject(hBitmap);
    DeleteDC(hdcMem);
    ReleaseDC(NULL, hdcScreen);
}

LRESULT CALLBACK CustomMenuWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RenderCustomMenu(hWnd);
        EndPaint(hWnd, &ps);
        return 0;
    }

    case WM_MOUSEMOVE: {
        POINT pt;
        GetCursorPos(&pt);
        int localX = pt.x - g_menuXPos;
        int localY = pt.y - g_menuYPos;

        float s = g_dpiScale;
        int newHover = -1;

        if (localX >= (int)(14 * s) && localX <= (int)(168 * s)) {
            if (localY >= (int)(48 * s) && localY < (int)(108 * s)) newHover = 0;
            else if (localY >= (int)(108 * s) && localY < (int)(168 * s)) newHover = 1;
            else if (localY >= (int)(168 * s) && localY <= (int)(228 * s)) newHover = 2;
        } else if (localX >= (int)(176 * s) && localX <= (int)(375 * s)) {
            if (localY >= (int)(48 * s) && localY < (int)(84 * s)) newHover = 3;
            else if (localY >= (int)(88 * s) && localY < (int)(124 * s)) newHover = 4;
            else if (localY >= (int)(128 * s) && localY < (int)(164 * s)) newHover = 5;
            else if (localY >= (int)(168 * s) && localY < (int)(204 * s)) newHover = 6;
            else if (localY >= (int)(208 * s) && localY <= (int)(244 * s)) newHover = 7;
        }

        if (newHover != g_menuHoverIndex) {
            g_menuHoverIndex = newHover;
            RenderCustomMenu(hWnd);
        }
        break;
    }

    case WM_LBUTTONUP: {
        POINT pt;
        GetCursorPos(&pt);
        int localX = pt.x - g_menuXPos;
        int localY = pt.y - g_menuYPos;

        float s = g_dpiScale;
        int clicked = -1;

        if (localX >= (int)(14 * s) && localX <= (int)(168 * s)) {
            if (localY >= (int)(48 * s) && localY < (int)(108 * s)) clicked = 0;
            else if (localY >= (int)(108 * s) && localY < (int)(168 * s)) clicked = 1;
            else if (localY >= (int)(168 * s) && localY <= (int)(228 * s)) clicked = 2;
        } else if (localX >= (int)(176 * s) && localX <= (int)(375 * s)) {
            if (localY >= (int)(48 * s) && localY < (int)(84 * s)) clicked = 3;
            else if (localY >= (int)(88 * s) && localY < (int)(124 * s)) clicked = 4;
            else if (localY >= (int)(128 * s) && localY < (int)(164 * s)) clicked = 5;
            else if (localY >= (int)(168 * s) && localY < (int)(204 * s)) clicked = 6;
            else if (localY >= (int)(208 * s) && localY <= (int)(244 * s)) clicked = 7;
        }

        if (clicked == 0) {
            SetStartupEnabled(!IsStartupEnabled());
            RenderCustomMenu(hWnd);
        } else if (clicked == 1) {
            g_showDay = !g_showDay;
            UpdateWidgetMode();
            SaveConfig();
            RenderWidget(g_hWnd);
            RenderCustomMenu(hWnd);
        } else if (clicked == 2) {
            g_setupMode = !g_setupMode;
            if (g_setupMode && g_isCalendarOpen) HideCalendar();
            UpdateWidgetMode();
            SaveConfig();
            RenderWidget(g_hWnd);
            RenderCustomMenu(hWnd);
        } else if (clicked == 3) {
            HideCustomMenu();
            ShowCalendar(g_hWnd);
        } else if (clicked == 4) {
            HideCustomMenu();
            PickCustomBackgroundColor(g_hWnd);
        } else if (clicked == 5) {
            HideCustomMenu();
            HANDLE hThread = CreateThread(NULL, 0, CheckForUpdateThread, (LPVOID)TRUE, 0, NULL);
            if (hThread) CloseHandle(hThread);
        } else if (clicked == 6) {
            HideCustomMenu();
            ShellExecuteW(NULL, L"open", L"https://tithify.guptaaayush.com.np/#donate", NULL, NULL, SW_SHOWNORMAL);
        } else if (clicked == 7) {
            HideCustomMenu();
            PostQuitMessage(0);
        }
        break;
    }

    case WM_KILLFOCUS:
        HideCustomMenu();
        break;

    case WM_ACTIVATE:
        if (LOWORD(wParam) == WA_INACTIVE) {
            HideCustomMenu();
        }
        break;

    case WM_KEYDOWN:
        if (wParam == VK_ESCAPE) {
            HideCustomMenu();
        }
        break;

    default:
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }
    return 0;
}

void ShowCustomMenu(HWND hWndOwner, POINT pt) {
    if (!g_hMenuWnd) return;

    float s = g_dpiScale;
    int menuW = (int)(385 * s);
    int menuH = (int)(260 * s);

    HMONITOR hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
    MONITORINFO mi = { sizeof(mi) };
    GetMonitorInfo(hMon, &mi);

    RECT rcWidget = { 0 };
    if (hWndOwner && IsWindow(hWndOwner)) {
        GetWindowRect(hWndOwner, &rcWidget);
    }

    int x = 0, y = 0;

    if (hWndOwner && PtInRect(&rcWidget, pt)) {
        // Right-clicked directly on the Tithify widget: center horizontally and float 10px above it
        int widgetCenterX = rcWidget.left + (rcWidget.right - rcWidget.left) / 2;
        x = widgetCenterX - menuW / 2;
        y = rcWidget.top - menuH - (int)(10 * s);

        if (y < mi.rcWork.top) {
            y = rcWidget.bottom + (int)(10 * s);
        }
    } else {
        // Right-clicked on tray icon (in taskbar notification area or overflow flyout)
        // Find the root window under the cursor (e.g. overflow flyout or taskbar)
        HWND hUnder = WindowFromPoint(pt);
        HWND hRoot = hUnder ? GetAncestor(hUnder, GA_ROOT) : NULL;
        RECT rcAnchor = { pt.x, pt.y, pt.x, pt.y };
        if (hRoot && hRoot != g_hWnd && hRoot != g_hMenuWnd && hRoot != g_hCalWnd) {
            GetWindowRect(hRoot, &rcAnchor);
        }

        x = pt.x - menuW / 2;
        // Position cleanly above the entire anchor box (overflow flyout or taskbar)
        y = rcAnchor.top - menuH - (int)(10 * s);

        if (y < mi.rcWork.top) {
            // If placed too high, position below the anchor box
            y = rcAnchor.bottom + (int)(10 * s);
        }
    }

    // Clamp inside vertical screen bounds
    if (y + menuH > mi.rcWork.bottom) {
        y = mi.rcWork.bottom - menuH - (int)(8 * s);
    }
    if (y < mi.rcWork.top) {
        y = mi.rcWork.top + (int)(8 * s);
    }

    // Clamp inside horizontal screen bounds
    if (x + menuW > mi.rcWork.right - (int)(10 * s)) {
        x = mi.rcWork.right - menuW - (int)(10 * s);
    }
    if (x < mi.rcWork.left + (int)(10 * s)) {
        x = mi.rcWork.left + (int)(10 * s);
    }

    g_menuXPos = x;
    g_menuYPos = y;
    g_menuHoverIndex = -1;
    g_isMenuOpen = true;

    SetWindowPos(g_hMenuWnd, HWND_TOPMOST, g_menuXPos, g_menuYPos, menuW, menuH, SWP_NOACTIVATE);
    RenderCustomMenu(g_hMenuWnd);
    ShowWindow(g_hMenuWnd, SW_SHOWNOACTIVATE);
    SetForegroundWindow(g_hMenuWnd);
    SetFocus(g_hMenuWnd);
}

void ShowContextMenu(HWND hWnd, POINT pt) {
    ShowCustomMenu(hWnd, pt);
}

// ── Modern Fluent Dialog Engine ──────────────────────────────────────────────
enum ModernDialogType {
    MODERN_DLG_SUCCESS = 0,
    MODERN_DLG_UPDATE  = 1,
    MODERN_DLG_ERROR   = 2,
    MODERN_DLG_INFO    = 3
};

struct ModernDialogState {
    bool isOpen = false;
    int result = IDCANCEL;
    int hoverBtn = 0; // 0=none, 1=primary, 2=secondary, 99=close
    bool isDragging = false;
    POINT dragStart = { 0, 0 };
    int dlgX = 0;
    int dlgY = 0;
    int dlgW = 0;
    int dlgH = 0;

    wchar_t title[128] = { 0 };
    wchar_t message[512] = { 0 };
    wchar_t primaryBtn[64] = { 0 };
    wchar_t secondaryBtn[64] = { 0 };
    bool hasSecondary = false;
    int dialogType = 0;
} g_dlgState;

void RenderModernDialog(HWND hWnd) {
    if (!hWnd) return;

    int rawW = g_dlgState.dlgW;
    int rawH = g_dlgState.dlgH;
    float s = g_dpiScale;
    bool isLight = g_isLightTheme;

    HDC hdcScreen = GetDC(NULL);
    HDC hdcMem = CreateCompatibleDC(hdcScreen);

    BITMAPINFO bmi = {};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = rawW;
    bmi.bmiHeader.biHeight = -rawH;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;

    void* pBits = NULL;
    HBITMAP hBitmap = CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, &pBits, NULL, 0);
    HBITMAP hOldBitmap = (HBITMAP)SelectObject(hdcMem, hBitmap);

    Graphics g(hdcMem);
    g.SetSmoothingMode(SmoothingModeHighQuality);
    g.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
    g.SetPixelOffsetMode(PixelOffsetModeHighQuality);
    g.SetInterpolationMode(InterpolationModeHighQualityBicubic);

    g.Clear(Color(0, 0, 0, 0));

    REAL w = (REAL)rawW;
    REAL h = (REAL)rawH;

    // ── Load Application Logo ──
    HICON hIcon = (HICON)LoadImageW(GetModuleHandle(NULL), MAKEINTRESOURCEW(1),
                                    IMAGE_ICON, (int)(64 * s), (int)(64 * s), LR_DEFAULTCOLOR);
    if (!hIcon) {
        wchar_t exePath[MAX_PATH];
        GetModuleFileNameW(NULL, exePath, MAX_PATH);
        wchar_t* lastSlash = wcsrchr(exePath, L'\\');
        if (lastSlash) {
            *(lastSlash + 1) = L'\0';
            wcscat_s(exePath, L"icon.ico");
            hIcon = (HICON)LoadImageW(NULL, exePath, IMAGE_ICON, (int)(64 * s), (int)(64 * s), LR_LOADFROMFILE);
        }
    }
    Bitmap* pLogo = hIcon ? Bitmap::FromHICON(hIcon) : NULL;

    // ── Main Card Background (Solid high-contrast graphite in dark mode) ──
    Color bgCardColor = isLight ? Color(255, 255, 255, 255) : Color(255, 26, 27, 32);
    Color borderColor = isLight ? Color(60, 0, 0, 0) : Color(75, 255, 255, 255);

    GraphicsPath cardPath;
    REAL r = 16.0f * s;
    REAL d = r * 2.0f;
    cardPath.AddArc(0.0f, 0.0f, d, d, 180.0f, 90.0f);
    cardPath.AddArc(w - d, 0.0f, d, d, 270.0f, 90.0f);
    cardPath.AddArc(w - d, h - d, d, d, 0.0f, 90.0f);
    cardPath.AddArc(0.0f, h - d, d, d, 90.0f, 90.0f);
    cardPath.CloseFigure();

    SolidBrush cardBrush(bgCardColor);
    g.FillPath(&cardBrush, &cardPath);
    Pen borderPen(borderColor, 1.5f * s);
    g.DrawPath(&borderPen, &cardPath);

    // ── Header Bar ──
    REAL headerH = 42.0f * s;
    REAL hLogoSize = 22.0f * s;
    REAL hLogoX = 18.0f * s;
    REAL hLogoY = (headerH - hLogoSize) / 2.0f;
    if (pLogo && pLogo->GetWidth() > 0) {
        g.DrawImage(pLogo, RectF(hLogoX, hLogoY, hLogoSize, hLogoSize));
    }

    FontFamily fontFamily(L"Segoe UI");
    Font brandFont(&fontFamily, 13.0f * s, FontStyleBold, UnitPixel);
    Color brandColor = isLight ? Color(255, 20, 20, 20) : Color(255, 255, 255, 255);
    SolidBrush brandBrush(brandColor);

    StringFormat fmtNearCenter;
    fmtNearCenter.SetAlignment(StringAlignmentNear);
    fmtNearCenter.SetLineAlignment(StringAlignmentCenter);

    RectF brandRect(hLogoX + hLogoSize + 10.0f * s, 0.0f, 200.0f * s, headerH);
    g.DrawString(L"Tithify", -1, &brandFont, brandRect, &fmtNearCenter, &brandBrush);

    // Close button [X]
    REAL closeBtnSize = 26.0f * s;
    REAL closeBtnX = w - 16.0f * s - closeBtnSize;
    REAL closeBtnY = (headerH - closeBtnSize) / 2.0f;
    if (g_dlgState.hoverBtn == 99) {
        SolidBrush hoverCloseBrush(isLight ? Color(30, 0, 0, 0) : Color(45, 255, 255, 255));
        g.FillEllipse(&hoverCloseBrush, closeBtnX, closeBtnY, closeBtnSize, closeBtnSize);
    }
    Font closeFont(&fontFamily, 12.0f * s, FontStyleRegular, UnitPixel);
    StringFormat fmtCenter;
    fmtCenter.SetAlignment(StringAlignmentCenter);
    fmtCenter.SetLineAlignment(StringAlignmentCenter);
    RectF closeRect(closeBtnX, closeBtnY, closeBtnSize, closeBtnSize);
    SolidBrush closeBrush(isLight ? Color(180, 80, 80, 80) : Color(220, 200, 200, 200));
    g.DrawString(L"\u2715", -1, &closeFont, closeRect, &fmtCenter, &closeBrush);

    Color divColor = isLight ? Color(30, 0, 0, 0) : Color(35, 255, 255, 255);
    Pen divPen(divColor, 1.0f * s);
    g.DrawLine(&divPen, 16.0f * s, headerH, w - 16.0f * s, headerH);

    // ── Body Area: App Logo + Status Badge ──
    REAL iconBoxX = 22.0f * s;
    REAL iconBoxY = headerH + 20.0f * s;
    REAL iconBoxSize = 54.0f * s;

    if (pLogo && pLogo->GetWidth() > 0) {
        g.DrawImage(pLogo, RectF(iconBoxX, iconBoxY, iconBoxSize, iconBoxSize));
    }

    // Corner Status Badge Overlay
    REAL chkSize = 22.0f * s;
    REAL chkX = iconBoxX + iconBoxSize - chkSize + 3.0f * s;
    REAL chkY = iconBoxY + iconBoxSize - chkSize + 3.0f * s;

    Color badgeColor = (g_dlgState.dialogType == MODERN_DLG_SUCCESS)
        ? Color(255, 16, 185, 129) // emerald
        : ((g_dlgState.dialogType == MODERN_DLG_UPDATE) ? Color(255, 220, 38, 38) : Color(255, 239, 68, 68)); // red or amber-red

    SolidBrush chkBgBrush(badgeColor);
    g.FillEllipse(&chkBgBrush, chkX, chkY, chkSize, chkSize);
    Pen chkRingPen(bgCardColor, 2.2f * s);
    g.DrawEllipse(&chkRingPen, chkX, chkY, chkSize, chkSize);

    REAL ccx = chkX + chkSize / 2.0f;
    REAL ccy = chkY + chkSize / 2.0f;
    if (g_dlgState.dialogType == MODERN_DLG_SUCCESS) {
        // White Checkmark
        Pen checkPen(Color(255, 255, 255, 255), 2.2f * s);
        checkPen.SetStartCap(LineCapRound);
        checkPen.SetEndCap(LineCapRound);
        checkPen.SetLineJoin(LineJoinRound);
        PointF pt1(ccx - 4.5f * s, ccy + 0.0f * s);
        PointF pt2(ccx - 1.0f * s, ccy + 3.5f * s);
        PointF pt3(ccx + 4.5f * s, ccy - 3.0f * s);
        PointF pts[3] = { pt1, pt2, pt3 };
        g.DrawLines(&checkPen, pts, 3);
    } else if (g_dlgState.dialogType == MODERN_DLG_UPDATE) {
        // White Download Arrow
        Pen arrowPen(Color(255, 255, 255, 255), 2.0f * s);
        arrowPen.SetStartCap(LineCapRound);
        arrowPen.SetEndCap(LineCapRound);
        g.DrawLine(&arrowPen, ccx, ccy - 4.5f * s, ccx, ccy + 3.5f * s);
        PointF h1(ccx - 3.0f * s, ccy + 1.0f * s);
        PointF h2(ccx, ccy + 3.8f * s);
        PointF h3(ccx + 3.0f * s, ccy + 1.0f * s);
        PointF hPts[3] = { h1, h2, h3 };
        g.DrawLines(&arrowPen, hPts, 3);
    } else {
        // White Cross
        Pen crossPen(Color(255, 255, 255, 255), 2.0f * s);
        crossPen.SetStartCap(LineCapRound);
        crossPen.SetEndCap(LineCapRound);
        REAL cr = 3.5f * s;
        g.DrawLine(&crossPen, ccx - cr, ccy - cr, ccx + cr, ccy + cr);
        g.DrawLine(&crossPen, ccx + cr, ccy - cr, ccx - cr, ccy + cr);
    }

    // ── Typography: Large, Bold, Ultra-High Contrast ──
    REAL textX = iconBoxX + iconBoxSize + 18.0f * s;
    REAL textW = w - textX - 22.0f * s;

    Font titleFont(&fontFamily, 17.5f * s, FontStyleBold, UnitPixel);
    Color titleColor = isLight ? Color(255, 15, 15, 15) : Color(255, 255, 255, 255);
    SolidBrush titleBrush(titleColor);
    RectF titleRect(textX, iconBoxY - 2.0f * s, textW, 26.0f * s);
    g.DrawString(g_dlgState.title, -1, &titleFont, titleRect, &fmtNearCenter, &titleBrush);

    Font msgFont(&fontFamily, 13.5f * s, FontStyleRegular, UnitPixel);
    // 92% luminance in dark mode (bright and crystal clear), dark slate in light mode
    Color msgColor = isLight ? Color(255, 60, 64, 72) : Color(255, 228, 232, 238);
    SolidBrush msgBrush(msgColor);

    StringFormat fmtWrap;
    fmtWrap.SetAlignment(StringAlignmentNear);
    fmtWrap.SetLineAlignment(StringAlignmentNear);
    RectF msgRect(textX, iconBoxY + 28.0f * s, textW, h - (iconBoxY + 28.0f * s) - 58.0f * s);
    g.DrawString(g_dlgState.message, -1, &msgFont, msgRect, &fmtWrap, &msgBrush);

    // ── Bottom Action Buttons ──
    REAL btnH = 38.0f * s;
    REAL btnY = h - 18.0f * s - btnH;
    REAL primaryW = g_dlgState.hasSecondary ? (118.0f * s) : (100.0f * s);
    REAL primaryX = w - 18.0f * s - primaryW;

    Font btnFont(&fontFamily, 13.5f * s, FontStyleBold, UnitPixel);

    if (g_dlgState.hasSecondary) {
        REAL secW = 94.0f * s;
        REAL secX = primaryX - 10.0f * s - secW;

        GraphicsPath secPath;
        REAL secR = 9.0f * s;
        REAL secD = secR * 2.0f;
        secPath.AddArc(secX, btnY, secD, secD, 180.0f, 90.0f);
        secPath.AddArc(secX + secW - secD, btnY, secD, secD, 270.0f, 90.0f);
        secPath.AddArc(secX + secW - secD, btnY + btnH - secD, secD, secD, 0.0f, 90.0f);
        secPath.AddArc(secX, btnY + btnH - secD, secD, secD, 90.0f, 90.0f);
        secPath.CloseFigure();

        Color secBg = (g_dlgState.hoverBtn == 2)
            ? (isLight ? Color(35, 0, 0, 0) : Color(45, 255, 255, 255))
            : (isLight ? Color(15, 0, 0, 0) : Color(20, 255, 255, 255));
        SolidBrush secBrush(secBg);
        g.FillPath(&secBrush, &secPath);

        Pen secBorder(isLight ? Color(50, 0, 0, 0) : Color(50, 255, 255, 255), 1.0f * s);
        g.DrawPath(&secBorder, &secPath);

        RectF secTextRect(secX, btnY, secW, btnH);
        SolidBrush secTextBrush(isLight ? Color(255, 30, 30, 30) : Color(255, 240, 240, 240));
        g.DrawString(g_dlgState.secondaryBtn, -1, &btnFont, secTextRect, &fmtCenter, &secTextBrush);
    }

    GraphicsPath primPath;
    REAL primR = 9.0f * s;
    REAL primD = primR * 2.0f;
    primPath.AddArc(primaryX, btnY, primD, primD, 180.0f, 90.0f);
    primPath.AddArc(primaryX + primaryW - primD, btnY, primD, primD, 270.0f, 90.0f);
    primPath.AddArc(primaryX + primaryW - primD, btnY + btnH - primD, primD, primD, 0.0f, 90.0f);
    primPath.AddArc(primaryX, btnY + btnH - primD, primD, primD, 90.0f, 90.0f);
    primPath.CloseFigure();

    Color primBg = (g_dlgState.hoverBtn == 1)
        ? Color(255, 239, 68, 68)  // hover lighter red
        : Color(255, 220, 38, 38);  // Tithify brand red
    SolidBrush primBrush(primBg);
    g.FillPath(&primBrush, &primPath);

    RectF primTextRect(primaryX, btnY, primaryW, btnH);
    SolidBrush primTextBrush(Color(255, 255, 255, 255));
    g.DrawString(g_dlgState.primaryBtn, -1, &btnFont, primTextRect, &fmtCenter, &primTextBrush);

    POINT ptDst = { g_dlgState.dlgX, g_dlgState.dlgY };
    SIZE sizeDst = { rawW, rawH };
    POINT ptSrc = { 0, 0 };
    BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

    UpdateLayeredWindow(hWnd, hdcScreen, &ptDst, &sizeDst, hdcMem, &ptSrc, 0, &blend, ULW_ALPHA);

    if (pLogo) delete pLogo;
    if (hIcon) DestroyIcon(hIcon);

    SelectObject(hdcMem, hOldBitmap);
    DeleteObject(hBitmap);
    DeleteDC(hdcMem);
    ReleaseDC(NULL, hdcScreen);
}

LRESULT CALLBACK ModernDialogWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_SETCURSOR: {
        POINT pt;
        GetCursorPos(&pt);
        int lx = pt.x - g_dlgState.dlgX;
        int ly = pt.y - g_dlgState.dlgY;

        float s = g_dpiScale;
        int w = g_dlgState.dlgW;
        int h = g_dlgState.dlgH;
        int btnH = (int)(38 * s);
        int btnY = h - (int)(18 * s) - btnH;
        int primaryW = g_dlgState.hasSecondary ? (int)(118 * s) : (int)(100 * s);
        int primaryX = w - (int)(18 * s) - primaryW;

        bool onButton = false;
        if (lx >= primaryX && lx <= primaryX + primaryW && ly >= btnY && ly <= btnY + btnH) {
            onButton = true;
        } else if (g_dlgState.hasSecondary) {
            int secW = (int)(94 * s);
            int secX = primaryX - (int)(10 * s) - secW;
            if (lx >= secX && lx <= secX + secW && ly >= btnY && ly <= btnY + btnH) {
                onButton = true;
            }
        }
        int closeBtnSize = (int)(26 * s);
        int closeBtnX = w - (int)(16 * s) - closeBtnSize;
        int closeBtnY = (int)((42 * s - closeBtnSize) / 2);
        if (lx >= closeBtnX && lx <= closeBtnX + closeBtnSize && ly >= closeBtnY && ly <= closeBtnY + closeBtnSize) {
            onButton = true;
        }

        if (onButton) {
            SetCursor(LoadCursor(NULL, IDC_HAND));
            return TRUE;
        }
        SetCursor(LoadCursor(NULL, IDC_ARROW));
        return TRUE;
    }

    case WM_MOUSEMOVE: {
        POINT pt;
        GetCursorPos(&pt);
        int lx = pt.x - g_dlgState.dlgX;
        int ly = pt.y - g_dlgState.dlgY;

        if (g_dlgState.isDragging) {
            g_dlgState.dlgX = pt.x - g_dlgState.dragStart.x;
            g_dlgState.dlgY = pt.y - g_dlgState.dragStart.y;
            RenderModernDialog(hWnd);
            break;
        }

        float s = g_dpiScale;
        int w = g_dlgState.dlgW;
        int h = g_dlgState.dlgH;
        int btnH = (int)(38 * s);
        int btnY = h - (int)(18 * s) - btnH;
        int primaryW = g_dlgState.hasSecondary ? (int)(118 * s) : (int)(100 * s);
        int primaryX = w - (int)(18 * s) - primaryW;

        int newHover = 0;
        if (lx >= primaryX && lx <= primaryX + primaryW && ly >= btnY && ly <= btnY + btnH) {
            newHover = 1;
        } else if (g_dlgState.hasSecondary) {
            int secW = (int)(94 * s);
            int secX = primaryX - (int)(10 * s) - secW;
            if (lx >= secX && lx <= secX + secW && ly >= btnY && ly <= btnY + btnH) {
                newHover = 2;
            }
        }
        int closeBtnSize = (int)(26 * s);
        int closeBtnX = w - (int)(16 * s) - closeBtnSize;
        int closeBtnY = (int)((42 * s - closeBtnSize) / 2);
        if (lx >= closeBtnX && lx <= closeBtnX + closeBtnSize && ly >= closeBtnY && ly <= closeBtnY + closeBtnSize) {
            newHover = 99;
        }

        if (newHover != g_dlgState.hoverBtn) {
            g_dlgState.hoverBtn = newHover;
            RenderModernDialog(hWnd);
        }
        break;
    }

    case WM_LBUTTONDOWN: {
        POINT pt;
        GetCursorPos(&pt);
        int lx = pt.x - g_dlgState.dlgX;
        int ly = pt.y - g_dlgState.dlgY;

        float s = g_dpiScale;
        int w = g_dlgState.dlgW;
        int h = g_dlgState.dlgH;
        int btnH = (int)(38 * s);
        int btnY = h - (int)(18 * s) - btnH;
        int primaryW = g_dlgState.hasSecondary ? (int)(118 * s) : (int)(100 * s);
        int primaryX = w - (int)(18 * s) - primaryW;

        bool onBtn = (lx >= primaryX && lx <= primaryX + primaryW && ly >= btnY && ly <= btnY + btnH);
        if (!onBtn && g_dlgState.hasSecondary) {
            int secW = (int)(94 * s);
            int secX = primaryX - (int)(10 * s) - secW;
            if (lx >= secX && lx <= secX + secW && ly >= btnY && ly <= btnY + btnH) onBtn = true;
        }
        int closeBtnSize = (int)(26 * s);
        int closeBtnX = w - (int)(16 * s) - closeBtnSize;
        int closeBtnY = (int)((42 * s - closeBtnSize) / 2);
        if (lx >= closeBtnX && lx <= closeBtnX + closeBtnSize && ly >= closeBtnY && ly <= closeBtnY + closeBtnSize) onBtn = true;

        if (!onBtn) {
            g_dlgState.isDragging = true;
            SetCapture(hWnd);
            g_dlgState.dragStart.x = pt.x - g_dlgState.dlgX;
            g_dlgState.dragStart.y = pt.y - g_dlgState.dlgY;
        }
        break;
    }

    case WM_LBUTTONUP: {
        if (g_dlgState.isDragging) {
            g_dlgState.isDragging = false;
            ReleaseCapture();
        }

        POINT pt;
        GetCursorPos(&pt);
        int lx = pt.x - g_dlgState.dlgX;
        int ly = pt.y - g_dlgState.dlgY;

        float s = g_dpiScale;
        int w = g_dlgState.dlgW;
        int h = g_dlgState.dlgH;
        int btnH = (int)(38 * s);
        int btnY = h - (int)(18 * s) - btnH;
        int primaryW = g_dlgState.hasSecondary ? (int)(118 * s) : (int)(100 * s);
        int primaryX = w - (int)(18 * s) - primaryW;

        if (lx >= primaryX && lx <= primaryX + primaryW && ly >= btnY && ly <= btnY + btnH) {
            g_dlgState.result = g_dlgState.hasSecondary ? IDYES : IDOK;
            g_dlgState.isOpen = false;
        } else if (g_dlgState.hasSecondary) {
            int secW = (int)(94 * s);
            int secX = primaryX - (int)(10 * s) - secW;
            if (lx >= secX && lx <= secX + secW && ly >= btnY && ly <= btnY + btnH) {
                g_dlgState.result = IDNO;
                g_dlgState.isOpen = false;
            }
        }
        int closeBtnSize = (int)(26 * s);
        int closeBtnX = w - (int)(16 * s) - closeBtnSize;
        int closeBtnY = (int)((42 * s - closeBtnSize) / 2);
        if (lx >= closeBtnX && lx <= closeBtnX + closeBtnSize && ly >= closeBtnY && ly <= closeBtnY + closeBtnSize) {
            g_dlgState.result = g_dlgState.hasSecondary ? IDCANCEL : IDOK;
            g_dlgState.isOpen = false;
        }
        break;
    }

    case WM_DESTROY:
        g_dlgState.isOpen = false;
        break;

    default:
        return DefWindowProcW(hWnd, msg, wParam, lParam);
    }
    return 0;
}

int ShowModernDialog(HWND hWndParent,
                     const wchar_t* title,
                     const wchar_t* message,
                     ModernDialogType type = MODERN_DLG_SUCCESS,
                     const wchar_t* primaryBtnText = L"OK",
                     const wchar_t* secondaryBtnText = NULL) {
    HINSTANCE hInst = GetModuleHandle(NULL);
    static bool s_classRegistered = false;
    if (!s_classRegistered) {
        WNDCLASSEXW wc = { sizeof(WNDCLASSEXW) };
        wc.lpfnWndProc = ModernDialogWndProc;
        wc.hInstance = hInst;
        wc.lpszClassName = L"NepaliModernDialogClass";
        RegisterClassExW(&wc);
        s_classRegistered = true;
    }

    float s = g_dpiScale;
    g_dlgState.dlgW = (int)(440 * s);
    g_dlgState.dlgH = (int)((secondaryBtnText != NULL ? 235 : 215) * s);
    g_dlgState.dialogType = type;
    g_dlgState.hoverBtn = 0;
    g_dlgState.isDragging = false;
    g_dlgState.hasSecondary = (secondaryBtnText != NULL);
    wcscpy_s(g_dlgState.title, title ? title : L"Tithify");
    wcscpy_s(g_dlgState.message, message ? message : L"");
    wcscpy_s(g_dlgState.primaryBtn, primaryBtnText ? primaryBtnText : L"OK");
    if (secondaryBtnText) wcscpy_s(g_dlgState.secondaryBtn, secondaryBtnText);
    else g_dlgState.secondaryBtn[0] = 0;

    HMONITOR hMon = MonitorFromWindow(hWndParent ? hWndParent : (g_hWnd ? g_hWnd : GetDesktopWindow()), MONITOR_DEFAULTTONEAREST);
    MONITORINFO mi = { sizeof(mi) };
    GetMonitorInfo(hMon, &mi);

    g_dlgState.dlgX = mi.rcWork.left + (mi.rcWork.right - mi.rcWork.left - g_dlgState.dlgW) / 2;
    g_dlgState.dlgY = mi.rcWork.top + (mi.rcWork.bottom - mi.rcWork.top - g_dlgState.dlgH) / 2;

    HWND hDlg = CreateWindowExW(
        WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
        L"NepaliModernDialogClass",
        L"Tithify Dialog",
        WS_POPUP,
        g_dlgState.dlgX, g_dlgState.dlgY, g_dlgState.dlgW, g_dlgState.dlgH,
        NULL, NULL, hInst, NULL
    );

    if (!hDlg) return IDCANCEL;

    g_dlgState.isOpen = true;
    g_dlgState.result = g_dlgState.hasSecondary ? IDCANCEL : IDOK;

    RenderModernDialog(hDlg);
    ShowWindow(hDlg, SW_SHOWNOACTIVATE);
    SetForegroundWindow(hDlg);
    SetFocus(hDlg);

    if (hWndParent && IsWindow(hWndParent)) {
        EnableWindow(hWndParent, FALSE);
    }

    MSG msg;
    while (g_dlgState.isOpen && GetMessage(&msg, NULL, 0, 0)) {
        if (msg.message == WM_KEYDOWN) {
            if (msg.wParam == VK_ESCAPE) {
                g_dlgState.result = g_dlgState.hasSecondary ? IDCANCEL : IDOK;
                g_dlgState.isOpen = false;
                break;
            } else if (msg.wParam == VK_RETURN || msg.wParam == VK_SPACE) {
                g_dlgState.result = g_dlgState.hasSecondary ? IDYES : IDOK;
                g_dlgState.isOpen = false;
                break;
            }
        }
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    if (hWndParent && IsWindow(hWndParent)) {
        EnableWindow(hWndParent, TRUE);
        SetForegroundWindow(hWndParent);
    }

    DestroyWindow(hDlg);
    return g_dlgState.result;
}

// ── Win32 Message Loop Engine ────────────────────────────────────────────────
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static UINT s_uTaskbarRestartMsg = 0;
    if (!s_uTaskbarRestartMsg) {
        s_uTaskbarRestartMsg = RegisterWindowMessageW(L"TaskbarCreated");
    }
    if (msg == s_uTaskbarRestartMsg && s_uTaskbarRestartMsg != 0) {
        AddTrayIcon(hWnd);
        UpdateWidgetMode();
        return 0;
    }

    switch (msg) {
    case WM_CREATE:
        AddTrayIcon(hWnd);
        SetTimer(hWnd, 1, 1000, NULL);   // Render timer
        SetTimer(hWnd, 2, 16, NULL);     // High-precision (60 FPS) animation & taskbar sync ticker
        break;

    case WM_TIMER:
        if (wParam == 1) {
            RenderWidget(hWnd);

            // Auto-recovery: periodically retry fetching holidays in background when offline
            if (g_holidayFetchState == FETCH_ERROR_OFFLINE && !g_isHolidayFetchInProgress) {
                DWORD now = GetTickCount();
                if (now - g_lastHolidayFetchAttemptTime >= 30000) {
                    int cy, cm, cd, cdow;
                    GetCurrentBSDate(cy, cm, cd, cdow);
                    EnsureHolidaysLoadedForCurrentYear(cy, true);
                }
            }
        } else if (wParam == 2) {
            // ── Click-outside-to-close for calendar ──
            if (g_isCalendarOpen && g_hCalWnd) {
                // Ignore clicks during initial opening grace period (300ms)
                if (GetTickCount() - g_calAnimStartTime > 300) {
                    if ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) ||
                        (GetAsyncKeyState(VK_RBUTTON) & 0x8000) ||
                        (GetAsyncKeyState(VK_MBUTTON) & 0x8000)) {
                        POINT cursor;
                        GetCursorPos(&cursor);
                        RECT rcWidget;
                        GetWindowRect(hWnd, &rcWidget);
                        // Close if click is outside both the calendar cards and the widget
                        if (!IsPointInCalendar(cursor) && !PtInRect(&rcWidget, cursor)) {
                            HideCalendar();
                        }
                    }
                }
            }

            // ── Fullscreen App Detection (throttled to 200ms) ──
            static DWORD s_lastFullscreenCheckTime = 0;
            static bool s_cachedFullscreen = false;
            DWORD nowTicks = GetTickCount();
            if (!g_setupMode && (nowTicks - s_lastFullscreenCheckTime >= 200)) {
                s_lastFullscreenCheckTime = nowTicks;
                s_cachedFullscreen = IsFullscreenAppRunning();
            }

            TaskbarSyncState syncState = GetTaskbarSyncState();
            bool fullscreen = s_cachedFullscreen;

            // Fullscreen hide rule: hide during fullscreen apps UNLESS auto-hide taskbar is revealed by hovering
            bool shouldHideFullscreen = fullscreen && (syncState.isAutoHide ? syncState.isCompletelyHidden : true);

            if (shouldHideFullscreen && !g_hiddenForFullscreen) {
                g_hiddenForFullscreen = true;
                if (g_isCalendarOpen) HideCalendarImmediate();
                if (g_isMenuOpen) HideCustomMenu();
                ShowWindow(hWnd, SW_HIDE);
            } else if (!shouldHideFullscreen && g_hiddenForFullscreen) {
                g_hiddenForFullscreen = false;
                if (!g_hiddenForTaskbar) {
                    ShowWindow(hWnd, SW_SHOWNOACTIVATE);
                    RenderWidget(hWnd);
                }
            }

            // ── Pixel-Accurate Taskbar Auto-Hide Animation Sync ──
            if (!g_setupMode && g_isOnTaskbar && syncState.isAutoHide) {
                if (syncState.isCompletelyHidden) {
                    if (!g_hiddenForTaskbar) {
                        g_hiddenForTaskbar = true;
                        if (g_isCalendarOpen) HideCalendarImmediate();
                        if (g_isMenuOpen) HideCustomMenu();
                        ShowWindow(hWnd, SW_HIDE);
                    }
                } else {
                    bool wasHidden = g_hiddenForTaskbar;
                    g_hiddenForTaskbar = false;

                    bool shiftChanged = (g_currentShiftX != syncState.shiftX || g_currentShiftY != syncState.shiftY);
                    g_currentShiftX = syncState.shiftX;
                    g_currentShiftY = syncState.shiftY;

                    if ((wasHidden || !IsWindowVisible(hWnd)) && !shouldHideFullscreen) {
                        ShowWindow(hWnd, SW_SHOWNOACTIVATE);
                        RenderWidget(hWnd);
                    } else if (shiftChanged && !shouldHideFullscreen && IsWindowVisible(hWnd)) {
                        SetWindowPos(hWnd, NULL, g_xPos + g_currentShiftX, g_yPos + g_currentShiftY, 0, 0,
                                     SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
                    }
                }
            } else {
                if (g_currentShiftX != 0 || g_currentShiftY != 0) {
                    g_currentShiftX = 0;
                    g_currentShiftY = 0;
                    if (!shouldHideFullscreen && IsWindowVisible(hWnd)) {
                        SetWindowPos(hWnd, NULL, g_xPos, g_yPos, 0, 0,
                                     SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
                    }
                }
                if (g_hiddenForTaskbar) {
                    g_hiddenForTaskbar = false;
                }
            }

            // ── Ensure window stays visible & un-minimized if not hidden for fullscreen or auto-hide taskbar ──
            if (!shouldHideFullscreen && !g_hiddenForTaskbar) {
                if (IsIconic(hWnd)) {
                    ShowWindow(hWnd, SW_RESTORE);
                }
                if (!IsWindowVisible(hWnd)) {
                    ShowWindow(hWnd, SW_SHOWNOACTIVATE);
                    RenderWidget(hWnd);
                }
            }

            // ── Z-Order Management & Taskbar Sync (50ms responsive check) ──
            static DWORD s_lastZCheckTime = 0;
            if (!shouldHideFullscreen && !g_hiddenForTaskbar && !g_isMenuOpen && !g_isCalendarOpen) {
                if (g_setupMode || g_isOnTaskbar) {
                    bool needZOrderUpdate = (nowTicks - s_lastZCheckTime >= 50);
                    if (!needZOrderUpdate) {
                        HWND hTaskbar = FindWindowW(L"Shell_TrayWnd", NULL);
                        if (hTaskbar) {
                            HWND hPrev = GetWindow(hWnd, GW_HWNDPREV);
                            if (hPrev == hTaskbar) {
                                needZOrderUpdate = true;
                            }
                        }
                    }
                    if (needZOrderUpdate) {
                        s_lastZCheckTime = nowTicks;
                        SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0,
                                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
                    }
                }
            }
        }
        break;

    // ── Block minimization completely (e.g. from Show Desktop / Win+D / 3-finger swipe) ──
    case WM_SYSCOMMAND:
        if ((wParam & 0xFFF0) == SC_MINIMIZE) {
            return 0;  // Block SC_MINIMIZE!
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);

    case WM_SIZE:
        if (wParam == SIZE_MINIMIZED && !g_hiddenForFullscreen && !g_hiddenForTaskbar) {
            ShowWindow(hWnd, SW_RESTORE);
            return 0;
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);

    // ── Prevent Windows / Explorer / Show Desktop / Aero Peek from hiding us ──
    case WM_SHOWWINDOW:
        if (wParam == FALSE) {
            if (!g_hiddenForFullscreen && !g_hiddenForTaskbar) {
                PostMessage(hWnd, WM_USER + 99, 0, 0);
                return 0;  // Stay visible unless explicitly hidden for fullscreen or taskbar
            }
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);

    case WM_WINDOWPOSCHANGING: {
        WINDOWPOS* wp = (WINDOWPOS*)lParam;
        if (wp && !g_hiddenForFullscreen && !g_hiddenForTaskbar) {
            wp->flags &= ~SWP_HIDEWINDOW;
            // Prevent Explorer from moving window to iconic off-screen (-32000, -32000)
            if (wp->x <= -30000 || wp->y <= -30000) {
                wp->x = g_xPos;
                wp->y = g_yPos;
                wp->flags |= SWP_NOMOVE;
            }
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    case WM_USER + 99:
        if (!g_hiddenForFullscreen && !g_hiddenForTaskbar) {
            if (IsIconic(hWnd)) ShowWindow(hWnd, SW_RESTORE);
            ShowWindow(hWnd, SW_SHOWNOACTIVATE);
            if (g_setupMode || g_isOnTaskbar) {
                SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0,
                             SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
            } else {
                HWND hDesktop = GetDesktopHostWindow();
                if (hDesktop && (HWND)GetWindowLongPtr(hWnd, GWLP_HWNDPARENT) != hDesktop) {
                    SetWindowLongPtr(hWnd, GWLP_HWNDPARENT, (LONG_PTR)hDesktop);
                }
                SetWindowPos(hWnd, HWND_BOTTOM, 0, 0, 0, 0,
                             SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
            }
            RenderWidget(hWnd);
        }
        break;

    case WM_MOUSEACTIVATE:
        return MA_NOACTIVATE;

    case WM_LBUTTONDOWN:
        if (g_setupMode) {
            // Setup mode: capture mouse for dragging
            g_isDragging = true;
            g_hasDragged = false;
            SetCapture(hWnd);
            GetCursorPos(&g_dragStart);
            g_dragStart.x -= g_xPos;
            g_dragStart.y -= g_yPos;
        } else {
            // Locked mode: open/close calendar on press
            // Don't SetCapture — WS_EX_NOACTIVATE window can drop WM_LBUTTONUP
            if (GetTickCount() - g_lastCalCloseTime > 250) {
                ToggleCalendar(hWnd);
            }
        }
        break;

    case WM_MOUSEMOVE:
        if (g_isDragging && g_setupMode) {
            POINT pt;
            GetCursorPos(&pt);
            int newX = pt.x - g_dragStart.x;
            int newY = pt.y - g_dragStart.y;
            if (abs(newX - g_xPos) > 2 || abs(newY - g_yPos) > 2) {
                g_hasDragged = true;
            }
            g_xPos = newX;
            g_yPos = newY;
            RenderWidget(hWnd);
        }
        break;

    case WM_LBUTTONUP:
        if (g_isDragging) {
            g_isDragging = false;
            ReleaseCapture();
            UpdateWidgetMode();
            SaveConfig();
        }
        break;

    case WM_RBUTTONUP: {
        POINT pt;
        GetCursorPos(&pt);
        ShowContextMenu(hWnd, pt);
        break;
    }

    case WM_TRAYICON:
        if (lParam == WM_RBUTTONUP || lParam == WM_LBUTTONUP) {
            POINT pt;
            GetCursorPos(&pt);
            ShowContextMenu(hWnd, pt);
        }
        break;

    case WM_DESTROY:
        RemoveTrayIcon();
        PostQuitMessage(0);
        break;

    // ── Update notification ──────────────────────────────────────────────────
    case WM_UPDATE_AVAILABLE: {
        wchar_t msg[320];
        swprintf(msg, 320,
            L"Version %ls is now available! Click Update Now to download and install. The widget will restart automatically.",
            g_latestVersion);
        int choice = ShowModernDialog(hWnd,
                                      L"Update Available",
                                      msg,
                                      MODERN_DLG_UPDATE,
                                      L"Update Now",
                                      L"Later");
        if (choice == IDYES || choice == IDOK) {
            // Open a visible PowerShell console that handles the full update
            LaunchUpdaterConsole(g_latestVersion);
            // Close the widget so the installer can overwrite Tithify.exe
            PostMessage(g_hWnd, WM_CLOSE, 0, 0);
        }
        break;
    }

    case WM_UPDATE_NOT_FOUND:
        ShowModernDialog(hWnd,
                         L"You're Up to Date",
                         L"You are already running the latest version of Tithify.",
                         MODERN_DLG_SUCCESS,
                         L"OK");
        break;

    case WM_UPDATE_ERROR:
        ShowModernDialog(hWnd,
                         L"Update Check Failed",
                         L"Unable to check for updates. Please verify your internet connection and try again.",
                         MODERN_DLG_ERROR,
                         L"OK");
        break;


    case WM_HOLIDAYS_LOADED:
        RenderWidget(hWnd);
        if (g_isCalendarOpen && g_hCalWnd) {
            RenderCalendar(g_hCalWnd);
        }
        break;

    case WM_HOLIDAYS_FAILED:
        if (g_isCalendarOpen && g_hCalWnd) {
            RenderCalendar(g_hCalWnd);
        }
        break;

    // ── Theme change detection ─────────────────────────────────────────────
    case WM_SETTINGCHANGE:
        if (lParam && wcscmp((LPCWSTR)lParam, L"ImmersiveColorSet") == 0) {
            g_isLightTheme = DetectWindowsTheme();
            RenderWidget(hWnd);
            if (g_isCalendarOpen && g_hCalWnd) {
                RenderCalendar(g_hCalWnd);
            }
        }
        break;

    default:
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }
    return 0;
}

// ── Application Entrypoint ───────────────────────────────────────────────────
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    HANDLE hMutex = CreateMutex(NULL, TRUE, L"Tithify_Mutex_Unique_App_ID");
    if (GetLastError() == ERROR_ALREADY_EXISTS) {
        MessageBox(NULL, L"The application is already running.", L"Tithify", MB_OK | MB_ICONINFORMATION);
        CloseHandle(hMutex);
        return 0;
    }

    // ── DPI Awareness: Render at native resolution, no bitmap scaling ────
    typedef BOOL (WINAPI *SetProcessDpiAwarenessContextFunc)(HANDLE);
    HMODULE hUser32 = GetModuleHandleW(L"user32.dll");
    if (hUser32) {
        auto fn = (SetProcessDpiAwarenessContextFunc)GetProcAddress(hUser32, "SetProcessDpiAwarenessContext");
        if (fn) {
            fn(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
        } else {
            SetProcessDPIAware();  // Fallback for older Windows 10
        }
    }

    // Compute DPI scale
    HDC hdc = GetDC(NULL);
    g_dpiScale = GetDeviceCaps(hdc, LOGPIXELSX) / 96.0f;
    ReleaseDC(NULL, hdc);

    LoadConfig();

    // Detect initial Windows theme
    g_isLightTheme = DetectWindowsTheme();

    GdiplusStartupInput gdiplusStartupInput;
    GdiplusStartup(&g_gdiplusToken, &gdiplusStartupInput, NULL);

    // Register Widget Class
    WNDCLASSEX wc = { 0 };
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = L"NepaliTaskbarWidgetClass";
    wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(1));
    wc.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(1));
    RegisterClassEx(&wc);

    // Register Calendar Popup Class
    WNDCLASSEX wcCal = { 0 };
    wcCal.cbSize = sizeof(WNDCLASSEX);
    wcCal.lpfnWndProc = CalendarWndProc;
    wcCal.hInstance = hInstance;
    wcCal.lpszClassName = L"NepaliCalendarPopupClass";
    wcCal.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClassEx(&wcCal);

    // Register Custom Menu Popup Class
    WNDCLASSEX wcMenu = { 0 };
    wcMenu.cbSize = sizeof(WNDCLASSEX);
    wcMenu.lpfnWndProc = CustomMenuWndProc;
    wcMenu.hInstance = hInstance;
    wcMenu.lpszClassName = L"NepaliMenuPopupClass";
    wcMenu.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClassEx(&wcMenu);

    HWND hTaskbar = FindWindow(L"Shell_TrayWnd", NULL);
    
    // Bounds check to ensure the widget isn't lost off-screen due to old configs
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
    if (g_yPos < 0 || g_yPos >= screenHeight) {
        if (hTaskbar) {
            RECT taskbarRect;
            GetWindowRect(hTaskbar, &taskbarRect);
            g_yPos = taskbarRect.top + (taskbarRect.bottom - taskbarRect.top) / 2 - 24;
            if (g_yPos < 0 || g_yPos > screenHeight) g_yPos = screenHeight - 60;
        } else {
            g_yPos = screenHeight - 60;
        }
    }

    // DPI-scaled window size
    int winW = (int)((g_showDay ? 190 : 155) * g_dpiScale);
    int winH = (int)(48 * g_dpiScale);

    // Create main widget window
    g_hWnd = CreateWindowEx(
        WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST | WS_EX_NOACTIVATE,
        L"NepaliTaskbarWidgetClass",
        L"Nepali Date Taskbar Widget",
        WS_POPUP,
        g_xPos, g_yPos, winW, winH,
        NULL, NULL, hInstance, NULL
    );

    // Create calendar popup window
    g_hCalWnd = CreateWindowEx(
        WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
        L"NepaliCalendarPopupClass",
        L"Nepali Calendar",
        WS_POPUP,
        0, 0, (int)(420 * g_dpiScale), (int)(440 * g_dpiScale),
        NULL, NULL, hInstance, NULL
    );

    // Create custom menu popup window
    g_hMenuWnd = CreateWindowEx(
        WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
        L"NepaliMenuPopupClass",
        L"Nepali Menu",
        WS_POPUP,
        0, 0, (int)(385 * g_dpiScale), (int)(260 * g_dpiScale),
        NULL, NULL, hInstance, NULL
    );

    // ── Apply Taskbar vs Desktop mode z-order & parenting ──
    UpdateWidgetMode();

    // ── Real-time shell event hook for instant foreground / desktop changes ──
    g_hEventHook = SetWinEventHook(
        EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND,
        NULL, WinEventProc, 0, 0,
        WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS
    );

    ShowWindow(g_hWnd, SW_SHOWNOACTIVATE);
    RenderWidget(g_hWnd);

    // ── Launch background update check (non-blocking) ────────────────────
    HANDLE hThread = CreateThread(NULL, 0, CheckForUpdateThread, (LPVOID)FALSE, 0, NULL);
    if (hThread) CloseHandle(hThread);  // Fire-and-forget

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    if (g_hEventHook) {
        UnhookWinEvent(g_hEventHook);
        g_hEventHook = NULL;
    }

    if (g_hCalWnd) {
        DestroyWindow(g_hCalWnd);
        g_hCalWnd = NULL;
    }
    if (g_hMenuWnd) {
        DestroyWindow(g_hMenuWnd);
        g_hMenuWnd = NULL;
    }

    GdiplusShutdown(g_gdiplusToken);

    if (hMutex) {
        ReleaseMutex(hMutex);
        CloseHandle(hMutex);
    }
    
    return 0;
}