using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace DeskCore;

public enum DesignMode { System, Light, Dark }
public enum ViewMode { Small, Medium, Large, List }

public class CategoryMeta
{
    public string? Glyph { get; set; }
    public string? Color { get; set; }
    // Die folgenden Box-Felder stammen aus Version 1.0.x und werden nur noch beim Umstieg auf FenceDef gelesen
    public bool Fence { get; set; }
    public double? FenceX { get; set; }
    public double? FenceY { get; set; }
    public double FenceW { get; set; } = 340;
    public double FenceH { get; set; } = 260;
    public bool FenceCollapsed { get; set; }
}

/// <summary>Eine Start-Gruppe: ein Klick startet mehrere Programme nacheinander.</summary>
public class LaunchGroup
{
    public string Name { get; set; } = "";
    /// <summary>Pfade in Startreihenfolge (meist Verknüpfungen aus den Kategorien).</summary>
    public List<string> Items { get; set; } = [];
    /// <summary>Wartezeit zwischen zwei Programmen in Sekunden.</summary>
    public double DelaySeconds { get; set; } = 1;
    public string? Color { get; set; }
}

public class SortRule
{
    /// <summary>"Name" = Name enthält …, "Typ" = Dateityp ist … (z. B. "Bilder" oder "pdf, docx")</summary>
    public string Kind { get; set; } = "Name";
    public string Contains { get; set; } = "";
    public string Category { get; set; } = "";
    [JsonIgnore] public string KindText => Kind == "Typ" ? "Dateityp ist" : "Name enthält";
}

/// <summary>Ein Tab einer Desktop-Box: eine Kategorie, ein beliebiger Ordner ("Ordner-Portal") oder "Zuletzt benutzt".</summary>
public class FenceTab
{
    public const string CategoryKind = "Kategorie", FolderKind = "Ordner", RecentKind = "Zuletzt";
    public string Kind { get; set; } = CategoryKind;
    /// <summary>Kategoriename bzw. Ordnerpfad (bei "Zuletzt benutzt" leer).</summary>
    public string Value { get; set; } = "";
    /// <summary>Eigene Reihenfolge (Dateinamen), wenn die Box nach "Eigene" sortiert ist.</summary>
    public List<string> Order { get; set; } = [];
    [JsonIgnore] public bool IsFolder => Kind == FolderKind;
    [JsonIgnore] public bool IsRecent => Kind == RecentKind;
    [JsonIgnore] public bool IsCategory => Kind == CategoryKind;
    [JsonIgnore] public string Title => IsRecent ? "Zuletzt benutzt"
        : IsFolder ? Path.GetFileName(Value.TrimEnd('\\')) is { Length: > 0 } n ? n : Value : Value;
}

/// <summary>Zusatzeinstellungen einer Desktop-Seite: Zeitplan und Hintergrundbild.</summary>
public class PageOption
{
    /// <summary>Seite automatisch zu bestimmten Zeiten anzeigen.</summary>
    public bool Scheduled { get; set; }
    /// <summary>Wochentage als Bits: Montag = 1, Dienstag = 2 … Sonntag = 64.</summary>
    public int Days { get; set; } = 0b0011111; // Mo–Fr
    public string From { get; set; } = "08:00";
    public string To { get; set; } = "17:00";
    /// <summary>Eigenes Hintergrundbild für diese Seite (null = nicht ändern).</summary>
    public string? Wallpaper { get; set; }

    public static int DayBit(DayOfWeek d) => 1 << (((int)d + 6) % 7); // Montag = Bit 0

    /// <summary>Gilt der Zeitplan zu diesem Zeitpunkt? Zeiträume über Mitternacht (z. B. 22:00–06:00) gehen auch.</summary>
    public bool Matches(DateTime now)
    {
        if (!Scheduled || !TimeSpan.TryParse(From, out var from) || !TimeSpan.TryParse(To, out var to)) return false;
        var t = now.TimeOfDay;
        if (from <= to) return (Days & DayBit(now.DayOfWeek)) != 0 && t >= from && t < to;
        // über Mitternacht: der Tag zählt, an dem der Zeitraum beginnt
        return t >= from ? (Days & DayBit(now.DayOfWeek)) != 0 : t < to && (Days & DayBit(now.AddDays(-1).DayOfWeek)) != 0;
    }
}

/// <summary>Eine Desktop-Box mit Position, Tabs und Aussehen.</summary>
public class FenceDef
{
    public string Id { get; set; } = Guid.NewGuid().ToString("N");
    public List<FenceTab> Tabs { get; set; } = [];
    public int ActiveTab { get; set; }
    public double? X { get; set; }
    public double? Y { get; set; }
    public double W { get; set; } = 340;
    public double H { get; set; } = 260;
    public bool Collapsed { get; set; }
    /// <summary>Gesperrt: nicht verschieb- oder vergrößerbar.</summary>
    public bool Locked { get; set; }
    /// <summary>Hintergrundfarbe (#RRGGBB) oder null = passend zum Design.</summary>
    public string? Background { get; set; }
    /// <summary>Deckkraft des Hintergrunds 0.2–1.</summary>
    public double Opacity { get; set; } = 0.92;
    /// <summary>Milchglas-Effekt (Hintergrund verschwommen).</summary>
    public bool Blur { get; set; }
    public ViewMode IconSize { get; set; } = ViewMode.Medium;
    /// <summary>"Name", "Typ", "Datum", "Häufig" (meistgenutzt zuerst) oder "Eigene" (per Ziehen angeordnet)</summary>
    public string Sort { get; set; } = "Name";
    /// <summary>Icon-Tönung (#RRGGBB) oder null.</summary>
    public string? Tint { get; set; }

    /// <summary>Desktop-Seite, auf der die Box liegt (0 = erste Seite).</summary>
    public int Page { get; set; }

    [JsonIgnore] public FenceTab? Active => Tabs.Count == 0 ? null : Tabs[Math.Clamp(ActiveTab, 0, Tabs.Count - 1)];
}

/// <summary>Gespeicherte Anordnung aller Desktop-Boxen.</summary>
public class FenceSnapshot
{
    public string Name { get; set; } = "";
    public DateTime Created { get; set; } = DateTime.Now;
    public List<FenceDef> Fences { get; set; } = [];
    [JsonIgnore] public string Info => $"{Fences.Count} {(Fences.Count == 1 ? "Box" : "Boxen")} · gespeichert am {Created:dd.MM.yyyy HH:mm}";
}

/// <summary>Alle Einstellungen, gespeichert in %APPDATA%\DeskCore\settings.json.</summary>
public class AppSettings
{
    public DesignMode Design { get; set; } = DesignMode.System;
    public ViewMode View { get; set; } = ViewMode.Medium;

    public bool TrayEnabled { get; set; } = true;
    public bool CloseToTray { get; set; } = true;
    public bool TrayHintShown { get; set; }

    public bool HotkeyEnabled { get; set; } = true;
    public int HotkeyModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
    public int HotkeyKey { get; set; } = 0x44; // D

    public bool AutoSort { get; set; }
    public bool AutoSortRemoveFromDesktop { get; set; }
    public List<SortRule> Rules { get; set; } = [];

    public bool FencesEnabled { get; set; } = true;
    public List<FenceDef> Fences { get; set; } = [];
    public List<FenceSnapshot> Snapshots { get; set; } = [];
    /// <summary>Box-Positionen je Bildschirm-Anordnung (Signatur → Box-Id → x, y, w, h).</summary>
    public Dictionary<string, Dictionary<string, double[]>> ScreenLayouts { get; set; } = [];
    /// <summary>Chamäleon: Boxen blenden sich aus, bis die Maus darüberfährt.</summary>
    public bool FenceChameleon { get; set; }
    /// <summary>Doppelklick auf eine freie Desktop-Stelle blendet Icons und Boxen aus/ein.</summary>
    public bool QuickHide { get; set; } = true;
    /// <summary>Peek: Tastenkürzel holt alle Boxen vor die Fenster.</summary>
    public bool PeekEnabled { get; set; } = true;
    public int PeekModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
    public int PeekKey { get; set; } = 0x42; // B wie "Boxen"

    /// <summary>Desktop-Seiten: jede Seite hat ihre eigenen Boxen.</summary>
    public List<string> Pages { get; set; } = ["Seite 1"];
    public int CurrentPage { get; set; }
    /// <summary>Mausrad über einer freien Desktop-Stelle wechselt die Seite.</summary>
    public bool PageWheel { get; set; } = true;
    /// <summary>Zeitplan und Hintergrundbild je Seite (Schlüssel = Seitenname).</summary>
    public Dictionary<string, PageOption> PageOptions { get; set; } = new(StringComparer.OrdinalIgnoreCase);
    /// <summary>Seite, die außerhalb aller Zeitpläne angezeigt wird (null = keine).</summary>
    public string? PageFallback { get; set; }
    /// <summary>Hintergrundbild, das vor dem ersten Seiten-Hintergrund eingestellt war (zum Zurückholen).</summary>
    public string? SavedWallpaper { get; set; }

    /// <summary>Schnellstart-Suche per Tastenkürzel.</summary>
    public bool QuickSearchEnabled { get; set; } = true;
    public int QuickSearchModifiers { get; set; } = Hotkey.ModAlt | Hotkey.ModShift;
    public int QuickSearchKey { get; set; } = 0x20; // Leertaste
    /// <summary>Programme aus dem Windows-Startmenü mit durchsuchen.</summary>
    public bool QuickSearchStartMenu { get; set; } = true;

    /// <summary>Sortierung im Hauptfenster: "Name" oder "Häufig".</summary>
    public string MainSort { get; set; } = "Name";

    /// <summary>Rechte Maustaste auf freier Desktop-Fläche ziehen → neue Box.</summary>
    public bool DrawFences { get; set; } = true;

    /// <summary>Tönung der echten Desktop-Icons (#RRGGBB) oder null = aus.</summary>
    public string? DesktopTint { get; set; }
    public double DesktopTintStrength { get; set; } = 0.55;

    /// <summary>Verknüpfungen zu deinstallierten Programmen automatisch entfernen.</summary>
    public bool RemoveDeadShortcuts { get; set; } = true;
    /// <summary>Tote Verknüpfungen, die der Nutzer per Rückgängig behalten wollte.</summary>
    public List<string> KeptShortcuts { get; set; } = [];

    // Fenster merken (WPF-Einheiten)
    public double? WindowLeft { get; set; }
    public double? WindowTop { get; set; }
    public double? WindowWidth { get; set; }
    public double? WindowHeight { get; set; }
    public bool WindowMaximized { get; set; }

    // Updates
    public bool AutoUpdateCheck { get; set; } = true;
    public DateTime? LastUpdateCheck { get; set; }
    public string? SkippedVersion { get; set; }

    public List<string> CategoryOrder { get; set; } = [];
    public List<LaunchGroup> LaunchGroups { get; set; } = [];
    public Dictionary<string, CategoryMeta> Categories { get; set; } = new(StringComparer.OrdinalIgnoreCase);

    // ---------- Laden/Speichern ----------

    public static readonly string Folder = Migration.Pick(Environment.SpecialFolder.ApplicationData);
    private static readonly string FilePath = Path.Combine(Folder, "settings.json");

    public static readonly JsonSerializerOptions Json = new()
    {
        WriteIndented = true,
        Converters = { new JsonStringEnumConverter() },
    };

    public static AppSettings Current { get; private set; } = Load();

    public static event Action? Saved;

    private static AppSettings Load()
    {
        AppSettings s;
        try
        {
            s = File.Exists(FilePath)
                ? JsonSerializer.Deserialize<AppSettings>(File.ReadAllText(FilePath), Json) ?? new()
                : new();
        }
        catch { s = new(); }

        s.Categories = new(s.Categories ?? [], StringComparer.OrdinalIgnoreCase);
        s.Rules ??= [];
        s.CategoryOrder ??= [];
        s.KeptShortcuts ??= [];
        s.LaunchGroups ??= [];
        s.Fences ??= [];
        s.Snapshots ??= [];
        s.ScreenLayouts ??= [];
        s.PageOptions = new(s.PageOptions ?? [], StringComparer.OrdinalIgnoreCase);
        foreach (var t in s.Fences.SelectMany(f => f.Tabs)) t.Order ??= [];
        if (s.Pages is null || s.Pages.Count == 0) s.Pages = ["Seite 1"];
        s.CurrentPage = Math.Clamp(s.CurrentPage, 0, s.Pages.Count - 1);

        // Umstieg von 1.0.x: Box gehörte fest zu einer Kategorie → eigenständige Box mit einem Tab
        foreach (var (name, meta) in s.Categories)
        {
            if (!meta.Fence) continue;
            s.Fences.Add(new FenceDef
            {
                Tabs = [new FenceTab { Value = name }],
                X = meta.FenceX, Y = meta.FenceY, W = meta.FenceW, H = meta.FenceH, Collapsed = meta.FenceCollapsed,
            });
            meta.Fence = false;
        }

        // Übernahme der alten Einstellung aus Version 2
        var old = Path.Combine(Folder, "design.txt");
        if (File.Exists(old))
        {
            try
            {
                var v = File.ReadAllText(old).Trim();
                s.Design = v == "Light" ? DesignMode.Light : v == "Dark" ? DesignMode.Dark : DesignMode.System;
                File.Delete(old);
            }
            catch { }
        }
        return s;
    }

    public void Save()
    {
        try
        {
            Directory.CreateDirectory(Folder);
            File.WriteAllText(FilePath, JsonSerializer.Serialize(this, Json));
        }
        catch { }
        Saved?.Invoke();
    }

    public CategoryMeta Meta(string category)
    {
        if (!Categories.TryGetValue(category, out var m))
            Categories[category] = m = new CategoryMeta();
        return m;
    }

    public void RenameCategory(string oldName, string newName)
    {
        if (Categories.Remove(oldName, out var m)) Categories[newName] = m;
        for (int i = 0; i < CategoryOrder.Count; i++)
            if (string.Equals(CategoryOrder[i], oldName, StringComparison.OrdinalIgnoreCase)) CategoryOrder[i] = newName;
        foreach (var r in Rules)
            if (string.Equals(r.Category, oldName, StringComparison.OrdinalIgnoreCase)) r.Category = newName;
        foreach (var t in Fences.SelectMany(f => f.Tabs))
            if (!t.IsFolder && string.Equals(t.Value, oldName, StringComparison.OrdinalIgnoreCase)) t.Value = newName;
        // Start-Gruppen zeigen auf Dateien in der Kategorie → Pfade mit umbenennen
        var oldDir = Storage.CategoryPath(oldName).TrimEnd('\\') + "\\";
        var newDir = Storage.CategoryPath(newName).TrimEnd('\\') + "\\";
        foreach (var g in LaunchGroups)
            for (int i = 0; i < g.Items.Count; i++)
                if (g.Items[i].StartsWith(oldDir, StringComparison.OrdinalIgnoreCase))
                    g.Items[i] = newDir + g.Items[i][oldDir.Length..];
    }

    /// <summary>Liegt diese Kategorie auf der gerade angezeigten Desktop-Seite in einer Box?</summary>
    public bool HasFence(string category) =>
        Fences.Any(f => f.Page == CurrentPage &&
                        f.Tabs.Any(t => t.IsCategory && string.Equals(t.Value, category, StringComparison.OrdinalIgnoreCase)));

    /// <summary>Kategorie auf der aktuellen Seite als eigene Box anzeigen bzw. von dieser Seite entfernen (andere Seiten bleiben).</summary>
    public void SetFence(string category, bool on)
    {
        if (on)
        {
            if (!HasFence(category)) Fences.Add(new FenceDef { Page = CurrentPage, Tabs = [new FenceTab { Value = category }] });
            FencesEnabled = true;
        }
        else
        {
            foreach (var f in Fences.Where(f => f.Page == CurrentPage))
                f.Tabs.RemoveAll(t => t.IsCategory && string.Equals(t.Value, category, StringComparison.OrdinalIgnoreCase));
            Fences.RemoveAll(f => f.Tabs.Count == 0);
        }
    }

    /// <summary>Tiefe Kopie (für Snapshots).</summary>
    public static List<FenceDef> CloneFences(List<FenceDef> fences) =>
        JsonSerializer.Deserialize<List<FenceDef>>(JsonSerializer.Serialize(fences, Json), Json) ?? [];

    /// <summary>Datei wurde umbenannt/verschoben → Start-Gruppen zeigen auf den neuen Pfad.</summary>
    public void ReplaceLaunchPath(string oldPath, string newPath)
    {
        bool changed = false;
        foreach (var g in LaunchGroups)
            for (int i = 0; i < g.Items.Count; i++)
                if (string.Equals(g.Items[i], oldPath, StringComparison.OrdinalIgnoreCase)) { g.Items[i] = newPath; changed = true; }
        // Umbenannt im selben Ordner → Platz in der eigenen Box-Reihenfolge behalten
        if (Storage.SamePath(Path.GetDirectoryName(oldPath), Path.GetDirectoryName(newPath)))
        {
            string oldName = Path.GetFileName(oldPath), newName = Path.GetFileName(newPath);
            foreach (var t in Fences.SelectMany(f => f.Tabs))
                for (int i = 0; i < t.Order.Count; i++)
                    if (string.Equals(t.Order[i], oldName, StringComparison.OrdinalIgnoreCase)) { t.Order[i] = newName; changed = true; }
        }
        Usage.Rename(oldPath, newPath);
        if (changed) Save();
    }

    // ---------- Desktop-Seiten ----------

    public PageOption PageOption(string page)
    {
        if (!PageOptions.TryGetValue(page, out var o)) PageOptions[page] = o = new PageOption();
        return o;
    }

    public void RenamePage(int index, string newName)
    {
        var old = Pages[index];
        Pages[index] = newName;
        if (PageOptions.Remove(old, out var o)) PageOptions[newName] = o;
        if (string.Equals(PageFallback, old, StringComparison.OrdinalIgnoreCase)) PageFallback = newName;
    }

    /// <summary>Aufräumen nach dem Löschen einer Seite (Boxen verschiebt der FenceManager).</summary>
    public void ForgetPage(string name)
    {
        PageOptions.Remove(name);
        if (string.Equals(PageFallback, name, StringComparison.OrdinalIgnoreCase)) PageFallback = null;
    }

    public void RemoveCategory(string name)
    {
        foreach (var f in Fences)
            f.Tabs.RemoveAll(t => !t.IsFolder && string.Equals(t.Value, name, StringComparison.OrdinalIgnoreCase));
        Fences.RemoveAll(f => f.Tabs.Count == 0);
        Categories.Remove(name);
        CategoryOrder.RemoveAll(n => string.Equals(n, name, StringComparison.OrdinalIgnoreCase));
        Rules.RemoveAll(r => string.Equals(r.Category, name, StringComparison.OrdinalIgnoreCase));
    }
}