Program.cs

using System.Drawing.Drawing2D;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using Microsoft.Win32;

namespace CodexUsageTray;

internal static class Program
{
    [STAThread]
    static void Main()
    {
        Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
        Application.ThreadException += (_, args) => AppLog.Write("UI thread", args.Exception);
        AppDomain.CurrentDomain.UnhandledException += (_, args) =>
            AppLog.Write("AppDomain", args.ExceptionObject as Exception ?? new Exception(args.ExceptionObject?.ToString() ?? "Unknown unhandled exception"));
        TaskScheduler.UnobservedTaskException += (_, args) =>
        {
            AppLog.Write("Unobserved task", args.Exception);
            args.SetObserved();
        };

        try
        {
            ApplicationConfiguration.Initialize();
            Application.Run(new TrayContext());
        }
        catch (Exception ex)
        {
            AppLog.Write("Application startup", ex);
        }
    }
}
internal static class AppLog
{
    private static readonly object Sync = new();
    private static readonly string DirectoryPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CodexUsageTray");
    private static readonly string FilePath = Path.Combine(DirectoryPath, "crash.log");

    public static void Write(string source, Exception exception)
    {
        try
        {
            lock (Sync)
            {
                Directory.CreateDirectory(DirectoryPath);
                File.AppendAllText(FilePath, $"[{DateTimeOffset.Now:yyyy-MM-dd HH:mm:ss zzz}] {source}{Environment.NewLine}{exception}{Environment.NewLine}{Environment.NewLine}");
            }
        }
        catch
        {
            // Logging must never become a second failure path.
        }
    }
}

internal sealed record ThemePalette(string Name, Color Background, Color Panel, Color Text, Color Muted, Color Accent, Color Good, Color Warning, Color SwapBackground, Color Swap);

internal static class ThemeManager
{
    private static readonly string Path = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CodexUsageTray", "theme.txt");
    public static readonly ThemePalette Default = new("Default", Color.FromArgb(17, 21, 29), Color.FromArgb(27, 34, 46), Color.FromArgb(241, 245, 249), Color.FromArgb(174, 188, 207), Color.FromArgb(45, 155, 255), Color.FromArgb(55, 225, 95), Color.FromArgb(255, 165, 55), Color.FromArgb(55, 46, 16), Color.FromArgb(255, 210, 70));
    public static readonly IReadOnlyList<ThemePalette> Themes =
    [
        Default,
        new("AMOLED", Color.Black, Color.FromArgb(3, 8, 10), Color.White, Color.FromArgb(180, 220, 230), Color.FromArgb(0, 190, 255), Color.FromArgb(0, 255, 120), Color.FromArgb(255, 185, 0), Color.FromArgb(35, 30, 0), Color.FromArgb(255, 220, 60)),
        new("Dracula", Color.FromArgb(40, 42, 54), Color.FromArgb(68, 71, 90), Color.FromArgb(248, 248, 242), Color.FromArgb(213, 208, 230), Color.FromArgb(189, 147, 249), Color.FromArgb(80, 250, 123), Color.FromArgb(255, 121, 198), Color.FromArgb(65, 45, 85), Color.FromArgb(189, 147, 249)),
        new("Nord", Color.FromArgb(46, 52, 64), Color.FromArgb(59, 66, 82), Color.FromArgb(236, 239, 244), Color.FromArgb(216, 222, 233), Color.FromArgb(136, 192, 208), Color.FromArgb(163, 190, 140), Color.FromArgb(208, 135, 112), Color.FromArgb(65, 55, 35), Color.FromArgb(235, 203, 139)),
        new("Solarized Dark", Color.FromArgb(0, 43, 54), Color.FromArgb(7, 54, 66), Color.FromArgb(238, 232, 213), Color.FromArgb(147, 161, 161), Color.FromArgb(38, 139, 210), Color.FromArgb(133, 153, 0), Color.FromArgb(203, 75, 22), Color.FromArgb(55, 45, 20), Color.FromArgb(181, 137, 0)),
        new("Light", Color.FromArgb(248, 249, 252), Color.White, Color.FromArgb(15, 23, 42), Color.FromArgb(42, 52, 67), Color.FromArgb(0, 95, 170), Color.FromArgb(20, 145, 75), Color.FromArgb(205, 105, 10), Color.FromArgb(255, 239, 185), Color.FromArgb(155, 100, 0)),
        new("Glass", Color.FromArgb(22, 32, 48), Color.FromArgb(38, 54, 76), Color.FromArgb(235, 244, 255), Color.FromArgb(180, 202, 225), Color.FromArgb(105, 190, 255), Color.FromArgb(80, 225, 165), Color.FromArgb(255, 190, 90), Color.FromArgb(35, 50, 72), Color.FromArgb(145, 215, 255))
    ];
    public static ThemePalette Current { get; private set; } = Default;
    public static void Load()
    {
        try { var name = File.ReadAllText(Path).Trim(); Current = Themes.FirstOrDefault(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) ?? Default; } catch { Current = Default; }
        Brushes.SetTextColor(Current.Text);
    }
    public static void Set(ThemePalette theme)
    {
        Current = theme;
        Brushes.SetTextColor(theme.Text);
        Directory.CreateDirectory(System.IO.Path.GetDirectoryName(Path)!);
        File.WriteAllText(Path, theme.Name);
    }
    public static void ApplyTo(Form form)
    {
        form.BackColor = Current.Background;
        form.Opacity = Current.Name == "Glass" ? 0.97 : 1.0;
        ApplyToControl(form, Current);
        form.Invalidate(true);
    }
    private static void ApplyToControl(Control control, ThemePalette theme)
    {
        if (control is Form) control.BackColor = theme.Background;
        else if (control is GraphCanvas or AnalyticsChart or AnalyticsDashboard) control.BackColor = theme.Panel;
        else if (control is Panel panel && (panel.Dock == DockStyle.Top || panel.Dock == DockStyle.Bottom)) control.BackColor = theme.Background;
        if (control is Label label) label.ForeColor = label.Cursor == Cursors.Hand ? theme.Accent : theme.Text;
        if (control.Tag is string role)
        {
            if (role == "weekly") control.BackColor = theme.Good;
            else if (role == "session") control.BackColor = theme.Accent;
            else if (role == "track") control.BackColor = theme.Panel;
            else if (role == "muted") control.ForeColor = theme.Muted;
        }
        if (control is Button button)
        {
            button.BackColor = theme.SwapBackground; button.ForeColor = theme.Swap; button.FlatAppearance.BorderColor = theme.Accent; button.BackColor = theme.Panel; button.ForeColor = theme.Accent; button.FlatAppearance.MouseOverBackColor = theme.Background;
        }
        foreach (Control child in control.Controls) ApplyToControl(child, theme);
    }
}

internal static class Brushes
{
    public static Brush White { get; private set; } = new SolidBrush(Color.White);
    public static void SetTextColor(Color color)
    {
        White.Dispose();
        White = new SolidBrush(color);
    }
}

internal sealed class TrayContext : ApplicationContext
{
    private static readonly Version CurrentVersion = new(2, 0, 18);
    private readonly NotifyIcon tray;
    private readonly UsageClient client = new();
    private readonly ResetDataClient resetClient = new();
    private readonly string stateFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CodexUsageTray", "state.json");
    private UsageSnapshot? latest;
    private GraphForm? graph;
    private AnalyticsForm? analytics;
    private bool busy;
    private readonly System.Windows.Forms.Timer refreshTimer;
    private readonly System.Windows.Forms.Timer resetTimer;
    private readonly System.Windows.Forms.Timer updateTimer;
    private readonly UpdateChecker updateChecker = new();
    private int refreshMinutes = 1;
    private int graphDays = 7;
    private int popoutScalePercent;
    private ResetData? resetData;
    private Point? popoutAnchor;

    public TrayContext()
    {
        Directory.CreateDirectory(Path.GetDirectoryName(stateFile)!);
        graphDays = LoadGraphDays();
        popoutScalePercent = LoadPopoutScale();
        ThemeManager.Load();
        resetData = resetClient.LoadCached();
        try
        {
            if (Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run")?.GetValue("CodexUsageTray") is string) SetStartup(true);
        }
        catch (Exception ex) { AppLog.Write("Startup registration", ex); }
        tray = new NotifyIcon { Visible = true, Text = "Codex usage", Icon = MakeIcon(null) };
        tray.MouseClick += (_, e) => { if (e.Button == MouseButtons.Left) { popoutAnchor = Cursor.Position; TogglePopout(); } };
        tray.ContextMenuStrip = Menu();
        refreshTimer = new System.Windows.Forms.Timer { Interval = refreshMinutes * 60 * 1000 };
        refreshTimer.Tick += async (_, _) => await RefreshAsync();
        refreshTimer.Start();
        resetTimer = new System.Windows.Forms.Timer { Interval = 15 * 60 * 1000 };
        resetTimer.Tick += async (_, _) => await RefreshResetDataAsync();
        resetTimer.Start();
        updateTimer = new System.Windows.Forms.Timer { Interval = 24 * 60 * 60 * 1000 };
        updateTimer.Tick += async (_, _) => await CheckForUpdatesAsync(false);
        updateTimer.Start();
        _ = RefreshAsync();
        _ = RefreshResetDataAsync();
        _ = CheckForUpdatesAsync(false);
        if (Environment.GetCommandLineArgs().Contains("--show-usage"))
        {
            var openUsage = new System.Windows.Forms.Timer { Interval = 250 };
            openUsage.Tick += (_, _) => { openUsage.Stop(); openUsage.Dispose(); ShowAnalytics(); };
            openUsage.Start();
        }
    }

    private ContextMenuStrip Menu()
    {
        var m = new ContextMenuStrip();
        m.Items.Add("Open Codex limits", null, (_, _) => { popoutAnchor = Cursor.Position; ShowGraph(); });
        m.Items.Add("Open Codex usage", null, (_, _) => { popoutAnchor = Cursor.Position; ShowAnalytics(); });
        m.Items.Add("Refresh now", null, async (_, _) => await RefreshAsync());
        m.Items.Add("Check for updates", null, async (_, _) => await CheckForUpdatesAsync(true));
        m.Items.Add("GitHub repository", null, (_, _) => System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo("https://github.com/colemanuk82/CodexUsageTray") { UseShellExecute = true }));
        var refreshMenu = new ToolStripMenuItem("Refresh interval");
        foreach (var minutes in new[] { 1, 5 })
        {
            var item = new ToolStripMenuItem($"{minutes} minute{(minutes == 1 ? "" : "s")}") { Checked = refreshMinutes == minutes };
            item.Click += (_, _) => SetRefreshMinutes(minutes);
            refreshMenu.DropDownItems.Add(item);
        }
        m.Items.Add(refreshMenu);
        var durationMenu = new ToolStripMenuItem("Graph duration");
        foreach (var days in new[] { 1, 7, 30 })
        {
            var item = new ToolStripMenuItem($"{days} day{(days == 1 ? "" : "s")}") { Checked = graphDays == days };
            item.Click += (_, _) => SetGraphDays(days);
            durationMenu.DropDownItems.Add(item);
        }
        m.Items.Add(durationMenu);
        var sizeMenu = new ToolStripMenuItem("Popout size");
        foreach (var percent in Enumerable.Range(10, 11).Select(x => x * 10))
        {
            var item = new ToolStripMenuItem($"{percent}%") { Checked = popoutScalePercent == percent };
            item.Click += (_, _) => SetPopoutScale(percent);
            sizeMenu.DropDownItems.Add(item);
        }
        m.Items.Add(sizeMenu);
        var themeMenu = new ToolStripMenuItem("Theme");
        foreach (var theme in ThemeManager.Themes)
        {
            var item = new ToolStripMenuItem(theme.Name) { Checked = ThemeManager.Current.Name == theme.Name };
            item.Click += (_, _) => SetTheme(theme);
            themeMenu.DropDownItems.Add(item);
        }
        m.Items.Add(themeMenu);
        var startup = new ToolStripMenuItem("Start with Windows") { Checked = StartupEnabled, CheckOnClick = true };
        startup.CheckedChanged += (_, _) => { SetStartup(startup.Checked); };
        m.Items.Add(startup);
        m.Items.Add(new ToolStripSeparator());
        m.Items.Add("Exit", null, (_, _) => ExitThread());
        return m;
    }

    private async Task RefreshAsync()
    {
        if (busy) return;
        busy = true;
        try
        {
            latest = await client.GetAsync();
            if (latest != null) SaveSnapshot(latest);
            UpdateIcon();
            tray.Text = latest == null ? "Codex usage unavailable" : $"5-hour: {latest.SessionRemaining:0}% remaining\nWeekly: {latest.WeeklyRemaining:0}% remaining";
        }
        catch (Exception ex) { tray.Text = "Codex usage unavailable"; System.Diagnostics.Debug.WriteLine(ex); }
        finally { busy = false; }
    }
    private async Task RefreshResetDataAsync()
    {
        try { if (resetData != null && DateTimeOffset.UtcNow - resetData.FetchedAt < TimeSpan.FromMinutes(15)) { UpdateIcon(); if (graph != null && !graph.IsDisposed) graph.SetResetData(resetData); return; } resetData = await resetClient.GetAsync(); UpdateIcon(); if (graph != null && !graph.IsDisposed) graph.SetResetData(resetData); }
        catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex); }
    }
    private void SetRefreshMinutes(int minutes) { refreshMinutes = minutes; refreshTimer.Interval = minutes * 60 * 1000; graph?.SetOptions(refreshMinutes, graphDays); analytics?.SetRefreshMinutes(refreshMinutes); }
    private void SetGraphDays(int days) { graphDays = days; try { SaveGraphDays(); } catch (Exception ex) { AppLog.Write("Save graph settings", ex); } graph?.SetOptions(refreshMinutes, graphDays); analytics?.SetGraphDays(graphDays); }
    private void SetPopoutScale(int percent)
    {
        popoutScalePercent = Math.Clamp(percent, 100, 200);
        try { SavePopoutScale(); } catch (Exception ex) { AppLog.Write("Save popout size", ex); }
        graph?.SetPopoutScale(popoutScalePercent, popoutAnchor ?? Cursor.Position);
        analytics?.SetPopoutScale(popoutScalePercent, popoutAnchor ?? Cursor.Position);
        tray.ContextMenuStrip = Menu();
    }
    private void SetTheme(ThemePalette theme)
    {
        try
        {
            ThemeManager.Set(theme);
            UpdateIcon();
            if (graph != null && !graph.IsDisposed) ThemeManager.ApplyTo(graph);
            if (analytics != null && !analytics.IsDisposed) ThemeManager.ApplyTo(analytics);
            tray.ContextMenuStrip = Menu();
        }
        catch (Exception ex) { AppLog.Write("Theme change", ex); }
    }
    private async Task CheckForUpdatesAsync(bool notifyWhenCurrent)
    {
        try
        {
            var update = await updateChecker.GetLatestAsync();
            if (update == null) { if (notifyWhenCurrent) ShowUpdateNotice("Update check unavailable", "GitHub could not be reached right now."); return; }
            if (update.Version > CurrentVersion) ShowUpdateNotice("Codex Usage Tray update available", $"Version {update.Version} is available on GitHub.");
            else if (notifyWhenCurrent) ShowUpdateNotice("Codex Usage Tray is up to date", $"You are running version {CurrentVersion}.");
        }
        catch (Exception ex) { if (notifyWhenCurrent) ShowUpdateNotice("Update check unavailable", "GitHub could not be reached right now."); System.Diagnostics.Debug.WriteLine(ex); }
    }
    private void ShowUpdateNotice(string title, string message)
    {
        tray.BalloonTipTitle = title;
        tray.BalloonTipText = message;
        tray.ShowBalloonTip(7000);
    }

    private void UpdateIcon() { var old = tray.Icon; tray.Icon = MakeIcon(latest); old?.Dispose(); }

    private void ShowGraph()
    {
        popoutAnchor ??= Cursor.Position;
        if (analytics != null && !analytics.IsDisposed) analytics.Close();
        if (latest == null) { _ = RefreshAsync(); return; }
        if (graph != null && !graph.IsDisposed)
        {
            if (graph.WindowState == FormWindowState.Minimized) graph.WindowState = FormWindowState.Normal;
            graph.UpdateData(latest, ReadSnapshots()); graph.SetOptions(refreshMinutes, graphDays); graph.SetResetData(resetData); ThemeManager.ApplyTo(graph); graph.PlaceAboveTray(popoutAnchor!.Value); graph.BringToFront(); graph.Activate(); return;
        }
        graph = new GraphForm(latest, ReadSnapshots(), refreshMinutes, graphDays, SetRefreshMinutes, SetGraphDays, resetData, ShowAnalytics);
        graph.SetPopoutScale(popoutScalePercent, popoutAnchor!.Value);
        ThemeManager.ApplyTo(graph);
        graph.FormClosed += (_, _) => graph = null;
        graph.Show(); graph.PlaceAboveTray(popoutAnchor!.Value); graph.Activate();
    }
    private void TogglePopout()
    {
        if (graph != null && !graph.IsDisposed) { graph.Close(); return; }
        if (analytics != null && !analytics.IsDisposed) { analytics.Close(); return; }
        ShowGraph();
    }
    private void ShowAnalytics()
    {
        popoutAnchor ??= Cursor.Position;
        if (graph != null && !graph.IsDisposed) graph.Close();
        if (analytics != null && !analytics.IsDisposed) { if (analytics.WindowState == FormWindowState.Minimized) analytics.WindowState = FormWindowState.Normal; analytics.PlaceAboveTray(popoutAnchor!.Value); analytics.BringToFront(); analytics.Activate(); return; }
        analytics = new AnalyticsForm(ShowGraph, refreshMinutes, SetRefreshMinutes); analytics.SetGraphState(graphDays, SetGraphDays); analytics.SetPopoutScale(popoutScalePercent, popoutAnchor!.Value); ThemeManager.ApplyTo(analytics); analytics.FormClosed += (_, _) => analytics = null; analytics.Show(); analytics.PlaceAboveTray(popoutAnchor!.Value); analytics.Activate();
    }

    private static string StartupPath => Environment.ProcessPath ?? Application.ExecutablePath;
    private bool StartupEnabled
    {
        get
        {
            var value = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run")?.GetValue("CodexUsageTray") as string;
            return value?.Trim().Trim('"').Equals(StartupPath, StringComparison.OrdinalIgnoreCase) == true;
        }
    }
    private void SetStartup(bool enabled)
    {
        using var key = Registry.CurrentUser.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
        if (enabled) key.SetValue("CodexUsageTray", $"\"{StartupPath}\"");
        else key.DeleteValue("CodexUsageTray", false);
    }
    private void SaveSnapshot(UsageSnapshot s)
    {
        var all = ReadSnapshots(); all.Add(s); all = all.Where(x => x.At >= DateTimeOffset.UtcNow.AddDays(-31)).ToList();
        File.WriteAllText(stateFile, JsonSerializer.Serialize(new State { History = all, GraphDays = graphDays, PopoutScalePercent = popoutScalePercent }));
    }
    private int LoadGraphDays() { try { return Math.Clamp(JsonSerializer.Deserialize<State>(File.ReadAllText(stateFile))?.GraphDays ?? 7, 1, 30); } catch { return 7; } }
    private void SaveGraphDays() { File.WriteAllText(stateFile, JsonSerializer.Serialize(new State { History = ReadSnapshots(), GraphDays = graphDays, PopoutScalePercent = popoutScalePercent })); }
    private int LoadPopoutScale() { try { return Math.Clamp(JsonSerializer.Deserialize<State>(File.ReadAllText(stateFile))?.PopoutScalePercent ?? 100, 100, 200); } catch { return 100; } }
    private void SavePopoutScale() { File.WriteAllText(stateFile, JsonSerializer.Serialize(new State { History = ReadSnapshots(), GraphDays = graphDays, PopoutScalePercent = popoutScalePercent })); }
    private List<UsageSnapshot> ReadSnapshots()
    {
        try { return JsonSerializer.Deserialize<State>(File.ReadAllText(stateFile))?.History ?? []; } catch { return []; }
    }
    protected override void ExitThreadCore() { refreshTimer.Dispose(); resetTimer.Dispose(); updateTimer.Dispose(); tray.Visible = false; tray.Dispose(); base.ExitThreadCore(); }

    private Icon MakeIcon(UsageSnapshot? s)
    {
        using var b = new Bitmap(32, 32); using var g = Graphics.FromImage(b);
        g.SmoothingMode = SmoothingMode.AntiAlias; g.Clear(Color.Transparent);
        var alert = resetData?.ChancePercent > 70; var weeklyColor = alert ? Color.FromArgb(235, 65, 70) : Color.FromArgb(55, 225, 95); var sessionColor = alert ? Color.FromArgb(235, 65, 70) : Color.FromArgb(45, 155, 255); DrawBar(g, 3, 5, s?.WeeklyRemaining, weeklyColor); DrawBar(g, 3, 20, s?.SessionRemaining, sessionColor);
        return Icon.FromHandle(b.GetHicon());
    }
    private static void DrawBar(Graphics g, int x, int y, double? remaining, Color color)
    {
        using var bg = new SolidBrush(Color.FromArgb(Math.Max(18, color.R / 4), Math.Max(18, color.G / 4), Math.Max(18, color.B / 4))); g.FillRoundedRectangle(bg, x, y, 26, 7, 3);
        if (remaining.HasValue) { using var br = new SolidBrush(color); g.FillRoundedRectangle(br, x, y, Math.Max(2, 26 * (float)remaining.Value / 100), 7, 3); }
        using var outline = new Pen(color); g.DrawRoundedRectangle(outline, x, y, 26, 7, 3);
    }
    private static Color ColorFor(double? remaining) => !remaining.HasValue ? Color.Gray : remaining < 20 ? Color.IndianRed : remaining < 50 ? Color.DarkOrange : Color.MediumSeaGreen;
}

internal sealed class UsageClient
{
    private static readonly HttpClient http = new() { Timeout = TimeSpan.FromSeconds(15) };
    public async Task<UsageSnapshot?> GetAsync()
    {
        var authPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".codex", "auth.json");
        if (!File.Exists(authPath)) return null;
        using var doc = JsonDocument.Parse(await File.ReadAllTextAsync(authPath)); var root = doc.RootElement;
        var token = root.GetProperty("tokens").GetProperty("access_token").GetString();
        if (string.IsNullOrWhiteSpace(token)) return null;
        using var req = new HttpRequestMessage(HttpMethod.Get, "https://chatgpt.com/backend-api/wham/usage"); req.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
        if (root.GetProperty("tokens").TryGetProperty("account_id", out var account)) req.Headers.TryAddWithoutValidation("ChatGPT-Account-ID", account.GetString());
        using var res = await http.SendAsync(req); res.EnsureSuccessStatusCode(); using var data = JsonDocument.Parse(await res.Content.ReadAsStringAsync());
        var r = data.RootElement; var primary = Find(r, "primary_window", "primary"); var secondary = Find(r, "secondary_window", "secondary");
        return new UsageSnapshot(DateTimeOffset.UtcNow, 100 - Used(primary), 100 - Used(secondary), ResetAt(primary), ResetAt(secondary));
    }
    private static JsonElement Find(JsonElement r, params string[] names)
    {
        foreach (var n in names) if (r.TryGetProperty(n, out var e)) return e;
        if (r.TryGetProperty("rate_limit", out var rl)) foreach (var n in names) if (rl.TryGetProperty(n, out var e)) return e;
        return default;
    }
    private static double Used(JsonElement e)
    {
        if (e.ValueKind != JsonValueKind.Object) return 0;
        foreach (var n in new[] { "used_percent", "usedPercentage", "percent_used" }) if (e.TryGetProperty(n, out var p) && p.TryGetDouble(out var v)) return Math.Clamp(v, 0, 100);
        if (e.TryGetProperty("remaining", out var rem) && e.TryGetProperty("limit", out var lim) && lim.GetDouble() > 0) return 100 - rem.GetDouble() / lim.GetDouble() * 100;
        return 0;
    }
    private static DateTimeOffset? ResetAt(JsonElement e)
    {
        if (e.ValueKind != JsonValueKind.Object) return null;
        foreach (var name in new[] { "reset_at", "resetAt", "resets_at" })
        {
            if (!e.TryGetProperty(name, out var value)) continue;
            if (value.ValueKind == JsonValueKind.Number && value.TryGetInt64(out var unixSeconds)) return DateTimeOffset.FromUnixTimeSeconds(unixSeconds);
            if (value.ValueKind == JsonValueKind.String && DateTimeOffset.TryParse(value.GetString(), out var parsed)) return parsed;
        }
        return null;
    }
}

internal sealed record UpdateInfo(Version Version, string Url);
internal sealed class UpdateChecker
{
    private static readonly HttpClient http = new() { Timeout = TimeSpan.FromSeconds(15) };
    public async Task<UpdateInfo?> GetLatestAsync()
    {
        using var request = new HttpRequestMessage(HttpMethod.Get, "https://api.github.com/repos/colemanuk82/CodexUsageTray/releases/latest");
        request.Headers.UserAgent.ParseAdd("CodexUsageTray-update-check");
        using var response = await http.SendAsync(request);
        if (!response.IsSuccessStatusCode) return await GetLatestFromReleasePageAsync();
        using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
        var root = document.RootElement;
        var tag = root.TryGetProperty("tag_name", out var tagValue) ? tagValue.GetString() : null;
        var url = root.TryGetProperty("html_url", out var urlValue) ? urlValue.GetString() : null;
        if (string.IsNullOrWhiteSpace(tag) || !Version.TryParse(tag.TrimStart('v', 'V'), out var version)) return null;
        return new UpdateInfo(version, url ?? "https://github.com/colemanuk82/CodexUsageTray/releases");
    }
    private static async Task<UpdateInfo?> GetLatestFromReleasePageAsync()
    {
        using var request = new HttpRequestMessage(HttpMethod.Get, "https://github.com/colemanuk82/CodexUsageTray/releases/latest");
        request.Headers.UserAgent.ParseAdd("CodexUsageTray-update-check");
        using var response = await http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
        if (!response.IsSuccessStatusCode) return null;
        var finalUrl = response.RequestMessage?.RequestUri?.ToString();
        const string marker = "/releases/tag/";
        var markerIndex = finalUrl?.IndexOf(marker, StringComparison.OrdinalIgnoreCase) ?? -1;
        if (markerIndex < 0) return null;
        var tag = finalUrl![(markerIndex + marker.Length)..].Trim('/');
        return Version.TryParse(tag.TrimStart('v', 'V'), out var version) ? new UpdateInfo(version, finalUrl!) : null;
    }
}

internal record UsageSnapshot(DateTimeOffset At, double SessionRemaining, double WeeklyRemaining, DateTimeOffset? SessionResetAt = null, DateTimeOffset? WeeklyResetAt = null);
internal sealed class State { public bool Bars { get; set; } public int GraphDays { get; set; } = 7; public int PopoutScalePercent { get; set; } = 100; public List<UsageSnapshot> History { get; set; } = []; }

internal sealed class CodexUsageRecord
{
    public string SourceFile { get; set; } = ""; public string SessionId { get; set; } = ""; public string Project { get; set; } = "Unknown project"; public string Model { get; set; } = "Codex"; public DateTimeOffset At { get; set; } public long InputTokens { get; set; } public long CachedInputTokens { get; set; } public long OutputTokens { get; set; } public long ReasoningTokens { get; set; } public long TotalTokens => InputTokens + OutputTokens + ReasoningTokens;
}
internal sealed class AnalyticsCache { public int Version { get; set; } = 3; public Dictionary<string, long> Files { get; set; } = []; public List<CodexUsageRecord> Records { get; set; } = []; }
internal sealed class CodexAnalyticsStore
{
    private readonly string sessionsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".codex", "sessions"); private readonly string cachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CodexUsageTray", "analytics-cache.json");
    public List<CodexUsageRecord> Load()
    {
        var cache = ReadCache();
        if (!Directory.Exists(sessionsPath)) return cache.Records;

        List<string> files;
        try { files = Directory.EnumerateFiles(sessionsPath, "*.jsonl", SearchOption.AllDirectories).ToList(); }
        catch (Exception ex) { AppLog.Write("Enumerate Codex sessions", ex); return cache.Records; }

        var active = files.ToHashSet(StringComparer.OrdinalIgnoreCase);
        cache.Records.RemoveAll(x => !active.Contains(x.SourceFile));
        foreach (var file in files)
        {
            try
            {
                var stamp = File.GetLastWriteTimeUtc(file).Ticks;
                if (cache.Files.TryGetValue(file, out var old) && old == stamp) continue;
                cache.Records.RemoveAll(x => string.Equals(x.SourceFile, file, StringComparison.OrdinalIgnoreCase));
                cache.Records.AddRange(ParseFile(file));
                cache.Files[file] = stamp;
            }
            catch (IOException) { }
            catch (UnauthorizedAccessException) { }
            catch (Exception ex) { AppLog.Write("Read Codex session", ex); }
        }

        try
        {
            Directory.CreateDirectory(Path.GetDirectoryName(cachePath)!);
            File.WriteAllText(cachePath, JsonSerializer.Serialize(cache));
        }
        catch (Exception ex) { AppLog.Write("Write analytics cache", ex); }
        return cache.Records;
    }
    private AnalyticsCache ReadCache() { try { var cache = JsonSerializer.Deserialize<AnalyticsCache>(File.ReadAllText(cachePath)) ?? new AnalyticsCache(); return cache.Version == 3 ? cache : new AnalyticsCache(); } catch { return new AnalyticsCache(); } }
    private static List<CodexUsageRecord> ParseFile(string file)
    {
        var records = new List<CodexUsageRecord>(); var sessionId = Path.GetFileNameWithoutExtension(file); var project = "Unknown project"; var model = "Codex (unknown)";
        foreach (var line in ReadSharedLines(file)) { try { using var doc = JsonDocument.Parse(line); var root = doc.RootElement; if (!root.TryGetProperty("payload", out var payload)) continue; if (payload.TryGetProperty("session_id", out var sid)) sessionId = sid.GetString() ?? sessionId; if (payload.TryGetProperty("cwd", out var cwd)) project = cwd.GetString() ?? project; if (payload.TryGetProperty("model", out var modelValue) && !string.IsNullOrWhiteSpace(modelValue.GetString())) model = modelValue.GetString()!; if (payload.TryGetProperty("thread_settings", out var settings) && settings.TryGetProperty("model", out var settingsModel) && !string.IsNullOrWhiteSpace(settingsModel.GetString())) model = settingsModel.GetString()!; if (!payload.TryGetProperty("type", out var type) || type.GetString() != "token_count" || !payload.TryGetProperty("info", out var info) || !info.TryGetProperty("last_token_usage", out var usage)) continue; long Number(string name) => usage.TryGetProperty(name, out var value) && value.TryGetInt64(out var number) ? number : 0; var at = root.TryGetProperty("timestamp", out var timestamp) && DateTimeOffset.TryParse(timestamp.GetString(), out var parsed) ? parsed : File.GetLastWriteTimeUtc(file); records.Add(new CodexUsageRecord { SourceFile = file, SessionId = sessionId, Project = project, Model = model, At = at, InputTokens = Number("input_tokens"), CachedInputTokens = Number("cached_input_tokens"), OutputTokens = Number("output_tokens"), ReasoningTokens = Number("reasoning_output_tokens") }); } catch (JsonException) { } }
        return records;
    }
    private static IEnumerable<string> ReadSharedLines(string file) { using var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); using var reader = new StreamReader(stream); while (reader.ReadLine() is { } line) yield return line; }
}
internal sealed class AnalyticsChart : Panel
{
    public List<CodexUsageRecord> Records { get; set; } = []; public int Days { get; set; } = 30; public DateTime StartDate { get; set; } = DateTime.Today.AddDays(-29);
    public AnalyticsChart() { BackColor = Color.FromArgb(24, 25, 29); DoubleBuffered = true; }
    protected override void OnPaint(PaintEventArgs e)
    { base.OnPaint(e); e.Graphics.Clear(BackColor); var left = 90; var top = 76; var right = Math.Max(left + 100, Width - 38); var bottom = Math.Max(top + 100, Height - 62); var start = StartDate.Date; var daily = Enumerable.Range(0, Days).Select(i => Records.Where(x => x.At.ToLocalTime().Date == start.AddDays(i)).Sum(x => x.TotalTokens)).ToList(); var max = Math.Max(1, daily.Max()); using var grid = new Pen(Color.FromArgb(50, 55, 62)); using var text = new SolidBrush(Color.FromArgb(180, 190, 205)); using var font = new Font("Segoe UI", 18, FontStyle.Regular, GraphicsUnit.Pixel); for (var i = 0; i <= 4; i++) { var y = top + i * (bottom - top) / 4; e.Graphics.DrawLine(grid, left, y, right, y); e.Graphics.DrawString($"{max * (4 - i) / 4 / 1000000d:0.#}M", font, text, 22, y - 10); } using var barBrush = new SolidBrush(ThemeManager.Current.Good); var slot = (right - left) / (float)Math.Max(1, Days); for (var i = 0; i < daily.Count; i++) { var h = (float)(daily[i] / max * (bottom - top)); e.Graphics.FillRectangle(barBrush, left + i * slot + 2, bottom - h, Math.Max(3, slot - 5), h); } using var heading = new Font("Segoe UI", 32, FontStyle.Bold, GraphicsUnit.Pixel); e.Graphics.DrawString("Daily Codex usage", heading, Brushes.White, 34, 22); e.Graphics.DrawString(start.ToString("dd MMM"), font, text, left, bottom + 14); var endLabel = (start.AddDays(Days - 1)).ToString("dd MMM"); var endSize = e.Graphics.MeasureString(endLabel, font); e.Graphics.DrawString(endLabel, font, text, right - endSize.Width, bottom + 14); }
}
internal sealed class ModelRate { public decimal Input { get; set; } public decimal Cached { get; set; } public decimal Output { get; set; } }
internal sealed class ModelRateCache { public int SchemaVersion { get; set; } public DateTimeOffset FetchedAt { get; set; } public Dictionary<string, ModelRate> Rates { get; set; } = []; }
internal static class ModelCostEstimator
{
    private static readonly HttpClient http = new() { Timeout = TimeSpan.FromSeconds(15) };
    private static Dictionary<string, ModelRate> rates = Defaults();
    private static string CachePath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CodexUsageTray", "model-rates.json");
    private static Dictionary<string, ModelRate> Defaults() => new(StringComparer.OrdinalIgnoreCase) { ["gpt-6-astra"] = new() { Input = 10m, Cached = 1m, Output = 50m }, ["gpt-5.6-luna"] = new() { Input = .20m, Cached = .02m, Output = 1.20m }, ["gpt-5.6-terra"] = new() { Input = 2m, Cached = .20m, Output = 12m }, ["gpt-5.6-sol"] = new() { Input = 4m, Cached = .40m, Output = 20m }, ["gpt-5.6"] = new() { Input = 4m, Cached = .40m, Output = 20m }, ["codex-auto-review"] = new() { Input = .20m, Cached = .02m, Output = 1.20m } };
    public static async Task SyncAsync(IEnumerable<string> models)
    {
        try
        {
            ModelRateCache cache; try { cache = JsonSerializer.Deserialize<ModelRateCache>(File.ReadAllText(CachePath)) ?? new(); } catch { cache = new(); }
            rates = Defaults(); foreach (var entry in cache.Rates ?? []) rates[entry.Key] = entry.Value;
            var requested = models.Select(NormalizeModel).Where(IsFetchableModel).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
            if (requested.Count == 0) return;
            var cacheIsFresh = cache.SchemaVersion >= 2 && DateTimeOffset.UtcNow - cache.FetchedAt < TimeSpan.FromHours(24);
            var toFetch = cacheIsFresh ? requested.Where(x => !(cache.Rates?.ContainsKey(x) ?? false)).ToList() : requested;
            if (toFetch.Count == 0) return;
            var fetchedAny = false;
            foreach (var model in toFetch)
            {
                var rate = await FetchRateAsync(model);
                if (rate == null) continue;
                rates[model] = rate;
                fetchedAny = true;
            }
            if (fetchedAny)
            {
                Directory.CreateDirectory(Path.GetDirectoryName(CachePath)!);
                File.WriteAllText(CachePath, JsonSerializer.Serialize(new ModelRateCache { SchemaVersion = 2, FetchedAt = DateTimeOffset.UtcNow, Rates = rates }));
            }
        }
        catch { }
    }
    private static async Task<ModelRate?> FetchRateAsync(string model)
    {
        foreach (var candidate in ModelPageCandidates(model))
        {
            try
            {
                using var response = await http.GetAsync($"https://developers.openai.com/api/docs/models/{Uri.EscapeDataString(candidate)}");
                if (!response.IsSuccessStatusCode) continue;
                var html = await response.Content.ReadAsStringAsync();
                var match = Regex.Match(html, @"<div[^>]*>\s*Input\s*</div>\s*<div[^>]*>\s*\$(?<input>[\d.]+)\s*</div>.*?<div[^>]*>\s*Cached input\s*</div>\s*<div[^>]*>\s*\$(?<cached>[\d.]+)\s*</div>.*?<div[^>]*>\s*Output\s*</div>\s*<div[^>]*>\s*\$(?<output>[\d.]+)\s*</div>", RegexOptions.Singleline | RegexOptions.IgnoreCase);
                if (!match.Success) continue;
                var culture = System.Globalization.CultureInfo.InvariantCulture;
                if (decimal.TryParse(match.Groups["input"].Value, System.Globalization.NumberStyles.Number, culture, out var input) && decimal.TryParse(match.Groups["cached"].Value, System.Globalization.NumberStyles.Number, culture, out var cached) && decimal.TryParse(match.Groups["output"].Value, System.Globalization.NumberStyles.Number, culture, out var output)) return new ModelRate { Input = input, Cached = cached, Output = output };
            }
            catch { }
        }
        return null;
    }
    private static IEnumerable<string> ModelPageCandidates(string model)
    {
        yield return model;
        var withoutSnapshot = Regex.Replace(model, @"-\d{4}(?:-\d{2}){0,2}$", "", RegexOptions.IgnoreCase);
        if (!withoutSnapshot.Equals(model, StringComparison.OrdinalIgnoreCase)) yield return withoutSnapshot;
        if (model.EndsWith("-latest", StringComparison.OrdinalIgnoreCase)) yield return model[..^7];
    }
    private static string NormalizeModel(string model) => model.Equals("codex-auto-review", StringComparison.OrdinalIgnoreCase) ? "gpt-5.6-luna" : model.Trim();
    private static bool IsFetchableModel(string model) => model.Length > 0 && !model.Equals("Codex (unknown)", StringComparison.OrdinalIgnoreCase) && !model.Any(char.IsWhiteSpace);
    public static ModelRate? Rates(string model) => rates.TryGetValue(model, out var rate) ? rate : rates.TryGetValue(NormalizeModel(model), out rate) ? rate : null;
    public static decimal Estimate(IEnumerable<CodexUsageRecord> records) { var list = records.ToList(); if (list.Count == 0 || Rates(list[0].Model) is not { } rate) return 0; var input = Math.Max(0, list.Sum(x => x.InputTokens) - list.Sum(x => x.CachedInputTokens)); var cached = list.Sum(x => x.CachedInputTokens); var output = list.Sum(x => x.OutputTokens) + list.Sum(x => x.ReasoningTokens); return input / 1_000_000m * rate.Input + cached / 1_000_000m * rate.Cached + output / 1_000_000m * rate.Output; }
    public static string DisplayModel(string model) => model.Equals("codex-auto-review", StringComparison.OrdinalIgnoreCase) ? "gpt-5.6-luna" : model;
    public static Color ColorFor(string model) => model.ToLowerInvariant() switch { "gpt-6-astra" => Color.FromArgb(240, 100, 145), "gpt-5.6-luna" => Color.FromArgb(45, 155, 255), "gpt-5.6-terra" => Color.FromArgb(255, 165, 55), "gpt-5.6-sol" or "gpt-5.6" => Color.FromArgb(180, 95, 255), "codex-auto-review" => Color.FromArgb(45, 225, 185), _ => Color.FromArgb(120, 135, 150) };
}
internal sealed class AnalyticsBreakdownPanel : Panel
{
    public List<CodexUsageRecord> Records { get; set; } = [];
    public AnalyticsBreakdownPanel() { BackColor = Color.FromArgb(18, 20, 24); DoubleBuffered = true; }
    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e); e.Graphics.Clear(BackColor); var groups = Records.GroupBy(x => x.Model).OrderByDescending(g => g.Sum(x => x.TotalTokens)).ToList(); var pad = 34; var gap = 22; var cardTop = 66; var cardHeight = Math.Max(190, Height - cardTop - 28); var cardWidth = Math.Max(320, (Width - pad * 2 - gap) / 2); var left = new Rectangle(pad, cardTop, cardWidth, cardHeight); var right = new Rectangle(left.Right + gap, cardTop, cardWidth, cardHeight);
        using var title = new Font("Segoe UI", 34, FontStyle.Bold, GraphicsUnit.Pixel); using var heading = new Font("Segoe UI", 26, FontStyle.Bold, GraphicsUnit.Pixel); using var text = new Font("Segoe UI", 21, FontStyle.Regular, GraphicsUnit.Pixel); using var muted = new SolidBrush(Color.LightSteelBlue); using var line = new Pen(Color.FromArgb(52, 58, 68)); using var card = new SolidBrush(Color.FromArgb(24, 27, 33)); using var track = new SolidBrush(Color.FromArgb(46, 55, 65));
        e.Graphics.DrawString("Model usage & predicted API cost", title, Brushes.White, pad, 14); e.Graphics.DrawString("Estimate only — calculated from local token records using standard API rates.", text, muted, pad, 45); e.Graphics.FillRectangle(card, left); e.Graphics.FillRectangle(card, right); e.Graphics.DrawRectangle(line, left); e.Graphics.DrawRectangle(line, right);
        e.Graphics.DrawString("Model usage", heading, Brushes.White, left.X + 22, left.Y + 18); var total = Math.Max(1, groups.Sum(g => g.Sum(x => x.TotalTokens))); var x = left.X + 22; var barY = left.Y + 64; var barWidth = left.Width - 44; e.Graphics.FillRectangle(track, x, barY, barWidth, 22); foreach (var group in groups) { var width = (int)(barWidth * group.Sum(r => r.TotalTokens) / (double)total); using var brush = new SolidBrush(ModelCostEstimator.ColorFor(group.Key)); e.Graphics.FillRectangle(brush, x, barY, Math.Max(1, width), 22); x += width; } var y = barY + 46; foreach (var group in groups.Take(4)) { var tokens = group.Sum(r => r.TotalTokens); using var dot = new SolidBrush(ModelCostEstimator.ColorFor(group.Key)); e.Graphics.FillEllipse(dot, left.X + 24, y + 4, 14, 14); e.Graphics.DrawString(group.Key, text, Brushes.White, left.X + 48, y); e.Graphics.DrawString($"{tokens:N0} tokens  ·  {tokens * 100d / total:0.0}%", text, muted, left.X + 48, y + 25); y += 64; }
        e.Graphics.DrawString("Predicted API cost", heading, Brushes.White, right.X + 22, right.Y + 18); y = right.Y + 64; var estimate = 0m; foreach (var group in groups.Take(4)) { var cost = ModelCostEstimator.Estimate(group); estimate += cost; using var dot = new SolidBrush(ModelCostEstimator.ColorFor(group.Key)); e.Graphics.FillEllipse(dot, right.X + 24, y + 5, 14, 14); e.Graphics.DrawString(group.Key, text, Brushes.White, right.X + 48, y); e.Graphics.DrawString(cost == 0 ? "Rate unavailable" : $"≈ ${cost:N2}", text, muted, right.X + 48, y + 25); y += 64; } e.Graphics.DrawLine(line, right.X + 22, Math.Min(right.Bottom - 54, y + 4), right.Right - 22, Math.Min(right.Bottom - 54, y + 4)); e.Graphics.DrawString("Estimated total", heading, Brushes.White, right.X + 22, Math.Min(right.Bottom - 42, y + 16)); e.Graphics.DrawString($"≈ ${estimate:N2}", heading, Brushes.White, right.Right - 150, Math.Min(right.Bottom - 42, y + 16));
    }
}
internal sealed class AnalyticsForm : Form
{
    private Action<int>? graphChanged;
    private readonly CodexAnalyticsStore store = new(); private readonly AnalyticsDashboard dashboard = new(); private readonly System.Windows.Forms.Timer refreshTimer = new() { Interval = 60_000 }; private readonly Action<int> refreshChanged; private List<CodexUsageRecord> all = []; private bool refreshing; private int graphDays = 30; private int refreshMinutes = 1; private float popoutScale = 1;
    public AnalyticsForm(Action showLimits, int refreshMinutes, Action<int> refreshChanged)
    {
        this.refreshMinutes = refreshMinutes; this.refreshChanged = refreshChanged; refreshTimer.Interval = refreshMinutes * 60_000; Text = "Codex usage"; ClientSize = new Size(600, AnalyticsDashboard.LogicalHeight); MinimumSize = Size.Empty; StartPosition = FormStartPosition.Manual; FormBorderStyle = FormBorderStyle.None; AutoScaleMode = AutoScaleMode.None; KeyPreview = true; BackColor = Color.Black; KeyDown += (_, e) => { if (e.KeyCode == Keys.Escape) Close(); }; dashboard.Dock = DockStyle.Fill; dashboard.GraphRangeClicked += () => { graphDays = graphDays == 1 ? 7 : graphDays == 7 ? 30 : 1; Render(); }; dashboard.RefreshClicked += () => refreshChanged(refreshMinutes == 1 ? 5 : 1); dashboard.LimitsClicked += () => { Close(); showLimits(); }; Controls.Add(dashboard); refreshTimer.Tick += async (_, _) => await RefreshAsync(); Load += async (_, _) => { await RefreshAsync(); refreshTimer.Start(); }; FormClosed += (_, _) => refreshTimer.Dispose();
    }
    public void SetRefreshMinutes(int minutes) { refreshMinutes = minutes; refreshTimer.Interval = minutes * 60_000; dashboard.RefreshMinutes = minutes; dashboard.UpdateLayout(); }
    public void SetGraphState(int days, Action<int> changed) { graphDays = days; graphChanged = changed; dashboard.GraphRangeClicked += () => graphChanged?.Invoke(graphDays); Render(); }
    public void SetGraphDays(int days) { graphDays = days; Render(); }
    public void SetPopoutScale(int percent, Point anchor)
    {
        var scale = Math.Clamp(percent, 100, 200) / 100f;
        var ratio = scale / popoutScale;
        if (Math.Abs(ratio - 1) > 0.001f)
        {
            Scale(new SizeF(ratio, ratio));
            popoutScale = scale;
            dashboard.SetDisplayScale(scale);
            dashboard.UpdateLayout();
        }
        else dashboard.SetDisplayScale(scale);
        PlaceAboveTray(anchor);
    }
    protected override CreateParams CreateParams { get { var parameters = base.CreateParams; parameters.ExStyle |= 0x80; return parameters; } }
    protected override void OnLoad(EventArgs e)
    {
        ShowInTaskbar = false;
        base.OnLoad(e);
        UiIcons.ApplyRoundedCorners(this);
    }
    protected override void OnResize(EventArgs e) { base.OnResize(e); UiIcons.ApplyRoundedCorners(this); }
    protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); UiIcons.DrawWindowBorder(e.Graphics, ClientRectangle, ThemeManager.Current.Accent); }
    protected override void SetVisibleCore(bool value)
    {
        ShowInTaskbar = false;
        base.SetVisibleCore(value);
    }
    private async Task RefreshAsync()
    {
        if (refreshing) return;
        try
        {
            refreshing = true;
            all = store.Load();
            await ModelCostEstimator.SyncAsync(all.Select(x => x.Model));
            ResizeForModels();
            Render();
        }
        catch (Exception ex) { AppLog.Write("Analytics refresh", ex); }
        finally { refreshing = false; }
    }
    private void ResizeForModels() { dashboard.UpdateLayout(); }
    private (DateTime Start, int Days) PeriodWindow() => (DateTime.Today.AddDays(-graphDays + 1), graphDays);
    private void Render() { var window = PeriodWindow(); dashboard.Records = all.Where(x => x.At.ToLocalTime().Date >= window.Start && x.At.ToLocalTime().Date < window.Start.AddDays(window.Days)).ToList(); dashboard.Days = window.Days; dashboard.RefreshMinutes = refreshMinutes; dashboard.StartDate = window.Start; dashboard.UpdateLayout(); }
    public void PlaceAboveTray(Point anchor) => UiIcons.PlaceAboveTray(this, anchor);
}

internal sealed class ResetData
{
    public int ChancePercent { get; set; }
    public int Chance24HourPercent { get; set; } = -1;
    public int ApiChancePercent { get; set; }
    public DateTimeOffset FetchedAt { get; set; }
    public DateTimeOffset ForecastValidUntil { get; set; }
    public string ForecastSource { get; set; } = "Reset Beacon";
    public string ForecastState { get; set; } = "unavailable";
    public List<ResetEvent> Events { get; set; } = [];
}
internal sealed class ResetEvent { [JsonPropertyName("reset_type")] public string ResetType { get; set; } = "regular"; [JsonPropertyName("announced_at")] public DateTimeOffset AnnouncedAt { get; set; } }
internal sealed class ResetDataClient
{
    private static readonly HttpClient http = new() { Timeout = TimeSpan.FromSeconds(20) };
    private static readonly JsonSerializerOptions json = new() { PropertyNameCaseInsensitive = true };
    private string CachePath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CodexUsageTray", "reset-data.json");
    public async Task<ResetData?> GetAsync()
    {
        var forecast = await GetForecastAsync();
        var history = await http.GetFromJsonAsync<HistoryEnvelope>("https://codex-reset.today/api/v1/resets?limit=100&order=desc", json) ?? new HistoryEnvelope();
        var events = history.Data ?? [];
        var historyChance = EstimateHistoricalChance(events);
        var apiChance24 = UsableForecast(forecast) ? Math.Clamp(forecast!.Probabilities!.H24!.Display, 0, 100) : -1;
        var apiChance48 = UsableForecast(forecast) ? Math.Clamp(forecast!.Probabilities!.H48!.Display, 0, 100) : -1;
        var chance24 = apiChance24 >= 0 ? apiChance24 : historyChance;
        var chance48 = apiChance48 >= 0 ? apiChance48 : historyChance;
        var result = new ResetData
        {
            ChancePercent = chance48,
            Chance24HourPercent = chance24,
            ApiChancePercent = apiChance48,
            FetchedAt = DateTimeOffset.UtcNow,
            ForecastValidUntil = forecast?.ValidUntil ?? DateTimeOffset.MinValue,
            ForecastSource = apiChance48 >= 0 ? "Reset Beacon" : "Local reset history",
            ForecastState = forecast?.PublicationState ?? "unavailable",
            Events = events
        };
        Directory.CreateDirectory(Path.GetDirectoryName(CachePath)!); File.WriteAllText(CachePath, JsonSerializer.Serialize(result, json)); return result;
    }
    private static async Task<ResetBeaconForecast?> GetForecastAsync()
    {
        try
        {
            using var request = new HttpRequestMessage(HttpMethod.Get, "https://resetbeacon.com/api/forecast");
            request.Headers.CacheControl = new System.Net.Http.Headers.CacheControlHeaderValue { NoCache = true };
            using var response = await http.SendAsync(request);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadFromJsonAsync<ResetBeaconForecast>(json);
        }
        catch { return null; }
    }
    private static bool UsableForecast(ResetBeaconForecast? forecast)
    {
        if (forecast == null || forecast.Probabilities?.H24 == null || forecast.Probabilities.H48 == null || forecast.ValidUntil <= DateTimeOffset.UtcNow) return false;
        return !string.Equals(forecast.PublicationState, "stale", StringComparison.OrdinalIgnoreCase);
    }
    private static int EstimateHistoricalChance(List<ResetEvent> events)
    {
        var regular = events.Where(x => x.ResetType.Equals("regular", StringComparison.OrdinalIgnoreCase)).OrderBy(x => x.AnnouncedAt).ToList();
        if (regular.Count < 4) return 0;
        var intervals = regular.Zip(regular.Skip(1), (previous, current) => (current.AnnouncedAt - previous.AnnouncedAt).TotalHours).Where(x => x > 0).ToList();
        if (intervals.Count < 3) return 0;
        var elapsed = Math.Max(0, (DateTimeOffset.UtcNow - regular[^1].AnnouncedAt).TotalHours);
        var matches = intervals.Count(x => x >= elapsed && x <= elapsed + 48);
        return Math.Clamp((int)Math.Round(matches * 100d / intervals.Count), 0, 100);
    }
    public ResetData? LoadCached()
    {
        try
        {
            var data = JsonSerializer.Deserialize<ResetData>(File.ReadAllText(CachePath), json);
            if (data == null) return null;
            var needsForecastRefresh = data.Chance24HourPercent < 0;
            if (needsForecastRefresh) { data.Chance24HourPercent = data.ChancePercent; data.FetchedAt = DateTimeOffset.MinValue; }
            var forecastStillValid = data.ApiChancePercent >= 0 && data.ForecastValidUntil > DateTimeOffset.UtcNow;
            data.ChancePercent = forecastStillValid ? data.ApiChancePercent : EstimateHistoricalChance(data.Events);
            if (!forecastStillValid) data.Chance24HourPercent = EstimateHistoricalChance(data.Events);
            if (!forecastStillValid) { data.ApiChancePercent = -1; data.ForecastSource = "Local reset history"; data.ForecastState = "unavailable"; }
            return data;
        }
        catch { return null; }
    }
    private sealed class HistoryEnvelope { public List<ResetEvent>? Data { get; set; } }
    private sealed class ResetBeaconForecast
    {
        public string? PublicationState { get; set; }
        public DateTimeOffset ValidUntil { get; set; }
        public ResetBeaconProbabilities? Probabilities { get; set; }
    }
    private sealed class ResetBeaconProbabilities { public ResetBeaconProbability? H24 { get; set; } public ResetBeaconProbability? H48 { get; set; } }
    private sealed class ResetBeaconProbability { public int Display { get; set; } }
}

internal static class UiIcons
{
    public static void FitPopout(Form form, int width, int height, Point anchor)
    {
        form.ClientSize = new Size(width, height);
        PlaceAboveTray(form, anchor);
    }
    public static void PlaceAboveTray(Form form, Point anchor)
    {
        var area = Screen.GetWorkingArea(anchor);
        form.Size = new Size(Math.Min(form.Width, Math.Max(1, area.Width - 16)), Math.Min(form.Height, Math.Max(1, area.Height - 16)));
        form.Location = new Point(Math.Clamp(anchor.X - form.Width / 2, area.Left, area.Right - form.Width), Math.Clamp(anchor.Y - form.Height - 8, area.Top, area.Bottom - form.Height));
    }
    public static readonly Color SwitchColor = Color.FromArgb(255, 210, 70);
    public const float SwapFontSize = 10f;
    private const float SwapCanvasFontSize = 11.1111f;
    public static void DrawSwapButton(Graphics graphics, RectangleF bounds, Color color)
    {
    }
    public static void ApplyRoundedCorners(Form form)
    {
        if (form.ClientSize.Width <= 0 || form.ClientSize.Height <= 0) return;
        using var path = RoundedPath(new RectangleF(0, 0, form.ClientSize.Width, form.ClientSize.Height), 18);
        var previous = form.Region;
        form.Region = new Region(path);
        previous?.Dispose();
    }
    public static Button CreateSwapButton()
    {
        var button = new Button { Text = "Swap", Size = new Size(144, 34), FlatStyle = FlatStyle.Flat, BackColor = Color.FromArgb(55, 46, 16), ForeColor = SwitchColor, Font = new Font("Segoe UI", 15, FontStyle.Bold, GraphicsUnit.Pixel), UseCompatibleTextRendering = true, Cursor = Cursors.Hand };
        button.FlatAppearance.BorderColor = SwitchColor;
        button.FlatAppearance.BorderSize = 1;
        return button;
    }
    public static void DrawWindowBorder(Graphics graphics, Rectangle bounds, Color color)
    {
        if (bounds.Width < 4 || bounds.Height < 4) return;
        using var path = RoundedPath(new RectangleF(1, 1, bounds.Width - 2, bounds.Height - 2), 18);
        using var pen = new Pen(color, 1);
        graphics.DrawPath(pen, path);
    }
    private static GraphicsPath RoundedPath(RectangleF bounds, float radius)
    {
        var path = new GraphicsPath();
        var diameter = radius * 2;
        path.AddArc(bounds.X, bounds.Y, diameter, diameter, 180, 90);
        path.AddArc(bounds.Right - diameter, bounds.Y, diameter, diameter, 270, 90);
        path.AddArc(bounds.Right - diameter, bounds.Bottom - diameter, diameter, diameter, 0, 90);
        path.AddArc(bounds.X, bounds.Bottom - diameter, diameter, diameter, 90, 90);
        path.CloseFigure();
        return path;
    }
}

internal sealed class GraphForm : Form
{
    private UsageSnapshot current; private List<UsageSnapshot> history; private readonly GraphCanvas canvas; private readonly Label weeklyValue; private readonly Label sessionValue; private readonly Panel weeklyBar; private readonly Panel sessionBar; private readonly Label sessionBarText; private readonly Label refreshValue; private readonly Label graphValue; private readonly Label resetChanceValue; private readonly Label resetChance48Value; private readonly Label lastResetValue; private readonly Action<int> refreshChanged; private readonly Action<int> durationChanged; private int selectedRefreshMinutes; private int selectedGraphDays; private float popoutScale = 1; private readonly Dictionary<Control, float> baseFontSizes = [];
    public GraphForm(UsageSnapshot current, List<UsageSnapshot> history, int refreshMinutes, int graphDays, Action<int> refreshChanged, Action<int> durationChanged, ResetData? resetData, Action showAnalytics)
    {
        this.current = current; this.history = history; this.refreshChanged = refreshChanged; this.durationChanged = durationChanged; selectedRefreshMinutes = refreshMinutes; selectedGraphDays = graphDays; Text = "Codex limits"; ClientSize = new Size(760, 740); MinimumSize = Size.Empty; StartPosition = FormStartPosition.Manual; FormBorderStyle = FormBorderStyle.None; AutoScaleMode = AutoScaleMode.None; KeyPreview = true; BackColor = Color.Black; ForeColor = Color.White; DoubleBuffered = true; KeyDown += (_, e) => { if (e.KeyCode == Keys.Escape) Close(); };
        var header = new Panel { Width = ClientSize.Width, Dock = DockStyle.Top, Height = 360, BackColor = Color.Black };
        header.Controls.Add(new Label { Text = "Codex limits", AutoSize = true, Location = new Point(34, 14), Font = new Font("Segoe UI", 32, FontStyle.Bold, GraphicsUnit.Pixel), ForeColor = Color.White });
        resetChanceValue = new Label { AutoSize = true, Location = new Point(36, 60), Font = new Font("Segoe UI", 23, FontStyle.Bold, GraphicsUnit.Pixel), ForeColor = Color.FromArgb(255, 190, 70) }; header.Controls.Add(resetChanceValue);
        resetChance48Value = new Label { AutoSize = true, Location = new Point(245, 60), Font = new Font("Segoe UI", 23, FontStyle.Bold, GraphicsUnit.Pixel), ForeColor = Color.FromArgb(255, 225, 120) }; header.Controls.Add(resetChance48Value);
        lastResetValue = new Label { AutoSize = true, Location = new Point(500, 58), Font = new Font("Segoe UI", 23, FontStyle.Bold, GraphicsUnit.Pixel), ForeColor = Color.FromArgb(220, 220, 230) }; header.Controls.Add(lastResetValue);
        header.Controls.Add(new Label { Text = "WEEKLY CAPACITY", Tag = "muted", AutoSize = true, Location = new Point(36, 104), Font = new Font("Segoe UI", 18, FontStyle.Regular, GraphicsUnit.Pixel), ForeColor = Color.LightSteelBlue });
        weeklyValue = MetricLabel("", Color.LightSteelBlue); weeklyValue.Location = new Point(36, 135); header.Controls.Add(weeklyValue);
        var weeklyTrack = new Panel { Location = new Point(36, 183), Size = new Size(688, 20), BackColor = Color.FromArgb(25, 55, 32) }; weeklyTrack.Tag = "track"; weeklyTrack.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top; weeklyBar = new Panel { Tag = "weekly", Location = new Point(0, 0), Height = 20, BackColor = Color.FromArgb(55, 225, 95) }; weeklyTrack.Controls.Add(weeklyBar); header.Controls.Add(weeklyTrack);
        header.Controls.Add(new Label { Text = "5-HOUR CAPACITY", Tag = "muted", AutoSize = true, Location = new Point(36, 238), Font = new Font("Segoe UI", 18, FontStyle.Regular, GraphicsUnit.Pixel), ForeColor = Color.FromArgb(140, 190, 245) });
        sessionValue = MetricLabel("", Color.FromArgb(140, 190, 245)); sessionValue.Location = new Point(36, 265); header.Controls.Add(sessionValue);
        var sessionTrack = new Panel { Location = new Point(36, 314), Size = new Size(688, 20), BackColor = Color.FromArgb(25, 45, 70) }; sessionTrack.Tag = "track"; sessionTrack.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top; sessionBar = new Panel { Tag = "session", Location = new Point(0, 0), Height = 20, BackColor = Color.FromArgb(45, 155, 255) }; sessionTrack.Controls.Add(sessionBar); sessionBarText = new Label { Dock = DockStyle.Fill, TextAlign = ContentAlignment.MiddleCenter, Font = new Font("Segoe UI", 13, FontStyle.Bold, GraphicsUnit.Pixel), ForeColor = Color.Black, BackColor = Color.Transparent };  header.Controls.Add(sessionTrack);
        canvas = new GraphCanvas(); canvas.Dock = DockStyle.Fill; canvas.Current = current; canvas.History = history;
        var footer = new Panel { Dock = DockStyle.Bottom, Height = 118, BackColor = Color.Black };
        refreshValue = new Label { AutoSize = true, Location = new Point(36, 14), Font = new Font("Segoe UI", 17, FontStyle.Regular, GraphicsUnit.Pixel), ForeColor = Color.FromArgb(45, 155, 255) }; footer.Controls.Add(refreshValue);
        graphValue = new Label { AutoSize = true, Location = new Point(440, 14), Anchor = AnchorStyles.Top | AnchorStyles.Right, Font = new Font("Segoe UI", 17, FontStyle.Regular, GraphicsUnit.Pixel), ForeColor = Color.FromArgb(45, 155, 255) }; footer.Controls.Add(graphValue);
        var analyticsValue = UiIcons.CreateSwapButton(); analyticsValue.Location = new Point((footer.Width - analyticsValue.Width) / 2, 76); footer.Resize += (_, _) => { analyticsValue.Left = (footer.Width - analyticsValue.Width) / 2; graphValue.Left = footer.Width - graphValue.Width - 36; }; analyticsValue.Click += (_, _) => { Close(); showAnalytics(); }; new ToolTip().SetToolTip(analyticsValue, "Switch between limits and usage"); footer.Controls.Add(analyticsValue); analyticsValue.BringToFront();
        refreshValue.Cursor = Cursors.Hand; graphValue.Cursor = Cursors.Hand;
        refreshValue.Click += (_, _) => refreshChanged(selectedRefreshMinutes == 1 ? 5 : 1);
        graphValue.Click += (_, _) => durationChanged(selectedGraphDays == 1 ? 7 : selectedGraphDays == 7 ? 30 : 1);
        Controls.Add(canvas); Controls.Add(footer); Controls.Add(header);
        UpdateData(current, history);
        SetOptions(refreshMinutes, graphDays);
        SetResetData(resetData);
        Resize += (_, _) => UpdateData(this.current, this.history);
        CaptureFontSizes(this);
    }
    public void SetOptions(int minutes, int days) { selectedRefreshMinutes = minutes; selectedGraphDays = days; refreshValue.Text = $"Refresh: {minutes} min"; graphValue.Text = $"Graph: {days} day{(days == 1 ? "" : "s")}"; canvas.RangeDays = days; canvas.Invalidate(); }
    public void SetPopoutScale(int percent, Point anchor)
    {
        var scale = Math.Clamp(percent, 100, 200) / 100f;
        var ratio = scale / popoutScale;
        if (Math.Abs(ratio - 1) > 0.001f)
        {
            Scale(new SizeF(ratio, ratio));
            popoutScale = scale;
            canvas.LayoutScale = scale;
        }
        foreach (var pair in baseFontSizes)
        {
            pair.Key.Font = new Font(pair.Key.Font.FontFamily, pair.Value * scale, pair.Key.Font.Style, GraphicsUnit.Pixel);
        }
        PlaceAboveTray(anchor);
    }
    private void CaptureFontSizes(Control parent)
    {
        foreach (Control child in parent.Controls)
        {
            baseFontSizes[child] = child.Font.Size;
            CaptureFontSizes(child);
        }
    }
    protected override CreateParams CreateParams { get { var parameters = base.CreateParams; parameters.ExStyle |= 0x80; return parameters; } }
    protected override void OnLoad(EventArgs e)
    {
        ShowInTaskbar = false;
        base.OnLoad(e);
        UiIcons.ApplyRoundedCorners(this);
    }
    protected override void OnResize(EventArgs e) { base.OnResize(e); UiIcons.ApplyRoundedCorners(this); }
    protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); UiIcons.DrawWindowBorder(e.Graphics, ClientRectangle, ThemeManager.Current.Accent); }
    protected override void SetVisibleCore(bool value)
    {
        ShowInTaskbar = false;
        base.SetVisibleCore(value);
    }
    public void SetResetData(ResetData? data) { resetChanceValue.Text = data == null ? "24h: unavailable" : $"24h: {data.Chance24HourPercent}%"; resetChance48Value.Text = data == null ? "48h: unavailable" : $"48h: {data.ChancePercent}%"; var latest = data?.Events.OrderByDescending(x => x.AnnouncedAt).FirstOrDefault(); lastResetValue.Text = latest == null ? "Last reset: unavailable" : $"Last reset: {Math.Max(0, (DateTimeOffset.UtcNow - latest.AnnouncedAt).TotalDays):0.0} days ago"; canvas.ResetEvents = data?.Events ?? []; canvas.Invalidate(); }
    private Label MetricLabel(string name, Color color)
    {
        return new Label { Text = $"{(name == "Weekly" ? current.WeeklyRemaining : current.SessionRemaining):0}% remaining", AutoSize = true, Font = new Font("Segoe UI", 25, FontStyle.Bold, GraphicsUnit.Pixel), ForeColor = color };
    }
    public void UpdateData(UsageSnapshot value, List<UsageSnapshot> points)
    {
        current = value; history = points; canvas.Current = value; canvas.History = points; canvas.Invalidate();
        var weeklyText = $"{value.WeeklyRemaining:0}% remaining ({WeeklyResetText(value.WeeklyResetAt)})";
        var sessionText = $"{value.SessionRemaining:0}% remaining ({SessionResetText(value.SessionResetAt)})";
        weeklyValue.Text = weeklyText; sessionValue.Text = sessionText;
        weeklyBar.Width = (int)(weeklyBar.Parent!.ClientSize.Width * Math.Clamp(value.WeeklyRemaining, 0, 100) / 100);
        sessionBar.Width = (int)(sessionBar.Parent!.ClientSize.Width * Math.Clamp(value.SessionRemaining, 0, 100) / 100); sessionBarText.Text = "";
    }
    private static string WeeklyResetText(DateTimeOffset? resetAt)
    {
        if (resetAt is null) return "reset time unavailable";
        var remaining = resetAt.Value - DateTimeOffset.UtcNow;
        if (remaining <= TimeSpan.Zero) return "resetting now";
        return $"resets in {Math.Max(0, (int)remaining.TotalDays)} days {remaining.Hours} hrs";
    }
    private static string SessionResetText(DateTimeOffset? resetAt)
    {
        if (resetAt is null) return "reset time unavailable";
        var remaining = resetAt.Value - DateTimeOffset.UtcNow;
        if (remaining <= TimeSpan.Zero) return "resetting now";
        return $"resets in {Math.Max(0, (int)remaining.TotalHours)} hrs {remaining.Minutes} mins";
    }
    public void PlaceAboveTray(Point anchor)
    {
        UiIcons.PlaceAboveTray(this, anchor);
    }

}

internal sealed class GraphCanvas : Panel
{
    public float LayoutScale { get; set; } = 1;
    public UsageSnapshot? Current { get; set; } public List<UsageSnapshot> History { get; set; } = []; public int RangeDays { get; set; } = 7; public List<ResetEvent> ResetEvents { get; set; } = [];
    private int hoverX = -1;
    private double? hoverValue;
    private DateTimeOffset? hoverTime;
    private ResetEvent? hoverReset;
    public GraphCanvas() { BackColor = Color.FromArgb(24, 25, 29); DoubleBuffered = true; Padding = new Padding(24); MouseMove += UpdateHover; MouseLeave += (_, _) => { hoverX = -1; hoverValue = null; hoverTime = null; hoverReset = null; Invalidate(); }; }
    private void UpdateHover(object? sender, MouseEventArgs e)
    {
        var plot = new Rectangle(120, 100, Math.Max(100, (int)(Width / LayoutScale) - 180), Math.Max(100, (int)(Height / LayoutScale) - 170));
        var mouseX = e.X / LayoutScale; var mouseY = e.Y / LayoutScale;
        if (mouseX < plot.Left || mouseX > plot.Right || mouseY < plot.Top || mouseY > plot.Bottom) { hoverX = -1; hoverValue = null; hoverTime = null; hoverReset = null; Invalidate(); return; }
        var rangeStart = DateTimeOffset.UtcNow.AddDays(-RangeDays);
        var reset = ResetEvents.Where(x => x.AnnouncedAt >= rangeStart && x.AnnouncedAt <= DateTimeOffset.UtcNow)
            .Select(x => new { Event = x, X = plot.Left + (x.AnnouncedAt - rangeStart).TotalDays / RangeDays * plot.Width })
            .OrderBy(x => Math.Abs(x.X - mouseX)).FirstOrDefault();
        if (reset != null && Math.Abs(reset.X - mouseX) <= 8)
        {
            hoverX = (int)Math.Clamp(reset.X, plot.Left, plot.Right); hoverValue = null; hoverTime = null; hoverReset = reset.Event; Invalidate(); return;
        }
        hoverReset = null;
        var points = VisiblePoints();
        if (points.Count == 0) return;
        var point = points.OrderBy(x => Math.Abs((plot.Left + (x.At - rangeStart).TotalDays / RangeDays * plot.Width) - mouseX)).First();
        hoverX = (int)Math.Clamp(plot.Left + (point.At - rangeStart).TotalDays / RangeDays * plot.Width, plot.Left, plot.Right); hoverValue = point.WeeklyRemaining; hoverTime = point.At; Invalidate();
    }
    protected override void OnPaint(PaintEventArgs e)
    {
        e.Graphics.Clear(BackColor); e.Graphics.ScaleTransform(LayoutScale, LayoutScale); var plot = new Rectangle(120, 100, Math.Max(100, (int)(Width / LayoutScale) - 180), Math.Max(100, (int)(Height / LayoutScale) - 170)); using var grid = new Pen(Color.FromArgb(55, ThemeManager.Current.Muted)); using var text = new SolidBrush(ThemeManager.Current.Muted); using var font = new Font("Segoe UI", 16, FontStyle.Regular, GraphicsUnit.Pixel);
        for (int i = 0; i <= 4; i++) { var y = plot.Top + i * plot.Height / 4; e.Graphics.DrawLine(grid, plot.Left, y, plot.Right, y); e.Graphics.DrawString($"{100 - i * 25}%", font, text, 18, y - 8); }
        using var heading = new Font("Segoe UI", 18, FontStyle.Bold, GraphicsUnit.Pixel); e.Graphics.DrawString("Remaining usage", heading, Brushes.White, 34, 20); if (RangeDays == 1) { for (var i = 0; i <= 4; i++) { var x = plot.Left + i * plot.Width / 4f; e.Graphics.DrawLine(grid, x, plot.Top, x, plot.Bottom); var label = DateTimeOffset.UtcNow.AddHours(-24 + i * 6).ToLocalTime().ToString("HH:mm"); var labelSize = e.Graphics.MeasureString(label, font); e.Graphics.DrawString(label, font, text, x - labelSize.Width / 2, plot.Bottom + 12); } } else { e.Graphics.DrawString($"{RangeDays} day{(RangeDays == 1 ? "" : "s")} ago", font, text, plot.Left, plot.Bottom + 12); var todaySize = e.Graphics.MeasureString("Today", font); e.Graphics.DrawString("Today", font, text, plot.Right - todaySize.Width, plot.Bottom + 12); }
        var rangeStart = DateTimeOffset.UtcNow.AddDays(-RangeDays);
        var visibleResets = ResetEvents.Where(x => x.AnnouncedAt >= rangeStart && x.AnnouncedAt <= DateTimeOffset.UtcNow).ToList();
        foreach (var reset in visibleResets) { var x = plot.Left + (float)((reset.AnnouncedAt - rangeStart).TotalDays / RangeDays) * plot.Width; using var resetPen = new Pen(reset.ResetType.Equals("banked", StringComparison.OrdinalIgnoreCase) ? Color.SaddleBrown : Color.DeepSkyBlue, reset == hoverReset ? 4 : 2); e.Graphics.DrawLine(resetPen, x, plot.Top, x, plot.Bottom); }
        if (hoverReset != null)
        {
            using var hoverFont = new Font("Segoe UI", 16, FontStyle.Regular, GraphicsUnit.Pixel); var resetKind = hoverReset.ResetType.Equals("banked", StringComparison.OrdinalIgnoreCase) ? "Banked reset" : "Reset"; var label = $"{resetKind}  •  {hoverReset.AnnouncedAt.ToLocalTime():dd MMM yyyy HH:mm}"; var size = e.Graphics.MeasureString(label, hoverFont); var badge = new RectangleF(plot.Right - size.Width - 18, 16, size.Width + 14, size.Height + 8); using var badgeBackground = new SolidBrush(ThemeManager.Current.Panel); using var badgeBorder = new Pen(Color.DeepSkyBlue, 1); e.Graphics.FillRectangle(badgeBackground, badge); e.Graphics.DrawRectangle(badgeBorder, badge.X, badge.Y, badge.Width, badge.Height); using var labelBrush = new SolidBrush(Color.DeepSkyBlue); e.Graphics.DrawString(label, hoverFont, labelBrush, badge.X + 7, badge.Y + 4);
        }
        var points = VisiblePoints();
        if (points.Count < 2) { using var empty = new SolidBrush(ThemeManager.Current.Muted); var msg = "Weekly history is collecting — check back after a few refreshes."; var size = e.Graphics.MeasureString(msg, font); e.Graphics.DrawString(msg, font, empty, plot.Left + (plot.Width - size.Width) / 2, plot.Top + plot.Height / 2 - 10); return; }
        var usageRangeStart = DateTimeOffset.UtcNow.AddDays(-RangeDays);
        PointF p(int i, double val) => new(plot.Left + (float)Math.Clamp((points[i].At - usageRangeStart).TotalDays / RangeDays, 0, 1) * plot.Width, plot.Top + (float)(100 - Math.Clamp(val, 0, 100)) * plot.Height / 100);
        using var line = new Pen(ThemeManager.Current.Good, 3); using var dot = new SolidBrush(ThemeManager.Current.Good); for (int i = 1; i < points.Count; i++) e.Graphics.DrawLine(line, p(i - 1, points[i - 1].WeeklyRemaining), p(i, points[i].WeeklyRemaining)); foreach (var point in points) { var q = p(points.IndexOf(point), point.WeeklyRemaining); e.Graphics.FillEllipse(dot, q.X - 4, q.Y - 4, 8, 8); }
        if (hoverX >= plot.Left && hoverX <= plot.Right && hoverValue.HasValue && hoverTime.HasValue)
        {
            var hoverRangeStart = DateTimeOffset.UtcNow.AddDays(-RangeDays); var dotPoint = new PointF(plot.Left + (float)Math.Clamp((hoverTime.Value - hoverRangeStart).TotalDays / RangeDays, 0, 1) * plot.Width, plot.Top + (float)(100 - Math.Clamp(hoverValue.Value, 0, 100)) * plot.Height / 100);
            using var dotOutline = new SolidBrush(Color.FromArgb(220, 255, 255, 255)); using var dotBrush = new SolidBrush(ThemeManager.Current.Good); e.Graphics.FillEllipse(dotOutline, dotPoint.X - 7, dotPoint.Y - 7, 14, 14); e.Graphics.FillEllipse(dotBrush, dotPoint.X - 5, dotPoint.Y - 5, 10, 10);
            using var hoverFont = new Font("Segoe UI", 16, FontStyle.Regular, GraphicsUnit.Pixel); var label = $"{hoverValue.Value:0.0}%  •  {hoverTime.Value.ToLocalTime():HH:mm}"; var size = e.Graphics.MeasureString(label, hoverFont); var badge = new RectangleF(plot.Right - size.Width - 18, 16, size.Width + 14, size.Height + 8); using var badgeBackground = new SolidBrush(ThemeManager.Current.Panel); using var badgeBorder = new Pen(ThemeManager.Current.Good, 1); e.Graphics.FillRectangle(badgeBackground, badge); e.Graphics.DrawRectangle(badgeBorder, badge.X, badge.Y, badge.Width, badge.Height); using var labelBrush = new SolidBrush(ThemeManager.Current.Good); e.Graphics.DrawString(label, hoverFont, labelBrush, badge.X + 7, badge.Y + 4);
        }
    }
    private List<UsageSnapshot> VisiblePoints() { var rangeStart = DateTimeOffset.UtcNow.AddDays(-RangeDays); var points = History.Where(x => x.At >= rangeStart).OrderBy(x => x.At).ToList(); if (Current != null && (points.Count == 0 || points[^1].At != Current.At)) points.Add(Current); if (points.Count == 0) return points; var interval = RangeDays == 1 ? TimeSpan.FromHours(1) : RangeDays == 7 ? TimeSpan.FromHours(6) : TimeSpan.FromDays(1); var count = (int)Math.Ceiling(TimeSpan.FromDays(RangeDays).TotalHours / interval.TotalHours); var sampled = new List<UsageSnapshot>(); for (var i = 0; i <= count; i++) { var slot = rangeStart + TimeSpan.FromTicks(interval.Ticks * i); var sample = points.LastOrDefault(x => x.At <= slot) ?? points.FirstOrDefault(x => x.At <= slot + interval); if (sample != null) sampled.Add(sample with { At = slot }); } return sampled; }
}

internal static class GraphicsExtensions
{
    public static void DrawRoundedRectangle(this Graphics g, Pen pen, float x, float y, float w, float h, float radius)
    { using var p = RoundedPath(x, y, w, h, radius); g.DrawPath(pen, p); }
    public static void FillRoundedRectangle(this Graphics g, Brush b, float x, float y, float w, float h, float radius)
    { using var p = RoundedPath(x, y, w, h, radius); g.FillPath(b, p); }
    private static GraphicsPath RoundedPath(float x, float y, float w, float h, float radius)
    { var p = new GraphicsPath(); p.AddArc(x, y, radius * 2, radius * 2, 180, 90); p.AddArc(x + w - radius * 2, y, radius * 2, radius * 2, 270, 90); p.AddArc(x + w - radius * 2, y + h - radius * 2, radius * 2, radius * 2, 0, 90); p.AddArc(x, y + h - radius * 2, radius * 2, radius * 2, 90, 90); p.CloseFigure(); return p; }
}