MainForm.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Eto.Drawing;
using Eto.Forms;
using SharpHook;
using SharpHook.Data;

namespace devtime
{
    public class MainForm : Form
    {
        [DllImport("user32.dll")]
        private static extern IntPtr GetForegroundWindow();

        private Bitmap? _iconLog;
        private Bitmap? _iconLogWarning;
        private Bitmap? _iconExport;
        private Bitmap? _iconTerminal;
        private Bitmap? _iconSettings;
        private Bitmap? _iconStart;
        private Bitmap? _iconStop;
        private Bitmap? _iconAdd;
        private Bitmap? _iconRemove;
        private Bitmap? _iconEdit;
        private Bitmap? _iconEditTime;
        private Bitmap? _iconRefresh;
        private Bitmap? _iconPrev;
        private Bitmap? _iconNext;
        private Bitmap? _iconTrayGreen;
        private Bitmap? _iconTrayRed;
        private Bitmap? _iconTrayYellow;
        private Bitmap? _iconTrayDefault;

        private TrayIndicator? _trayIndicator;
        private TaskPoolGlobalHook? _hook;
        private bool _isQuitting = false;

        private Thread? timerThread;
        private volatile bool timerThreadShouldStop;

        private enum TimerState { Start, Starting, Stop, Stopping }
        private TimerState timerState = TimerState.Start;

        private long dayBaseTime; // Ticks
        private long dayCurrentStartTime; // Ticks

        private string context = "";
        private string timerDate = "";
        private string? previousDate;
        private string? currentDate;
        private string? nextDate;

        private readonly List<string> days = new List<string>();
        private int todayIndex = -1;
        private bool initialized = false;
        private int _openDialogsCount = 0;

        private T ShowDialogHelper<T>(Dialog<T> dialog)
        {
            _openDialogsCount++;
            try
            {
                return dialog.ShowModal(this);
            }
            finally
            {
                _openDialogsCount--;
            }
        }

        private void ShowDialogHelper(Dialog dialog)
        {
            _openDialogsCount++;
            try
            {
                dialog.ShowModal(this);
            }
            finally
            {
                _openDialogsCount--;
            }
        }

        // UI Controls
        private Button? _logWorkBtn;
        private Button? _statsBtn;
        private Button? _terminalBtn;
        private Button? _settingsBtn;

        private DropDown? _projectDropDown;
        private Button? _editProjectBtn;
        private GroupBox? _projectGroupBox;

        private Label? _timerMainLabel;
        private Label? _timerSecondaryLabel;
        private GroupBox? _timerGroupBox;

        private Button? _startButton;

        private Button? _prevMonthBtn;
        private Button? _nextMonthBtn;
        private Label? _monthLabel;

        private ListBox? _daysListBox;

        private Button? _refreshBtn;
        private Button? _editTimeBtn;
        private Button? _removeBtn;
        private Button? _addBtn;

        // Windows taskbar color list interop
        private ITaskbarList3? _taskbarList;

        public MainForm()
        {
            Title = "devtime";
            ClientSize = new Size(447, 259);
            Resizable = false;
            Maximizable = false;

            // Load and set the main window icon and tray icons
            InitializeIcons();

            // Set up WindowStateChanged handler
            WindowStateChanged += OnWindowStateChanged;

            // Subscribe to macOS close notifications
            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                Shown += (sender, e) => SubscribeToMacNotifications();
            }

            // Taskbar effects (Windows-only)
            InitializeTaskbar();

            // Setup controls and layouts
            InitializeControls();

            // Window Shown handler to load context/hook
            Shown += (sender, e) =>
            {
                ReloadContexts(Config.LastSelectedProject);
                UpdateHookState();
                initialized = true;
            };
        }

        private void InitializeIcons()
        {
            try
            {
                var assembly = typeof(MainForm).Assembly;

                _iconLog = LoadIcon("log.png");
                _iconLogWarning = LoadIcon("log-warning.png");
                _iconExport = LoadIcon("export.png");
                _iconTerminal = LoadIcon("terminal.png");
                _iconSettings = LoadIcon("settings.png");
                _iconStart = LoadIcon("start.png");
                _iconStop = LoadIcon("stop.png");
                _iconAdd = LoadIcon("add.png");
                _iconRemove = LoadIcon("remove.png");
                _iconEdit = LoadIcon("edit.png");
                _iconEditTime = LoadIcon("edit-time.png");
                _iconRefresh = LoadIcon("refresh.png");
                _iconPrev = LoadIcon("prev.png");
                _iconNext = LoadIcon("next.png");
                _iconTrayGreen = LoadIcon("tray-green.png");
                _iconTrayRed = LoadIcon("tray-red.png");
                _iconTrayYellow = LoadIcon("tray-yellow.png");
                _iconTrayDefault = LoadIcon("tray.png");

                // Main window icon
                string? resIcon = FindResourceName("icon.png");
                if (resIcon != null)
                {
                    Icon = Eto.Drawing.Icon.FromResource(resIcon, assembly);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error initializing icons: {ex}");
            }
        }

        private Bitmap? LoadIcon(string name)
        {
            try
            {
                var assembly = typeof(MainForm).Assembly;
                string? resName = FindResourceName(name);
                if (resName != null)
                {
                    return Bitmap.FromResource(resName, assembly);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error loading resource {name}: {ex}");
            }
            return null;
        }

        private string? FindResourceName(string filename)
        {
            var assembly = typeof(MainForm).Assembly;
            foreach (var name in assembly.GetManifestResourceNames())
            {
                if (name.EndsWith(filename, StringComparison.OrdinalIgnoreCase))
                {
                    return name;
                }
            }
            return null;
        }

        private void InitializeTaskbar()
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                try
                {
                    _taskbarList = (ITaskbarList3)new TaskbarList();
                    _taskbarList.HrInit();
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Failed to initialize taskbar interop: {ex}");
                }
            }
        }

        private IntPtr GetHwnd()
        {
            try
            {
                dynamic? form = ControlObject;
                if (form != null)
                {
                    return (IntPtr)form.Handle;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error getting HWND: {ex}");
            }
            return IntPtr.Zero;
        }

        private void UpdateTaskbar()
        {
            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || _taskbarList == null) return;

            var color = (timerState == TimerState.Start) ? Config.StoppedTimerColor : Config.RunningTimerColor;
            TBPFLAG flag = TBPFLAG.NOPROGRESS;
            switch (color)
            {
                case TaskbarColor.Green:
                    flag = TBPFLAG.NORMAL;
                    break;
                case TaskbarColor.Yellow:
                    flag = TBPFLAG.PAUSED;
                    break;
                case TaskbarColor.Red:
                    flag = TBPFLAG.ERROR;
                    break;
                default:
                    flag = TBPFLAG.NOPROGRESS;
                    break;
            }

            try
            {
                IntPtr hwnd = GetHwnd();
                if (hwnd != IntPtr.Zero)
                {
                    _taskbarList.SetProgressValue(hwnd, 1, 1);
                    _taskbarList.SetProgressState(hwnd, flag);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error updating taskbar: {ex}");
            }
        }

        private void InitializeControls()
        {
            // Toolbar buttons
            _logWorkBtn = new Button { Image = _iconLogWarning, Text = "Log work", ToolTip = "Describe what you did on this day" };
            _logWorkBtn.Click += (s, e) => LogWorkClick();

            _statsBtn = new Button { Image = _iconExport, Text = "Stats/Export", ToolTip = "See stats or export to CSV/JSON" };
            _statsBtn.Click += (s, e) => StatsClick();

            _terminalBtn = new Button { Image = _iconTerminal, Text = "Terminal", ToolTip = "Database terminal" };
            _terminalBtn.Click += (s, e) => TerminalClick();

            _settingsBtn = new Button { Image = _iconSettings, Text = "Settings", ToolTip = "Change various options" };
            _settingsBtn.Click += (s, e) => SettingsClick();

            // Project GroupBox
            _projectDropDown = new DropDown();
            _projectDropDown.SelectedIndexChanged += ProjectDropDown_SelectedIndexChanged;

            _editProjectBtn = new Button { Image = _iconEdit, Size = new Size(24, 24) };
            _editProjectBtn.Click += (s, e) => EditProjectClick();

            var projectDropDownWrapper = new Panel
            {
                Padding = new Padding(0, 2, 0, 0),
                Content = _projectDropDown
            };

            var projectLayout = new TableLayout
            {
                Spacing = new Size(5, 0),
                Rows = { new TableRow(new TableCell(projectDropDownWrapper, true), _editProjectBtn) }
            };
            _projectGroupBox = new GroupBox { Text = "Project", Content = projectLayout, Height = 52 };

            // Timer GroupBox
            _timerMainLabel = new Label { Text = "00:00", Font = Fonts.Monospace(48, FontStyle.Bold), VerticalAlignment = VerticalAlignment.Center };
            _timerSecondaryLabel = new Label { Text = "00.00", Font = Fonts.Monospace(18, FontStyle.Bold), TextColor = Colors.DarkGray, VerticalAlignment = VerticalAlignment.Center };

            var timerLayout = new StackLayout
            {
                Orientation = Orientation.Horizontal,
                Spacing = 0,
                VerticalContentAlignment = VerticalAlignment.Center,
                HorizontalContentAlignment = HorizontalAlignment.Center,
                Items = { _timerMainLabel, _timerSecondaryLabel }
            };
            _timerGroupBox = new GroupBox { Text = "Timer", Font = Fonts.Sans(12), Content = timerLayout, Height = 80 };

            // Start Button
            _startButton = new Button { Text = "Start", Image = _iconStart, Font = Fonts.Sans(14, FontStyle.Bold), Height = 54 };
            _startButton.Click += (s, e) => StartButtonClick();

            // Month navigation
            _prevMonthBtn = new Button { Image = _iconPrev, Size = new Size(24, 24) };
            _prevMonthBtn.Click += (s, e) => _prevMonthBtn_Click();

            _nextMonthBtn = new Button { Image = _iconNext, Size = new Size(24, 24) };
            _nextMonthBtn.Click += (s, e) => _nextMonthBtn_Click();

            _monthLabel = new Label { Text = "Jan 2022", TextAlignment = TextAlignment.Center, Font = Fonts.Sans(9), VerticalAlignment = VerticalAlignment.Center };

            var monthLayout = new TableLayout
            {
                Spacing = new Size(2, 0),
                Rows = { new TableRow(_prevMonthBtn, new TableCell(_monthLabel, true), _nextMonthBtn) }
            };

            // Days ListBox
            _daysListBox = new ListBox { Font = Fonts.Sans(9) };
            _daysListBox.SelectedIndexChanged += DaysListBox_SelectedIndexChanged;

            // Action Buttons
            _refreshBtn = new Button { Image = _iconRefresh, Size = new Size(24, 24), ToolTip = "Refresh" };
            _refreshBtn.Click += (s, e) => RefreshClick();

            _editTimeBtn = new Button { Image = _iconEditTime, Size = new Size(24, 24), ToolTip = "Edit logged time" };
            _editTimeBtn.Click += (s, e) => EditTimeClick();

            _removeBtn = new Button { Image = _iconRemove, Size = new Size(24, 24), ToolTip = "Delete entry" };
            _removeBtn.Click += (s, e) => RemoveClick();

            _addBtn = new Button { Image = _iconAdd, Size = new Size(24, 24), ToolTip = "Add entry" };
            _addBtn.Click += (s, e) => AddClick();

            var actionLayout = new TableLayout
            {
                Spacing = new Size(2, 0),
                Rows =
                {
                    new TableRow(
                        new TableCell(_refreshBtn, false),
                        new TableCell(new Panel(), true),
                        new TableCell(_editTimeBtn, false),
                        new TableCell(_removeBtn, false),
                        new TableCell(_addBtn, false)
                    )
                }
            };

            // Layout assembly
            var toolbarButtonsLayout = new TableLayout
            {
                Padding = new Padding(5, 0),
                Rows =
                {
                    new TableRow(
                        new TableCell(_logWorkBtn),
                        new TableCell(new Panel { Width = 5 }),
                        new TableCell(_statsBtn),
                        new TableCell(new Panel(), true),
                        new TableCell(_settingsBtn),
                        new TableCell(new Panel { Width = 5 }),
                        new TableCell(_terminalBtn)
                    )
                }
            };

            var toolbarSeparator = new Panel
            {
                Height = 1,
                BackgroundColor = Color.Parse("#A0A0A0")
            };

            var toolbarLayout = new TableLayout
            {
                BackgroundColor = Colors.White,
                Rows =
                {
                    new TableRow(toolbarButtonsLayout),
                    new TableRow(toolbarSeparator)
                }
            };

            var leftLayout = new StackLayout
            {
                Spacing = 5,
                HorizontalContentAlignment = HorizontalAlignment.Stretch,
                Items = { _projectGroupBox, _timerGroupBox, _startButton }
            };

            var rightLayout = new TableLayout
            {
                Spacing = new Size(5, 0),
                Rows =
                {
                    new TableRow(monthLayout),
                    new TableRow(_daysListBox) { ScaleHeight = true },
                    new TableRow(actionLayout)
                }
            };

            var leftPanel = new Panel { Width = 280, Content = leftLayout };
            var rightPanel = new Panel { Content = rightLayout };

            var mainBodyLayout = new TableLayout
            {
                Spacing = new Size(20, 0),
                Padding = new Padding(10, 5, 10, 10),
                Rows =
                {
                    new TableRow(
                        new TableCell(leftPanel),
                        new TableCell(rightPanel, true)
                    )
                }
            };

            Content = new TableLayout
            {
                Rows =
                {
                    new TableRow(toolbarLayout),
                    new TableRow(mainBodyLayout) { ScaleHeight = true }
                }
            };
            // Style all flat icon buttons
            StyleFlatIconButton(_logWorkBtn);
            StyleFlatIconButton(_statsBtn);
            StyleFlatIconButton(_terminalBtn);
            StyleFlatIconButton(_settingsBtn);
            StyleFlatIconButton(_editProjectBtn);
            StyleFlatIconButton(_prevMonthBtn);
            StyleFlatIconButton(_nextMonthBtn);
            StyleFlatIconButton(_refreshBtn);
            StyleFlatIconButton(_editTimeBtn);
            StyleFlatIconButton(_removeBtn);
            StyleFlatIconButton(_addBtn);
        }

        private void StyleFlatIconButton(Button button)
        {
            var nativeObj = button.ControlObject;
            if (nativeObj != null)
            {
                var type = nativeObj.GetType();
                bool isWinFormsButton = false;
                while (type != null)
                {
                    if (type.FullName == "System.Windows.Forms.Button" || type.FullName == "System.Windows.Forms.ButtonBase")
                    {
                        isWinFormsButton = true;
                        break;
                    }
                    type = type.BaseType;
                }

                if (isWinFormsButton)
                {
                    try
                    {
                        var flatStyleProp = nativeObj.GetType().GetProperty("FlatStyle");
                        if (flatStyleProp != null)
                        {
                            var flatVal = Enum.Parse(flatStyleProp.PropertyType, "Flat");
                            flatStyleProp.SetValue(nativeObj, flatVal);
                        }

                        var flatAppearanceProp = nativeObj.GetType().GetProperty("FlatAppearance");
                        if (flatAppearanceProp != null)
                        {
                            var flatApp = flatAppearanceProp.GetValue(nativeObj);
                            if (flatApp != null)
                            {
                                var borderSizeProp = flatApp.GetType().GetProperty("BorderSize");
                                if (borderSizeProp != null)
                                {
                                    borderSizeProp.SetValue(flatApp, 0);
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error styling flat button: {ex}");
                    }
                }
            }
        }

        private bool IsWindowFocused()
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                try
                {
                    IntPtr hwnd = GetHwnd();
                    if (hwnd != IntPtr.Zero)
                    {
                        return GetForegroundWindow() == hwnd;
                    }
                }
                catch { }
            }
            return true;
        }

        private void LoadContext(string ctx)
        {
            string lastContext = context;
            context = ctx;

            try
            {
                UpdateTimer(0);
                ReloadContext();
            }
            catch (Exception)
            {
                context = lastContext;
                try
                {
                    ReloadContext();
                }
                catch (Exception innerEx)
                {
                    MessageBox.Show(this, $"Fatal error: failed to restore last project data from database.\n\n{innerEx.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                    Application.Instance.Quit();
                }
                throw;
            }
        }

        private void ReloadContext()
        {
            try
            {
                previousDate = null;
                currentDate = null;
                nextDate = null;

                if (!LoadDay())
                {
                    _monthLabel!.Text = DateToMonthString(DateTime.Today.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"Failed to load project data from the database.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                throw;
            }
        }

        private void ReloadContexts(string? preferredContext = null)
        {
            _projectDropDown!.Items.Clear();

            List<string> contexts = DB.ListTables();

            foreach (var ctx in contexts)
            {
                _projectDropDown.Items.Add(ctx);
            }

            _projectDropDown.Items.Add("Add new project...");

            if (_projectDropDown.Items.Count > 1)
            {
                int index = 0;
                if (preferredContext != null)
                {
                    int found = -1;
                    for (int i = 0; i < _projectDropDown.Items.Count; i++)
                    {
                        if (_projectDropDown.Items[i].Text == preferredContext)
                        {
                            found = i;
                            break;
                        }
                    }

                    if (found != -1)
                    {
                        index = found;
                    }
                }

                _projectDropDown.SelectedIndex = index;
                LoadContext(_projectDropDown.Items[index].Text);

                _startButton!.Enabled = true;
                UpdateContextButtons(true);
            }
            else
            {
                days.Clear();
                _daysListBox!.Items.Clear();

                previousDate = null;
                currentDate = null;
                nextDate = null;

                _startButton!.Enabled = false;

                _prevMonthBtn!.Enabled = false;
                _nextMonthBtn!.Enabled = false;
                UpdateLogWork();
                UpdateDayButtons(false);
                UpdateContextButtons(false);

                UpdateTimer(0);
            }

            UpdateLogWork();
        }

        private bool LoadDay(string? day = null)
        {
            _daysListBox!.Items.Clear();
            days.Clear();

            if (day == null)
            {
                day = DB.SelectNewestDate(context);

                if (day == null)
                {
                    _prevMonthBtn!.Enabled = false;
                    _nextMonthBtn!.Enabled = false;
                    UpdateLogWork();
                    UpdateDayButtons(false);
                    UpdateTimer(0);
                    return false;
                }
            }

            UpdateDayButtons(true);

            if (day != currentDate)
            {
                if (day == previousDate)
                {
                    nextDate = currentDate;
                    currentDate = day;
                    previousDate = DB.SelectNewestDateBeforeMonth(context, day.Substring(0, 7));
                }
                else if (day == nextDate)
                {
                    previousDate = currentDate;
                    currentDate = day;
                    nextDate = DB.SelectOldestDateAfterMonth(context, day.Substring(0, 7));
                }
                else
                {
                    currentDate = day;
                    previousDate = DB.SelectNewestDateBeforeMonth(context, day.Substring(0, 7));
                    nextDate = DB.SelectOldestDateAfterMonth(context, day.Substring(0, 7));
                }

                _prevMonthBtn!.Enabled = previousDate != null;
                _nextMonthBtn!.Enabled = nextDate != null;
            }

            _monthLabel!.Text = DateToMonthString(currentDate);

            List<string> dates = DB.SelectDatesInMonth(context, currentDate.Substring(0, 7));

            if (dates == null || dates.Count == 0)
            {
                UpdateLogWork();
                return true;
            }

            foreach (var dt in dates)
            {
                _daysListBox.Items.Add(DateToDayString(dt));
                days.Add(dt);
            }

            _daysListBox.SelectedIndex = 0;
            OnSelectEntry(days[0]);

            UpdateLogWork();
            return true;
        }

        private void SelectToday()
        {
            DateTime now = DateTime.Now;
            string today = now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
            timerDate = today;

            bool addedOrRefreshed = false;

            if (!DB.DateExists(context, today))
            {
                DB.InsertEntry(context, today, 0, null);
                ReloadContext();
                addedOrRefreshed = true;
            }
            else if (currentDate == null || currentDate.Substring(0, 7) != today.Substring(0, 7))
            {
                ReloadContext();
                addedOrRefreshed = true;
            }

            if (!days.Contains(today) && !addedOrRefreshed)
            {
                ReloadContext();
            }

            todayIndex = days.IndexOf(today);
            if (todayIndex != -1)
            {
                _daysListBox!.SelectedIndex = todayIndex;
            }

            long baseTime = DB.SelectLoggedTime(context, today) ?? 0;
            dayBaseTime = baseTime * TimeSpan.TicksPerMillisecond;
            dayCurrentStartTime = now.Ticks;

            UpdateTimer(baseTime);
        }

        private void OnSelectEntry(string entry)
        {
            long time = DB.SelectLoggedTime(context, entry) ?? 0;
            UpdateTimer(time);
            UpdateLogWork();
        }

        private string DateToDayString(string when)
        {
            if (DateTime.TryParseExact(when, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
            {
                string name = date.DayOfWeek.ToString();

                if (date.Date == DateTime.Today)
                {
                    name = "Today";
                }
                else if (date.Date == DateTime.Today.AddDays(-1))
                {
                    name = "Yesterday";
                }
                else if (date.Date == DateTime.Today.AddDays(1))
                {
                    name = "Tomorrow";
                }

                return $"{date.Day:D2} - {name}";
            }
            return when;
        }

        private string DateToMonthString(string when)
        {
            if (DateTime.TryParseExact(when, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
            {
                return date.ToString("MMM yyyy", CultureInfo.InvariantCulture);
            }
            return when;
        }

        private void UpdateLogWork()
        {
            if (_daysListBox != null && _daysListBox.SelectedIndex != -1 && days.Count > _daysListBox.SelectedIndex)
            {
                string date = days[_daysListBox.SelectedIndex];
                string? log = DB.SelectLog(context, date);
                if (!string.IsNullOrWhiteSpace(log))
                {
                    _logWorkBtn!.Image = _iconLog;
                    return;
                }
            }
            _logWorkBtn!.Image = _iconLogWarning;
        }

        private void UpdateDayButtons(bool enabled)
        {
            _logWorkBtn!.Enabled = enabled;
            _removeBtn!.Enabled = enabled;
            _editTimeBtn!.Enabled = enabled;
        }

        private void UpdateContextButtons(bool enabled)
        {
            _statsBtn!.Enabled = enabled;
            _editProjectBtn!.Enabled = enabled;
        }

        private void DisableMostControls()
        {
            _logWorkBtn!.Enabled = false;
            _statsBtn!.Enabled = false;
            _terminalBtn!.Enabled = false;
            _settingsBtn!.Enabled = false;
            _refreshBtn!.Enabled = false;
            _editTimeBtn!.Enabled = false;
            _removeBtn!.Enabled = false;
            _addBtn!.Enabled = false;
            _prevMonthBtn!.Enabled = false;
            _nextMonthBtn!.Enabled = false;
            _daysListBox!.Enabled = false;
            _projectDropDown!.Enabled = false;
            _editProjectBtn!.Enabled = false;
        }

        private void EnableMostControls()
        {
            _logWorkBtn!.Enabled = days.Count > 0 && _daysListBox!.SelectedIndex != -1;
            _statsBtn!.Enabled = _projectDropDown!.Items.Count > 1;
            _terminalBtn!.Enabled = true;
            _settingsBtn!.Enabled = true;

            _refreshBtn!.Enabled = _projectDropDown.Items.Count > 1;
            _editTimeBtn!.Enabled = days.Count > 0 && _daysListBox!.SelectedIndex != -1;
            _removeBtn!.Enabled = days.Count > 0 && _daysListBox!.SelectedIndex != -1;
            _addBtn!.Enabled = _projectDropDown.Items.Count > 1;

            _prevMonthBtn!.Enabled = previousDate != null;
            _nextMonthBtn!.Enabled = nextDate != null;

            _daysListBox!.Enabled = true;
            _projectDropDown.Enabled = true;
            _editProjectBtn!.Enabled = _projectDropDown.Items.Count > 1;
        }

        private void Start()
        {
            timerState = TimerState.Starting;
            _startButton!.Enabled = false;

            SelectToday();

            timerThreadShouldStop = false;
            timerThread = new Thread(TimerThreadRun);
            timerThread.Start();

            _startButton.Text = "Stop";
            _startButton.Image = _iconStop;
            _startButton.Enabled = true;

            DisableMostControls();

            timerState = TimerState.Stop;

            UpdateTaskbar();
            UpdateTrayIconImage();
        }

        private void Stop()
        {
            timerState = TimerState.Stopping;
            _startButton!.Enabled = false;

            timerThreadShouldStop = true;

            Task.Run(() =>
            {
                if (timerThread != null)
                {
                    while (timerThread.IsAlive)
                    {
                        Thread.Sleep(1);
                    }
                }

                Application.Instance.Invoke(() =>
                {
                    timerState = TimerState.Start;

                    long baseTime = DB.SelectLoggedTime(context, timerDate) ?? 0;
                    dayBaseTime = baseTime * TimeSpan.TicksPerMillisecond;

                    UpdateTimer(dayBaseTime / TimeSpan.TicksPerMillisecond);

                    _startButton.Text = "Start";
                    _startButton.Image = _iconStart;
                    _startButton.Enabled = true;

                    EnableMostControls();
                    UpdateTaskbar();
                    UpdateTrayIconImage();
                });

                if (Config.FreeMemoryWhenStopping)
                {
                    GC.Collect();
                }

                if (_isQuitting)
                {
                    Application.Instance.Quit();
                }
            });
        }

        private void UpdateTimer(long ms)
        {
            long hours = ms / 3600000;
            ms %= 3600000;

            long minutes = ms / 60000;
            ms %= 60000;

            long seconds = ms / 1000;
            ms %= 1000;

            _timerMainLabel!.Text = $"{hours:D2}:{minutes:D2}";
            _timerSecondaryLabel!.Text = $"{seconds:D2}.{ms / 10:D2}";
        }

        private void TimerThreadRun()
        {
            long checkpoint = DateTime.Now.Ticks;
            long time;
            DateTime last = DateTime.Now;

            while (!timerThreadShouldStop)
            {
                DateTime current = DateTime.Now;

                if (last.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture) != current.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture))
                {
                    long elapsed = dayBaseTime + last.Ticks - dayCurrentStartTime;
                    DB.UpdateLoggedTime(context, elapsed / TimeSpan.TicksPerMillisecond, timerDate);

                    Application.Instance.Invoke(() =>
                    {
                        SelectToday();
                    });

                    checkpoint = current.Ticks;
                }
                else if (last > current)
                {
                    long elapsed = dayBaseTime + last.Ticks - dayCurrentStartTime;
                    DB.UpdateLoggedTime(context, elapsed / TimeSpan.TicksPerMillisecond, timerDate);

                    dayBaseTime = elapsed;
                    dayCurrentStartTime = current.Ticks;
                    checkpoint = current.Ticks;
                }

                time = dayBaseTime + current.Ticks - dayCurrentStartTime;

                if (!Config.DisableDynamicGuiUpdates || IsWindowFocused())
                {
                    Application.Instance.Invoke(() =>
                    {
                        UpdateTimer(time / TimeSpan.TicksPerMillisecond);
                    });
                }

                if ((current.Ticks - checkpoint) / TimeSpan.TicksPerSecond >= Config.DatabaseUpdateFrequency)
                {
                    DB.UpdateLoggedTime(context, time / TimeSpan.TicksPerMillisecond, timerDate);
                    checkpoint = current.Ticks;
                }

                last = current;
                Thread.Sleep(10);
            }

            time = dayBaseTime + DateTime.Now.Ticks - dayCurrentStartTime;
            DB.UpdateLoggedTime(context, time / TimeSpan.TicksPerMillisecond, timerDate);
        }

        private void LogWorkClick()
        {
            if (_daysListBox!.SelectedIndex == -1 || days.Count <= _daysListBox.SelectedIndex) return;
            string date = days[_daysListBox.SelectedIndex];
            var logForm = new LogWorkForm(DB.SelectLog(context, date) ?? "", date);
            if (ShowDialogHelper(logForm))
            {
                try
                {
                    DB.UpdateLog(context, logForm.Log, date);
                    UpdateLogWork();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Failed to log work.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                }
            }
        }

        private void StatsClick()
        {
            var statsForm = new StatsForm(context);
            ShowDialogHelper(statsForm);
        }

        private void TerminalClick()
        {
            var consoleForm = new ConsoleForm();
            ShowDialogHelper(consoleForm);
        }

        private void SettingsClick()
        {
            string oldDbPath = Config.DatabasePath;
            bool failed = false;

            do
            {
                var settingsForm = new SettingsForm();
                if (ShowDialogHelper(settingsForm))
                {
                    OnSettingsChanged();

                    if (Config.DatabasePath != oldDbPath || failed)
                    {
                        try
                        {
                            DB.Initialize();
                            ReloadContexts();
                            failed = false;
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(this, $"Failed to initialize database path.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                            failed = true;
                        }
                    }
                }
                else
                {
                    break;
                }
            } while (failed);

            if (failed)
            {
                Close();
            }
        }

        private void StartButtonClick()
        {
            if (timerState == TimerState.Start)
            {
                Start();
            }
            else if (timerState == TimerState.Stop)
            {
                Stop();
            }
        }

        private void _prevMonthBtn_Click()
        {
            if (previousDate != null)
            {
                LoadDay(previousDate);
            }
        }

        private void _nextMonthBtn_Click()
        {
            if (nextDate != null)
            {
                LoadDay(nextDate);
            }
        }

        private void RefreshClick()
        {
            ReloadContexts(context);
        }

        private void EditTimeClick()
        {
            if (_daysListBox!.SelectedIndex == -1 || days.Count <= _daysListBox.SelectedIndex) return;
            string date = days[_daysListBox.SelectedIndex];
            long currentLogged = DB.SelectLoggedTime(context, date) ?? 0;

            var editForm = new EditEntryForm(currentLogged);
            if (ShowDialogHelper(editForm))
            {
                try
                {
                    DB.UpdateLoggedTime(context, editForm.LoggedTime, date);
                    OnSelectEntry(date);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Failed to edit entry.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                }
            }
        }

        private void RemoveClick()
        {
            if (_daysListBox!.SelectedIndex == -1 || days.Count <= _daysListBox.SelectedIndex) return;
            string entryDate = days[_daysListBox.SelectedIndex];

            var result = MessageBox.Show(this, $"Are you sure you want to delete the entry for {entryDate}?", "devtime warning", MessageBoxButtons.YesNo, MessageBoxType.Warning);
            if (result == DialogResult.Yes)
            {
                try
                {
                    DB.DeleteEntry(context, entryDate);
                    ReloadContext();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Failed to delete entry from database.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                }
            }
        }

        private void AddClick()
        {
            var addForm = new AddEntryForm(context);
            if (ShowDialogHelper(addForm))
            {
                try
                {
                    string dateStr = addForm.Date.ToString("yyyy-MM-dd");
                    DB.InsertEntry(context, dateStr, addForm.LoggedTime, null);
                    LoadDay(dateStr);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Failed to add entry.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                }
            }
        }

        private void EditProjectClick()
        {
            if (_projectDropDown!.SelectedIndex == -1 || _projectDropDown.SelectedIndex == _projectDropDown.Items.Count - 1) return;

            var editForm = new EditContextForm(context);
            var result = ShowDialogHelper(editForm);

            if (result == EditContextResult.Save && editForm.NewName != null)
            {
                try
                {
                    if (context == editForm.NewName) return;
                    DB.RenameTable(context, editForm.NewName);
                    context = editForm.NewName;
                    ReloadContexts(context);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Failed to rename project.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                }
            }
            else if (result == EditContextResult.Delete)
            {
                try
                {
                    DB.DropTable(context);
                    ReloadContexts();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Failed to delete project.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                }
            }
        }

        private void ProjectDropDown_SelectedIndexChanged(object? sender, EventArgs e)
        {
            if (_projectDropDown!.SelectedIndex == -1) return;

            if (_projectDropDown.SelectedIndex == _projectDropDown.Items.Count - 1)
            {
                var addForm = new AddContextForm();
                if (ShowDialogHelper(addForm) && addForm.ContextName != null)
                {
                    try
                    {
                        DB.CreateTable(addForm.ContextName);
                        ReloadContexts(addForm.ContextName);
                        return;
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(this, $"Failed to create project table.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                    }
                }

                int found = -1;
                for (int i = 0; i < _projectDropDown.Items.Count; i++)
                {
                    if (_projectDropDown.Items[i].Text == context)
                    {
                        found = i;
                        break;
                    }
                }
                _projectDropDown.SelectedIndex = found;
            }
            else
            {
                try
                {
                    LoadContext(_projectDropDown.Items[_projectDropDown.SelectedIndex].Text);
                }
                catch
                {
                    int found = -1;
                    for (int i = 0; i < _projectDropDown.Items.Count; i++)
                    {
                        if (_projectDropDown.Items[i].Text == context)
                        {
                            found = i;
                            break;
                        }
                    }
                    _projectDropDown.SelectedIndex = found;
                }
            }

            Config.LastSelectedProject = context;
            Config.Save();
        }

        private void DaysListBox_SelectedIndexChanged(object? sender, EventArgs e)
        {
            if (initialized && timerState == TimerState.Start)
            {
                if (_daysListBox!.SelectedIndex != -1 && days.Count > _daysListBox.SelectedIndex)
                {
                    OnSelectEntry(days[_daysListBox.SelectedIndex]);
                }
            }
        }

        private bool IsWayland()
        {
            try
            {
                var xdg = Environment.GetEnvironmentVariable("XDG_SESSION_TYPE");
                if (string.Equals(xdg, "wayland", StringComparison.OrdinalIgnoreCase))
                    return true;

                var waylandDisplay = Environment.GetEnvironmentVariable("WAYLAND_DISPLAY");
                return !string.IsNullOrEmpty(waylandDisplay);
            }
            catch
            {
                return false;
            }
        }

        private void SetMacDockIconVisible(bool visible)
        {
            try
            {
                Type? appType = null;
                Type? policyEnumType = null;

                foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
                {
                    string name = asm.FullName ?? "";
                    if (name.Contains("MonoMac") || name.Contains("Eto.Mac"))
                    {
                        try
                        {
                            var t = asm.GetType("MonoMac.AppKit.NSApplication");
                            if (t != null)
                            {
                                appType = t;
                            }
                            var p = asm.GetType("MonoMac.AppKit.NSApplicationActivationPolicy");
                            if (p != null)
                            {
                                policyEnumType = p;
                            }
                        }
                        catch { }
                    }
                }

                if (appType == null)
                {
                    appType = Type.GetType("MonoMac.AppKit.NSApplication, MonoMac")
                              ?? Type.GetType("AppKit.NSApplication, Xamarin.Mac")
                              ?? Type.GetType("AppKit.NSApplication, Microsoft.macOS")
                              ?? Type.GetType("AppKit.NSApplication");
                }

                if (policyEnumType == null)
                {
                    policyEnumType = Type.GetType("MonoMac.AppKit.NSApplicationActivationPolicy, MonoMac")
                                     ?? Type.GetType("AppKit.NSApplicationActivationPolicy, Xamarin.Mac")
                                     ?? Type.GetType("AppKit.NSApplicationActivationPolicy, Microsoft.macOS")
                                     ?? Type.GetType("AppKit.NSApplicationActivationPolicy");
                }

                if (appType != null && policyEnumType != null)
                {
                    var sharedAppProp = appType.GetProperty("SharedApplication", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
                    if (sharedAppProp != null)
                    {
                        var sharedApp = sharedAppProp.GetValue(null);
                        if (sharedApp != null)
                        {
                            var policyProp = sharedApp.GetType().GetProperty("ActivationPolicy");
                            if (policyProp != null)
                            {
                                string policyName = visible ? "Regular" : "Accessory";
                                var policyValue = Enum.Parse(policyEnumType, policyName);
                                policyProp.SetValue(sharedApp, policyValue);
                            }

                            if (visible)
                            {
                                var activateMethod = sharedApp.GetType().GetMethod("Activate", new Type[] { typeof(bool) });
                                if (activateMethod != null)
                                {
                                    activateMethod.Invoke(sharedApp, new object[] { true });
                                }
                            }
                        }
                    }
                }
            }
            catch { }
        }

        private void OnWindowStateChanged(object? sender, EventArgs e)
        {
            if (WindowState == WindowState.Minimized)
            {
                if (Config.MinimizeToTray)
                {
                    ShowTrayIcon();
                    if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
                    {
                        Application.Instance.AsyncInvoke(() =>
                        {
                            SetMacDockIconVisible(false);
                        });
                    }
                    else
                    {
                        Visible = false;
                        if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Linux) && !IsWayland())
                        {
                            WindowState = WindowState.Normal;
                        }
                    }
                }
            }
        }

        private void ShowTrayIcon()
        {
            if (_trayIndicator == null)
            {
                _trayIndicator = new TrayIndicator
                {
                    Title = "devtime"
                };

                _trayIndicator.Activated += (s, e) =>
                {
                    Application.Instance.AsyncInvoke(() =>
                    {
                        RestoreWindow();
                    });
                };

                var menu = new ContextMenu();

                var restoreItem = new ButtonMenuItem { Text = "Restore" };
                restoreItem.Click += (s, e) => RestoreWindow();

                var quitItem = new ButtonMenuItem { Text = "Quit" };
                quitItem.Click += (s, e) =>
                {
                    _isQuitting = true;
                    if (timerState == TimerState.Stop)
                    {
                        Stop();
                    }
                    else
                    {
                        Application.Instance.Quit();
                    }
                };

                menu.Items.Add(restoreItem);
                menu.Items.Add(quitItem);
                _trayIndicator.Menu = menu;
            }

            UpdateTrayIconImage();
            _trayIndicator.Show();
        }

        private void HideTrayIcon()
        {
            if (_trayIndicator != null)
            {
                _trayIndicator.Hide();
            }
        }

        private Bitmap? GetTrayImage(TaskbarColor color)
        {
            switch (color)
            {
                case TaskbarColor.Green:
                    return _iconTrayGreen;
                case TaskbarColor.Red:
                    return _iconTrayRed;
                case TaskbarColor.Yellow:
                    return _iconTrayYellow;
                case TaskbarColor.None:
                default:
                    return _iconTrayDefault;
            }
        }

        private void UpdateTrayIconImage()
        {
            if (_trayIndicator != null)
            {
                var color = (timerState == TimerState.Start) ? Config.StoppedTimerColor : Config.RunningTimerColor;
                _trayIndicator.Image = GetTrayImage(color);
            }
        }

        private void RestoreWindow()
        {
            if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
            {
                SetMacDockIconVisible(true);
                if (WindowState == WindowState.Minimized)
                {
                    WindowState = WindowState.Normal;
                }
                else
                {
                    Visible = true;
                    ActivateMacWindow();
                }
            }
            else if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Linux) && !IsWayland())
            {
                Visible = true;
                BringToFront();
            }
            else
            {
                WindowState = WindowState.Normal;
                Visible = true;
                BringToFront();
            }
            HideTrayIcon();
        }

        private void ActivateMacWindow()
        {
            try
            {
                Type? appType = null;
                foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
                {
                    string name = asm.FullName ?? "";
                    if (name.Contains("MonoMac") || name.Contains("Eto.Mac"))
                    {
                        try
                        {
                            var t = asm.GetType("MonoMac.AppKit.NSApplication");
                            if (t != null)
                            {
                                appType = t;
                            }
                        }
                        catch { }
                    }
                }

                if (appType == null)
                {
                    appType = Type.GetType("MonoMac.AppKit.NSApplication, MonoMac")
                              ?? Type.GetType("AppKit.NSApplication, Xamarin.Mac")
                              ?? Type.GetType("AppKit.NSApplication, Microsoft.macOS")
                              ?? Type.GetType("AppKit.NSApplication");
                }

                if (appType != null)
                {
                    var sharedAppProp = appType.GetProperty("SharedApplication", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
                    if (sharedAppProp != null)
                    {
                        var sharedApp = sharedAppProp.GetValue(null);
                        if (sharedApp != null)
                        {
                            var activateMethod = sharedApp.GetType().GetMethod("Activate", new Type[] { typeof(bool) })
                                                 ?? sharedApp.GetType().GetMethod("ActivateIgnoringOtherApps", new Type[] { typeof(bool) });
                            if (activateMethod != null)
                            {
                                activateMethod.Invoke(sharedApp, new object[] { true });
                            }
                        }
                    }
                }

                var nativeWindow = this.ControlObject;
                if (nativeWindow != null)
                {
                    var nsObjectType = Type.GetType("MonoMac.Foundation.NSObject, MonoMac") ?? typeof(object);
                    var makeKeyMethod = nativeWindow.GetType().GetMethod("MakeKeyAndOrderFront", new Type[] { nsObjectType });
                    if (makeKeyMethod != null)
                    {
                        makeKeyMethod.Invoke(nativeWindow, new object[] { null! });
                    }

                    var orderFrontMethod = nativeWindow.GetType().GetMethod("OrderFrontRegardless");
                    if (orderFrontMethod != null)
                    {
                        orderFrontMethod.Invoke(nativeWindow, null);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception in ActivateMacWindow: {ex}");
            }
        }

        private void StartHook()
        {
            try
            {
                _hook = new TaskPoolGlobalHook();
                _hook.KeyPressed += OnKeyPressed;
                _hook.RunAsync();
                Console.WriteLine("Global hotkey hook started successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to start global hook: {ex}");
            }
        }

        private void StopHook()
        {
            if (_hook != null)
            {
                _hook.KeyPressed -= OnKeyPressed;
                _hook.Dispose();
                _hook = null;
                Console.WriteLine("Global hotkey hook stopped.");
            }
        }

        private KeyCode? MapHotkeyToKeyCode(Hotkey hotkey)
        {
            switch (hotkey)
            {
                case Hotkey.F1: return KeyCode.VcF1;
                case Hotkey.F2: return KeyCode.VcF2;
                case Hotkey.F3: return KeyCode.VcF3;
                case Hotkey.F4: return KeyCode.VcF4;
                case Hotkey.F5: return KeyCode.VcF5;
                case Hotkey.F6: return KeyCode.VcF6;
                case Hotkey.F7: return KeyCode.VcF7;
                case Hotkey.F8: return KeyCode.VcF8;
                case Hotkey.F9: return KeyCode.VcF9;
                case Hotkey.F10: return KeyCode.VcF10;
                case Hotkey.F11: return KeyCode.VcF11;
                case Hotkey.F12: return KeyCode.VcF12;
                case Hotkey.MediaPlayPause: return KeyCode.VcMediaPlay;
                default: return null;
            }
        }

        private void OnKeyPressed(object? sender, KeyboardHookEventArgs e)
        {
            var keyCode = e.Data.KeyCode;
            Application.Instance.AsyncInvoke(() =>
            {
                if (_openDialogsCount > 0) return;

                if (timerState == TimerState.Start)
                {
                    var startKey = MapHotkeyToKeyCode(Config.StartHotkey);
                    if (startKey.HasValue && keyCode == startKey.Value && _startButton?.Enabled == true)
                    {
                        Start();
                    }
                }
                else if (timerState == TimerState.Stop)
                {
                    var stopKey = MapHotkeyToKeyCode(Config.StopHotkey);
                    if (stopKey.HasValue && keyCode == stopKey.Value && _startButton?.Enabled == true)
                    {
                        Stop();
                    }
                }
            });
        }

        private void UpdateHookState()
        {
            bool needHook = Config.StartHotkey != Hotkey.None || Config.StopHotkey != Hotkey.None;
            if (needHook)
            {
                if (_hook == null)
                {
                    StartHook();
                }
            }
            else
            {
                if (_hook != null)
                {
                    StopHook();
                }
            }
        }

        private void OnSettingsChanged()
        {
            Config.Save();
            UpdateTaskbar();
            UpdateTrayIconImage();
            UpdateHookState();
        }

        protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
        {
            if (_isQuitting)
            {
                base.OnClosing(e);
                return;
            }

            if (Config.MinimizeToTray)
            {
                e.Cancel = true;
                try
                {
                    ShowTrayIcon();
                    if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
                    {
                        Application.Instance.AsyncInvoke(() =>
                        {
                            Visible = false;
                            SetMacDockIconVisible(false);
                        });
                    }
                    else
                    {
                        Visible = false;
                    }
                }
                catch (Exception ex)
                {
                    e.Cancel = false;
                    Console.WriteLine($"Failed to hide to tray on close: {ex}");
                }
            }
            else
            {
                if (timerState == TimerState.Stop)
                {
                    e.Cancel = true;
                    _isQuitting = true;
                    Stop();
                }
                else
                {
                    base.OnClosing(e);
                }
            }
        }

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);

            Config.LastSelectedProject = context;
            Config.Save();

            timerThreadShouldStop = true;
            if (timerThread != null && timerThread.IsAlive)
            {
                timerThread.Join();
            }

            StopHook();
            HideTrayIcon();
            if (_trayIndicator != null)
            {
                _trayIndicator.Dispose();
                _trayIndicator = null;
            }

            _iconLog?.Dispose();
            _iconLogWarning?.Dispose();
            _iconExport?.Dispose();
            _iconTerminal?.Dispose();
            _iconSettings?.Dispose();
            _iconStart?.Dispose();
            _iconStop?.Dispose();
            _iconAdd?.Dispose();
            _iconRemove?.Dispose();
            _iconEdit?.Dispose();
            _iconEditTime?.Dispose();
            _iconRefresh?.Dispose();
            _iconPrev?.Dispose();
            _iconNext?.Dispose();
            _iconTrayGreen?.Dispose();
            _iconTrayRed?.Dispose();
            _iconTrayYellow?.Dispose();
            _iconTrayDefault?.Dispose();
        }

        private void SubscribeToMacNotifications()
        {
            try
            {
                var notificationCenterType = Type.GetType("MonoMac.Foundation.NSNotificationCenter, MonoMac");
                if (notificationCenterType == null) return;

                var defaultCenterProp = notificationCenterType.GetProperty("DefaultCenter", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
                if (defaultCenterProp == null) return;

                var defaultCenter = defaultCenterProp.GetValue(null);
                if (defaultCenter == null) return;

                var nativeWindow = this.ControlObject;
                if (nativeWindow == null) return;

                var nsNotificationType = Type.GetType("MonoMac.Foundation.NSNotification, MonoMac");
                if (nsNotificationType == null) return;

                var actionType = typeof(Action<>).MakeGenericType(nsNotificationType);
                var handlerMethod = typeof(MainForm).GetMethod("OnMacWindowNotification", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                if (handlerMethod == null) return;

                var handlerDelegate = Delegate.CreateDelegate(actionType, this, handlerMethod);
                var addObserverMethod = defaultCenter.GetType().GetMethod("AddObserver", new Type[] { typeof(string), actionType });
                if (addObserverMethod != null)
                {
                    addObserverMethod.Invoke(defaultCenter, new object[] { "NSWindowWillCloseNotification", handlerDelegate });
                    addObserverMethod.Invoke(defaultCenter, new object[] { "NSWindowDidDeminiaturizeNotification", handlerDelegate });
                }
            }
            catch { }
        }

        private void OnMacWindowNotification(object notification)
        {
            try
            {
                var nameProp = notification.GetType().GetProperty("Name");
                if (nameProp == null) return;
                string? name = nameProp.GetValue(notification) as string;

                var objProp = notification.GetType().GetProperty("Object");
                if (objProp != null)
                {
                    var senderWindow = objProp.GetValue(notification);
                    var nativeWindow = this.ControlObject;
                    if (senderWindow == nativeWindow && nativeWindow != null)
                    {
                        if (name == "NSWindowWillCloseNotification")
                        {
                            Application.Instance.AsyncInvoke(() =>
                            {
                                ShowTrayIcon();
                                SetMacDockIconVisible(false);
                            });
                        }
                        else if (name == "NSWindowDidDeminiaturizeNotification")
                        {
                            Application.Instance.AsyncInvoke(() =>
                            {
                                ActivateMacWindow();
                            });
                        }
                    }
                }
            }
            catch { }
        }
    }
}