Config.cs

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace devtime
{
    public enum TaskbarColor
    {
        None,
        Green,
        Yellow,
        Red
    }

    public enum Hotkey
    {
        None,
        F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
        MediaPlayPause
    }

    public static class Config
    {
        public static uint DatabaseUpdateFrequency { get; set; } = 300;
        public static string DatabasePath { get; set; } = "";
        public static uint DatabaseExportBufferSize { get; set; } = 30;
        public static TaskbarColor StoppedTimerColor { get; set; } = TaskbarColor.None;
        public static TaskbarColor RunningTimerColor { get; set; } = TaskbarColor.Green;
        public static bool MinimizeToTray { get; set; } = false;
        public static Hotkey StartHotkey { get; set; } = Hotkey.None;
        public static Hotkey StopHotkey { get; set; } = Hotkey.None;
        public static bool DisableDynamicGuiUpdates { get; set; } = true;
        public static bool FreeMemoryWhenStopping { get; set; } = false;
        public static string? LastSelectedProject { get; set; } = null;

        static Config()
        {
            // Initialize default DatabasePath based on platform
            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                DatabasePath = Path.Combine(appData, "devtime", "devtime.db");
            }
            else
            {
                DatabasePath = "devtime.db";
            }
        }

        public static string GetDefaultDirectory()
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                return Path.Combine(appData, "devtime");
            }
            else
            {
                return AppDomain.CurrentDomain.BaseDirectory;
            }
        }

        public static string GetDatabaseAbsolutePath()
        {
            string path = DatabasePath;
            if (string.IsNullOrWhiteSpace(path))
            {
                if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                {
                    string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                    path = Path.Combine(appData, "devtime", "devtime.db");
                }
                else
                {
                    path = "devtime.db";
                }
            }

            if (path.StartsWith("~/"))
            {
                string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
                path = Path.Combine(home, path.Substring(2));
            }

            if (!Path.IsPathRooted(path))
            {
                path = Path.Combine(GetDefaultDirectory(), path);
            }

            return Path.GetFullPath(path);
        }

        public static string GetConfigFilePath()
        {
            // INI stored in the same directory as the database
            string dbAbsPath = GetDatabaseAbsolutePath();
            string? dbDir = Path.GetDirectoryName(dbAbsPath);
            if (string.IsNullOrEmpty(dbDir))
            {
                dbDir = GetDefaultDirectory();
            }
            return Path.Combine(dbDir, "devtime.ini");
        }

        public static void Load()
        {
            // We first try to load config from the default directory to bootstrap finding the DB path
            string defaultIni = Path.Combine(GetDefaultDirectory(), "devtime.ini");
            string path = defaultIni;
            
            if (!File.Exists(path))
            {
                // If not found in default directory, check where the DB path resolves to
                string dbIni = Path.Combine(Path.GetDirectoryName(GetDatabaseAbsolutePath()) ?? GetDefaultDirectory(), "devtime.ini");
                if (File.Exists(dbIni))
                {
                    path = dbIni;
                }
                else
                {
                    return; // Use defaults
                }
            }

            try
            {
                var lines = File.ReadAllLines(path);
                foreach (var line in lines)
                {
                    var trimmed = line.Trim();
                    if (trimmed.StartsWith(";") || trimmed.StartsWith("#") || !trimmed.Contains("="))
                        continue;

                    int idx = trimmed.IndexOf('=');
                    string key = trimmed.Substring(0, idx).Trim();
                    string val = trimmed.Substring(idx + 1).Trim();

                    switch (key)
                    {
                        case nameof(DatabaseUpdateFrequency):
                            if (uint.TryParse(val, out uint duf)) DatabaseUpdateFrequency = duf;
                            break;
                        case nameof(DatabasePath):
                            DatabasePath = val;
                            break;
                        case nameof(DatabaseExportBufferSize):
                            if (uint.TryParse(val, out uint deb)) DatabaseExportBufferSize = deb;
                            break;
                        case nameof(StoppedTimerColor):
                            if (Enum.TryParse(val, out TaskbarColor stc)) StoppedTimerColor = stc;
                            break;
                        case nameof(RunningTimerColor):
                            if (Enum.TryParse(val, out TaskbarColor rtc)) RunningTimerColor = rtc;
                            break;
                        case nameof(MinimizeToTray):
                            if (bool.TryParse(val, out bool mtt)) MinimizeToTray = mtt;
                            break;
                        case nameof(StartHotkey):
                            if (Enum.TryParse(val, out Hotkey sh)) StartHotkey = sh;
                            break;
                        case nameof(StopHotkey):
                            if (Enum.TryParse(val, out Hotkey sth)) StopHotkey = sth;
                            break;
                        case nameof(DisableDynamicGuiUpdates):
                            if (bool.TryParse(val, out bool ddg)) DisableDynamicGuiUpdates = ddg;
                            break;
                        case nameof(FreeMemoryWhenStopping):
                            if (bool.TryParse(val, out bool fmw)) FreeMemoryWhenStopping = fmw;
                            break;
                        case nameof(LastSelectedProject):
                            LastSelectedProject = string.IsNullOrEmpty(val) || val == "null" ? null : val;
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error loading config: {ex}");
            }
        }

        public static void Save()
        {
            try
            {
                string path = GetConfigFilePath();
                string? dir = Path.GetDirectoryName(path);
                if (!string.IsNullOrEmpty(dir))
                {
                    Directory.CreateDirectory(dir);
                }

                var sb = new StringBuilder();
                sb.AppendLine("; devtime configuration");
                sb.AppendLine($"{nameof(DatabaseUpdateFrequency)}={DatabaseUpdateFrequency}");
                sb.AppendLine($"{nameof(DatabasePath)}={DatabasePath}");
                sb.AppendLine($"{nameof(DatabaseExportBufferSize)}={DatabaseExportBufferSize}");
                sb.AppendLine($"{nameof(StoppedTimerColor)}={StoppedTimerColor}");
                sb.AppendLine($"{nameof(RunningTimerColor)}={RunningTimerColor}");
                sb.AppendLine($"{nameof(MinimizeToTray)}={MinimizeToTray.ToString().ToLower()}");
                sb.AppendLine($"{nameof(StartHotkey)}={StartHotkey}");
                sb.AppendLine($"{nameof(StopHotkey)}={StopHotkey}");
                sb.AppendLine($"{nameof(DisableDynamicGuiUpdates)}={DisableDynamicGuiUpdates.ToString().ToLower()}");
                sb.AppendLine($"{nameof(FreeMemoryWhenStopping)}={FreeMemoryWhenStopping.ToString().ToLower()}");
                sb.AppendLine($"{nameof(LastSelectedProject)}={(LastSelectedProject ?? "null")}");

                File.WriteAllText(path, sb.ToString());

                // If default path is different, save there too to help bootstrap
                string defaultIni = Path.Combine(GetDefaultDirectory(), "devtime.ini");
                if (defaultIni != path)
                {
                    string? defDir = Path.GetDirectoryName(defaultIni);
                    if (!string.IsNullOrEmpty(defDir))
                    {
                        Directory.CreateDirectory(defDir);
                    }
                    File.WriteAllText(defaultIni, sb.ToString());
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error saving config: {ex}");
            }
        }
    }
}