MainWindow.xaml.cs

using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;
using WindowManager.Services;

namespace WindowManager;

public partial class MainWindow : Window
{
    private sealed class LayoutCard
    {
        public required Layout Layout { get; init; }
        public required string Info { get; init; }
        public required string Tooltip { get; init; }
        public string Name => Layout.Name;
    }

    private readonly DispatcherTimer _statusTimer;
    private readonly DispatcherTimer _deleteTimer;
    private Layout? _pendingDelete;
    private Layout? _renameTarget;
    private bool _initialized;

    public MainWindow()
    {
        InitializeComponent();

        _statusTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(5) };
        _statusTimer.Tick += (_, _) => { StatusText.Visibility = Visibility.Collapsed; _statusTimer.Stop(); };
        _deleteTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(4) };
        _deleteTimer.Tick += (_, _) => { _pendingDelete = null; _deleteTimer.Stop(); };

        App.Store.Changed += () => Dispatcher.Invoke(Refresh);
        SettingsStore.Changed += () => Dispatcher.Invoke(Refresh);
        Refresh();

        AutostartBox.IsChecked = Autostart.IsEnabled();
        HotkeysBox.IsChecked = SettingsStore.Current.HotkeysEnabled;
        LaunchMissingBox.IsChecked = SettingsStore.Current.LaunchMissingApps;
        _initialized = true;
    }

    private void Refresh()
    {
        bool hotkeys = SettingsStore.Current.HotkeysEnabled;
        LayoutsList.ItemsSource = App.Store.Layouts.Select((l, i) =>
        {
            string info = $"{l.Windows.Count} {WindowService.WindowsWord(l.Windows.Count)}";
            if (hotkeys && i < 9) info += $"  ·  Ctrl+Alt+{i + 1}";

            var lines = l.Windows.Take(12).Select(w => $"• {w.ProcessName} — {Truncate(w.TitleHint, 58)}");
            string tip = L.SavedAtPrefix(l.SavedAt) + "\n" + string.Join("\n", lines);
            if (l.Windows.Count > 12) tip += "\n" + L.AndMore(l.Windows.Count - 12);

            return new LayoutCard { Layout = l, Info = info, Tooltip = tip };
        }).ToList();
        EmptyState.Visibility = App.Store.Layouts.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
    }

    private static string Truncate(string s, int max) =>
        s.Length <= max ? s : s[..(max - 1)] + "…";

    private void ShowStatus(string message)
    {
        StatusText.Text = message;
        StatusText.Visibility = Visibility.Visible;
        _statusTimer.Stop();
        _statusTimer.Start();
    }

    // --- zapis nowego układu / zmiana nazwy ---

    private void Save_Click(object sender, RoutedEventArgs e)
    {
        _renameTarget = null;
        NamePanel.Visibility = Visibility.Visible;
        NameBox.Text = L.DefaultLayoutName(App.Store.Layouts.Count + 1);
        NameBox.SelectAll();
        NameBox.Focus();
    }

    private void StartRename(Layout layout)
    {
        _renameTarget = layout;
        NamePanel.Visibility = Visibility.Visible;
        NameBox.Text = layout.Name;
        NameBox.SelectAll();
        NameBox.Focus();
    }

    private void NameBox_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
    {
        if (e.Key == Key.Enter) ConfirmName();
        else if (e.Key == Key.Escape) NamePanel.Visibility = Visibility.Collapsed;
    }

    private void ConfirmSave_Click(object sender, RoutedEventArgs e) => ConfirmName();

    private void ConfirmName()
    {
        string name = NameBox.Text.Trim();
        if (name.Length == 0) return;

        if (_renameTarget is { } target)
        {
            App.Store.Rename(target, name);
            _renameTarget = null;
            NamePanel.Visibility = Visibility.Collapsed;
            ShowStatus(L.RenamedTo(name));
            return;
        }

        var layout = WindowService.Capture(name);
        if (layout.Windows.Count == 0)
        {
            ShowStatus(L.NoWindowsToSave);
            return;
        }

        App.Store.Add(layout);
        NamePanel.Visibility = Visibility.Collapsed;
        ShowStatus(L.SavedLayout(name, layout.Windows.Count));
    }

    // --- akcje na kartach ---

    private static Layout? LayoutOf(object sender) =>
        (sender as FrameworkElement)?.DataContext is LayoutCard card ? card.Layout : null;

    private void Card_Click(object sender, MouseButtonEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) ApplyLayout(layout);
    }

    private void Apply_Click(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) ApplyLayout(layout);
    }

    private async void ApplyLayout(Layout layout)
    {
        try
        {
            var result = await WindowService.ApplyAsync(layout, SettingsStore.Current.LaunchMissingApps,
                msg => Dispatcher.Invoke(() => ShowStatus(msg)));
            ShowStatus(WindowService.Describe(layout, result));
        }
        catch (Exception ex)
        {
            Log.Write("Błąd przywracania układu: " + ex);
            ShowStatus(L.ApplyFailed);
        }
    }

    private void Overwrite_Click(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) OverwriteLayout(layout);
    }

    private void OverwriteLayout(Layout layout)
    {
        var captured = WindowService.Capture(layout.Name);
        if (captured.Windows.Count == 0)
        {
            ShowStatus(L.NoWindowsToSave);
            return;
        }
        layout.Windows = captured.Windows;
        layout.SavedAt = captured.SavedAt;
        layout.MonitorSignature = captured.MonitorSignature;
        App.Store.Save();
        ShowStatus(L.Overwritten(layout.Name));
    }

    private void Delete_Click(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is not { } layout) return;
        if (_pendingDelete == layout)
        {
            _pendingDelete = null;
            _deleteTimer.Stop();
            App.Store.Remove(layout);
            ShowStatus(L.DeletedLayout(layout.Name));
        }
        else
        {
            _pendingDelete = layout;
            _deleteTimer.Stop();
            _deleteTimer.Start();
            ShowStatus(L.ClickAgainToDelete(layout.Name));
        }
    }

    // --- menu kontekstowe ---

    private void Menu_Apply(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) ApplyLayout(layout);
    }

    private void Menu_Rename(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) StartRename(layout);
    }

    private void Menu_Overwrite(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) OverwriteLayout(layout);
    }

    private void Menu_MoveUp(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) App.Store.Move(layout, -1);
    }

    private void Menu_MoveDown(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is { } layout) App.Store.Move(layout, +1);
    }

    private void Menu_Delete(object sender, RoutedEventArgs e)
    {
        if (LayoutOf(sender) is not { } layout) return;
        App.Store.Remove(layout);
        ShowStatus(L.DeletedLayout(layout.Name));
    }

    // --- okno / zasobnik / ustawienia ---

    private void Minimize_Click(object sender, RoutedEventArgs e) => WindowState = WindowState.Minimized;

    private void HideToTray_Click(object sender, RoutedEventArgs e) => Close();

    protected override void OnClosing(CancelEventArgs e)
    {
        if (!App.IsExiting)
        {
            e.Cancel = true;
            Hide();
            ((App)System.Windows.Application.Current).NotifyHiddenToTray();
        }
        base.OnClosing(e);
    }

    private void Autostart_Changed(object sender, RoutedEventArgs e)
    {
        if (!_initialized) return;
        try
        {
            Autostart.Set(AutostartBox.IsChecked == true);
        }
        catch (Exception ex)
        {
            Log.Write("Błąd autostartu: " + ex.Message);
            ShowStatus(L.AutostartFailed);
        }
    }

    private void Settings_Changed(object sender, RoutedEventArgs e)
    {
        if (!_initialized) return;
        SettingsStore.Current.HotkeysEnabled = HotkeysBox.IsChecked == true;
        SettingsStore.Current.LaunchMissingApps = LaunchMissingBox.IsChecked == true;
        SettingsStore.Save();
    }
}