MainForm.cs

using System.Diagnostics;

namespace PhotoViewer;

internal sealed class MainForm : Form
{
    private static readonly HashSet<string> SupportedExtensions = new(StringComparer.OrdinalIgnoreCase)
    {
        ".bmp", ".gif", ".ico", ".jpeg", ".jpg", ".png", ".tif", ".tiff"
    };

    private readonly ImageCanvas canvas = new() { Dock = DockStyle.Fill };
    private readonly ToolStripStatusLabel fileStatus = new() { Spring = true, TextAlign = ContentAlignment.MiddleLeft };
    private readonly ToolStripStatusLabel dimensionsStatus = new();
    private readonly ToolStripStatusLabel positionStatus = new();
    private readonly ToolStripStatusLabel zoomStatus = new();
    private readonly ToolStripButton previousButton;
    private readonly ToolStripButton nextButton;
    private readonly ToolStripButton slideshowButton;
    private readonly MenuStrip menu;
    private readonly ToolStrip toolbar;
    private readonly StatusStrip status;
    private readonly TableLayoutPanel layout;
    private readonly System.Windows.Forms.Timer slideshowTimer = new() { Interval = 3000 };
    private readonly List<string> files = [];
    private AppSettings settings;
    private Font? applicationFont;
    private int currentIndex = -1;
    private Image? currentImage;
    private bool fullScreen;
    private bool updateCheckInProgress;
    private FormBorderStyle savedBorderStyle;
    private FormWindowState savedWindowState;

    public MainForm(string? initialPath)
    {
        settings = AppSettings.Load();
        AppTheme.Apply(settings);
        Text = "Photo Viewer";
        StartPosition = FormStartPosition.CenterScreen;
        MinimumSize = new Size(720, 480);
        ClientSize = new Size(1100, 720);
        KeyPreview = true;
        AllowDrop = true;
        BackColor = AppTheme.WindowBackground;
        ForeColor = AppTheme.Foreground;

        if (Environment.ProcessPath is string executablePath)
            Icon = Icon.ExtractAssociatedIcon(executablePath);

        menu = BuildMenu();
        var stripRenderer = AppTheme.CreateRenderer();
        ConfigureStrip(menu, stripRenderer);
        toolbar = new ToolStrip
        {
            GripStyle = ToolStripGripStyle.Hidden,
            Padding = new Padding(8, 4, 8, 4),
            ImageScalingSize = new Size(20, 20),
            BackColor = AppTheme.Surface,
            ForeColor = AppTheme.Foreground,
            Renderer = stripRenderer,
            CanOverflow = true,
            LayoutStyle = ToolStripLayoutStyle.HorizontalStackWithOverflow
        };

        toolbar.Items.Add(MakeButton("Open", ToolbarIconKind.OpenImage, (_, _) => OpenImage(), "Open an image (Ctrl+O)"));
        toolbar.Items.Add(MakeButton("Folder", ToolbarIconKind.OpenFolder, (_, _) => OpenFolder(), "Open a folder (Ctrl+Shift+O)"));
        toolbar.Items.Add(new ToolStripSeparator());
        previousButton = MakeButton("Previous", ToolbarIconKind.Previous, (_, _) => Navigate(-1), "Previous photo (Left)");
        nextButton = MakeButton("Next", ToolbarIconKind.Next, (_, _) => Navigate(1), "Next photo (Right)");
        toolbar.Items.Add(previousButton);
        toolbar.Items.Add(nextButton);
        toolbar.Items.Add(new ToolStripSeparator());
        toolbar.Items.Add(MakeButton("Zoom out", ToolbarIconKind.ZoomOut, (_, _) => canvas.ZoomOut(), "Zoom out (-)"));
        toolbar.Items.Add(MakeButton("Zoom in", ToolbarIconKind.ZoomIn, (_, _) => canvas.ZoomIn(), "Zoom in (+)"));
        toolbar.Items.Add(MakeButton("Fit", ToolbarIconKind.Fit, (_, _) => canvas.Fit(), "Fit to window (F)"));
        toolbar.Items.Add(MakeButton("100%", ToolbarIconKind.ActualSize, (_, _) => canvas.ActualSize(), "Actual size (1)"));
        toolbar.Items.Add(new ToolStripSeparator());
        toolbar.Items.Add(MakeButton("Rotate left", ToolbarIconKind.RotateLeft, (_, _) => Rotate(RotateFlipType.Rotate270FlipNone), "Rotate left (Ctrl+L)"));
        toolbar.Items.Add(MakeButton("Rotate right", ToolbarIconKind.RotateRight, (_, _) => Rotate(RotateFlipType.Rotate90FlipNone), "Rotate right (Ctrl+R)"));
        toolbar.Items.Add(new ToolStripSeparator());
        slideshowButton = MakeButton("Slideshow", ToolbarIconKind.Slideshow, (_, _) => ToggleSlideshow(), "Start slideshow (F5)");
        slideshowButton.CheckOnClick = true;
        toolbar.Items.Add(slideshowButton);

        status = new StatusStrip
        {
            BackColor = AppTheme.Surface,
            ForeColor = AppTheme.Foreground,
            Renderer = stripRenderer,
            SizingGrip = false,
            Padding = new Padding(8, 2, 8, 2)
        };
        status.Items.AddRange([fileStatus, dimensionsStatus, positionStatus, zoomStatus]);

        layout = new TableLayoutPanel
        {
            Dock = DockStyle.Fill,
            BackColor = AppTheme.WindowBackground,
            ColumnCount = 1,
            RowCount = 4,
            Margin = Padding.Empty,
            Padding = Padding.Empty
        };
        layout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100));
        layout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
        layout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
        layout.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
        layout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
        layout.Controls.Add(menu, 0, 0);
        layout.Controls.Add(toolbar, 0, 1);
        layout.Controls.Add(canvas, 0, 2);
        layout.Controls.Add(status, 0, 3);

        Controls.Add(layout);
        MainMenuStrip = menu;

        canvas.ViewChanged += (_, _) => UpdateStatus();
        slideshowTimer.Tick += (_, _) => Navigate(1);
        DragEnter += HandleDragEnter;
        DragDrop += HandleDragDrop;
        FormClosed += (_, _) =>
        {
            currentImage?.Dispose();
            applicationFont?.Dispose();
        };
        KeyDown += HandleKeyDown;
        Shown += async (_, _) =>
        {
            OpenInitialPath(initialPath);
            if (settings.AutomaticallyCheckForUpdates &&
                Environment.GetEnvironmentVariable("PHOTOVIEWER_DISABLE_UPDATE_CHECK") != "1" &&
                (settings.LastUpdateCheckUtc is null ||
                 DateTimeOffset.UtcNow - settings.LastUpdateCheckUtc.Value >= TimeSpan.FromDays(1)))
                await CheckForUpdatesAsync(userInitiated: false);
        };

        ApplySettings(settings);
        UpdateNavigationState();
        UpdateStatus();
    }

    private MenuStrip BuildMenu()
    {
        var menu = new MenuStrip();
        var file = new ToolStripMenuItem("&File");
        file.DropDownItems.Add(new ToolStripMenuItem("&Open image...", null, (_, _) => OpenImage(), Keys.Control | Keys.O));
        file.DropDownItems.Add(new ToolStripMenuItem("Open &folder...", null, (_, _) => OpenFolder(), Keys.Control | Keys.Shift | Keys.O));
        file.DropDownItems.Add(new ToolStripSeparator());
        file.DropDownItems.Add(new ToolStripMenuItem("Open file &location", null, (_, _) => OpenFileLocation()));
        file.DropDownItems.Add(new ToolStripSeparator());
        file.DropDownItems.Add(new ToolStripMenuItem("E&xit", null, (_, _) => Close(), Keys.Alt | Keys.F4));

        var view = new ToolStripMenuItem("&View");
        view.DropDownItems.Add(new ToolStripMenuItem("Zoom &in", null, (_, _) => canvas.ZoomIn(), Keys.Control | Keys.Oemplus));
        view.DropDownItems.Add(new ToolStripMenuItem("Zoom &out", null, (_, _) => canvas.ZoomOut(), Keys.Control | Keys.OemMinus));
        view.DropDownItems.Add(new ToolStripMenuItem("&Fit to window", null, (_, _) => canvas.Fit())
        {
            ShortcutKeyDisplayString = "F"
        });
        view.DropDownItems.Add(new ToolStripMenuItem("&Actual size", null, (_, _) => canvas.ActualSize())
        {
            ShortcutKeyDisplayString = "1"
        });
        view.DropDownItems.Add(new ToolStripSeparator());
        view.DropDownItems.Add(new ToolStripMenuItem("&Full screen", null, (_, _) => ToggleFullScreen(), Keys.F11));
        view.DropDownItems.Add(new ToolStripSeparator());
        view.DropDownItems.Add(new ToolStripMenuItem("&Settings...", null, (_, _) => OpenSettings(), Keys.Control | Keys.Oemcomma));

        var image = new ToolStripMenuItem("&Image");
        image.DropDownItems.Add(new ToolStripMenuItem("&Previous", null, (_, _) => Navigate(-1))
        {
            ShortcutKeyDisplayString = "Left"
        });
        image.DropDownItems.Add(new ToolStripMenuItem("&Next", null, (_, _) => Navigate(1))
        {
            ShortcutKeyDisplayString = "Right"
        });
        image.DropDownItems.Add(new ToolStripSeparator());
        image.DropDownItems.Add(new ToolStripMenuItem("Rotate &left", null, (_, _) => Rotate(RotateFlipType.Rotate270FlipNone), Keys.Control | Keys.L));
        image.DropDownItems.Add(new ToolStripMenuItem("Rotate &right", null, (_, _) => Rotate(RotateFlipType.Rotate90FlipNone), Keys.Control | Keys.R));
        image.DropDownItems.Add(new ToolStripSeparator());
        image.DropDownItems.Add(new ToolStripMenuItem("&Slideshow", null, (_, _) => ToggleSlideshow(), Keys.F5));

        var help = new ToolStripMenuItem("&Help");
        help.DropDownItems.Add(new ToolStripMenuItem("Check for &updates...", null,
            async (_, _) => await CheckForUpdatesAsync(userInitiated: true)));

        menu.Items.AddRange([file, view, image, help]);
        return menu;
    }

    protected override void OnHandleCreated(EventArgs e)
    {
        base.OnHandleCreated(e);
        AppTheme.ApplyDarkTitleBar(this);
    }

    private static ToolStripButton MakeButton(string text, ToolbarIconKind icon, EventHandler onClick, string tooltip)
    {
        var button = new ToolStripButton(text)
        {
            DisplayStyle = ToolStripItemDisplayStyle.ImageAndText,
            Image = ToolbarIconFactory.Create(icon),
            ImageAlign = ContentAlignment.MiddleCenter,
            TextAlign = ContentAlignment.MiddleCenter,
            TextImageRelation = TextImageRelation.ImageBeforeText,
            ToolTipText = tooltip,
            ForeColor = AppTheme.Foreground,
            Tag = icon,
            Margin = new Padding(1, 0, 1, 0),
            Padding = new Padding(4, 2, 5, 2)
        };
        button.Click += onClick;
        return button;
    }

    private static void ConfigureStrip(MenuStrip menu, ToolStripRenderer renderer)
    {
        menu.BackColor = AppTheme.Surface;
        menu.ForeColor = AppTheme.Foreground;
        menu.Renderer = renderer;
        menu.Padding = new Padding(8, 2, 8, 2);
        ApplyMenuTheme(menu.Items, renderer);
    }

    private static void ApplyMenuTheme(ToolStripItemCollection items, ToolStripRenderer renderer)
    {
        foreach (ToolStripItem item in items)
        {
            item.ForeColor = AppTheme.Foreground;
            if (item is not ToolStripMenuItem menuItem)
                continue;

            menuItem.DropDown.BackColor = AppTheme.Surface;
            menuItem.DropDown.ForeColor = AppTheme.Foreground;
            menuItem.DropDown.Renderer = renderer;
            ApplyMenuTheme(menuItem.DropDownItems, renderer);
        }
    }

    private void OpenSettings()
    {
        using var dialog = new SettingsDialog(settings);
        dialog.PreviewSettingsChanged += (_, _) => ApplySettings(dialog.SelectedSettings);
        if (dialog.ShowDialog(this) != DialogResult.OK)
        {
            ApplySettings(settings);
            return;
        }

        settings = dialog.SelectedSettings;
        ApplySettings(settings);
        if (!settings.TrySave(out string? error))
        {
            MessageBox.Show(this, $"The settings could not be saved. They will remain active until the application closes.\n\n{error}",
                "Photo Viewer", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        }
    }

    private void ApplySettings(AppSettings newSettings)
    {
        newSettings.Normalize();
        AppTheme.Apply(newSettings);

        Font newFont = newSettings.CreateFont();
        Font? oldFont = applicationFont;
        applicationFont = newFont;
        Font = newFont;
        menu.Font = newFont;
        toolbar.Font = newFont;
        status.Font = newFont;

        BackColor = AppTheme.WindowBackground;
        ForeColor = AppTheme.Foreground;
        layout.BackColor = AppTheme.WindowBackground;
        canvas.ApplyTheme();
        slideshowTimer.Interval = newSettings.SlideshowIntervalSeconds * 1000;

        var renderer = AppTheme.CreateRenderer();
        ConfigureStrip(menu, renderer);
        ConfigureToolStrip(toolbar, renderer);
        ConfigureToolStrip(status, renderer);
        RefreshToolbarIcons();
        if (IsHandleCreated)
            AppTheme.ApplyDarkTitleBar(this);
        Invalidate(true);
        oldFont?.Dispose();
    }

    private async Task CheckForUpdatesAsync(bool userInitiated)
    {
        if (updateCheckInProgress)
            return;

        updateCheckInProgress = true;
        UseWaitCursor = true;
        try
        {
            if (userInitiated)
                fileStatus.Text = "Checking for updates…";

            AvailableUpdate? update = await UpdateService.CheckForUpdateAsync();
            if (IsDisposed)
                return;

            if (update is null)
            {
                if (userInitiated)
                {
                    MessageBox.Show(this, $"Photo Viewer {UpdateService.CurrentVersion.ToString(3)} is up to date.",
                        "Check for updates", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                return;
            }

            DialogResult choice = MessageBox.Show(this,
                $"Photo Viewer {update.Version.ToString(3)} is available.\n\n" +
                "Download and install it now? The application will restart automatically.",
                "Update available", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
            if (choice != DialogResult.Yes)
                return;

            var progress = new Progress<int>(percentage =>
                fileStatus.Text = $"Downloading Photo Viewer {update.Version.ToString(3)}… {percentage}%");
            string stagedExecutable = await UpdateService.DownloadAndStageAsync(update, progress);
            fileStatus.Text = "Installing update…";
            UpdateService.LaunchUpdater(stagedExecutable);
            Close();
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Update check failed: {ex}");
            if (userInitiated && !IsDisposed)
            {
                MessageBox.Show(this, $"Photo Viewer could not check for updates.\n\n{ex.Message}",
                    "Check for updates", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
        finally
        {
            if (!userInitiated)
            {
                settings.LastUpdateCheckUtc = DateTimeOffset.UtcNow;
                settings.TrySave(out _);
            }
            updateCheckInProgress = false;
            if (!IsDisposed)
            {
                UseWaitCursor = false;
                UpdateStatus();
            }
        }
    }

    private static void ConfigureToolStrip(ToolStrip strip, ToolStripRenderer renderer)
    {
        strip.BackColor = AppTheme.Surface;
        strip.ForeColor = AppTheme.Foreground;
        strip.Renderer = renderer;
        ApplyToolStripItemTheme(strip.Items, renderer);
    }

    private static void ApplyToolStripItemTheme(ToolStripItemCollection items, ToolStripRenderer renderer)
    {
        foreach (ToolStripItem item in items)
        {
            item.ForeColor = AppTheme.Foreground;
            if (item is ToolStripMenuItem menuItem)
            {
                menuItem.DropDown.BackColor = AppTheme.Surface;
                menuItem.DropDown.ForeColor = AppTheme.Foreground;
                menuItem.DropDown.Renderer = renderer;
                ApplyToolStripItemTheme(menuItem.DropDownItems, renderer);
            }
        }
    }

    private void RefreshToolbarIcons()
    {
        foreach (ToolStripItem item in toolbar.Items)
        {
            if (item.Tag is not ToolbarIconKind icon)
                continue;

            Image? oldImage = item.Image;
            item.Image = ToolbarIconFactory.Create(icon);
            oldImage?.Dispose();
        }
    }

    private void OpenImage()
    {
        using var dialog = new OpenFileDialog
        {
            Title = "Open a photo",
            Filter = "Images|*.bmp;*.gif;*.ico;*.jpeg;*.jpg;*.png;*.tif;*.tiff|All files|*.*",
            CheckFileExists = true
        };

        if (dialog.ShowDialog(this) == DialogResult.OK)
            LoadFolderAndSelect(dialog.FileName);
    }

    private void OpenFolder()
    {
        using var dialog = new FolderBrowserDialog
        {
            Description = "Choose a folder containing photos",
            UseDescriptionForTitle = true,
            ShowNewFolderButton = false
        };

        if (dialog.ShowDialog(this) != DialogResult.OK)
            return;

        LoadFolder(dialog.SelectedPath);
        if (files.Count > 0)
            ShowAt(0);
        else
            MessageBox.Show(this, "No supported images were found in that folder.", "Photo Viewer",
                MessageBoxButtons.OK, MessageBoxIcon.Information);
    }

    private void OpenInitialPath(string? path)
    {
        if (string.IsNullOrWhiteSpace(path))
            return;

        if (Directory.Exists(path))
        {
            LoadFolder(path);
            if (files.Count > 0)
                ShowAt(0);
        }
        else if (File.Exists(path) && IsSupported(path))
        {
            LoadFolderAndSelect(path);
        }
    }

    private void LoadFolderAndSelect(string path)
    {
        string fullPath = Path.GetFullPath(path);
        LoadFolder(Path.GetDirectoryName(fullPath)!);
        int index = files.FindIndex(file => string.Equals(file, fullPath, StringComparison.OrdinalIgnoreCase));
        if (index >= 0)
            ShowAt(index);
    }

    private void LoadFolder(string folder)
    {
        files.Clear();
        try
        {
            files.AddRange(Directory.EnumerateFiles(folder)
                .Where(IsSupported)
                .OrderBy(Path.GetFileName, StringComparer.CurrentCultureIgnoreCase));
        }
        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
        {
            MessageBox.Show(this, $"The folder could not be read.\n\n{ex.Message}", "Photo Viewer",
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        UpdateNavigationState();
    }

    private void ShowAt(int index)
    {
        if (files.Count == 0)
            return;

        index = (index % files.Count + files.Count) % files.Count;
        string path = files[index];

        try
        {
            Image loaded = LoadUnlocked(path);
            Image? oldImage = currentImage;
            currentImage = loaded;
            currentIndex = index;
            canvas.Image = loaded;
            oldImage?.Dispose();
            Text = $"{Path.GetFileName(path)} — Photo Viewer";
            UpdateNavigationState();
            UpdateStatus();
        }
        catch (Exception ex) when (ex is ArgumentException or IOException or UnauthorizedAccessException or OutOfMemoryException)
        {
            MessageBox.Show(this, $"The image could not be opened.\n\n{ex.Message}", "Photo Viewer",
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    private static Image LoadUnlocked(string path)
    {
        byte[] bytes = File.ReadAllBytes(path);
        using var stream = new MemoryStream(bytes);
        using var source = Image.FromStream(stream);
        return new Bitmap(source);
    }

    private void Navigate(int offset)
    {
        if (files.Count > 0)
            ShowAt(currentIndex < 0 ? 0 : currentIndex + offset);
    }

    private void Rotate(RotateFlipType rotation)
    {
        if (currentImage is null)
            return;

        currentImage.RotateFlip(rotation);
        canvas.Fit();
        canvas.Invalidate();
        UpdateStatus();
    }

    private void ToggleSlideshow()
    {
        if (files.Count < 2)
            return;

        slideshowTimer.Enabled = !slideshowTimer.Enabled;
        slideshowButton.Checked = slideshowTimer.Enabled;
        slideshowButton.Text = slideshowTimer.Enabled ? "Stop slideshow" : "Slideshow";
    }

    private void ToggleFullScreen()
    {
        if (!fullScreen)
        {
            savedBorderStyle = FormBorderStyle;
            savedWindowState = WindowState;
            FormBorderStyle = FormBorderStyle.None;
            WindowState = FormWindowState.Maximized;
            fullScreen = true;
        }
        else
        {
            FormBorderStyle = savedBorderStyle;
            WindowState = savedWindowState;
            fullScreen = false;
        }
    }

    private void OpenFileLocation()
    {
        if (currentIndex < 0)
            return;

        Process.Start(new ProcessStartInfo("explorer.exe", $"/select,\"{files[currentIndex]}\"")
        {
            UseShellExecute = true
        });
    }

    private void UpdateNavigationState()
    {
        bool canNavigate = files.Count > 1;
        previousButton.Enabled = canNavigate;
        nextButton.Enabled = canNavigate;
        slideshowButton.Enabled = canNavigate;
        if (!canNavigate && slideshowTimer.Enabled)
            ToggleSlideshow();
    }

    private void UpdateStatus()
    {
        if (currentImage is null || currentIndex < 0)
        {
            fileStatus.Text = "No photo open";
            dimensionsStatus.Text = string.Empty;
            positionStatus.Text = string.Empty;
            zoomStatus.Text = string.Empty;
            return;
        }

        fileStatus.Text = Path.GetFileName(files[currentIndex]);
        dimensionsStatus.Text = $"{currentImage.Width:N0} × {currentImage.Height:N0}";
        positionStatus.Text = $"{currentIndex + 1:N0} of {files.Count:N0}";
        zoomStatus.Text = $"{canvas.EffectiveZoom:P0}";
    }

    private void HandleKeyDown(object? sender, KeyEventArgs e)
    {
        bool handled = true;

        switch (e.KeyCode)
        {
            case Keys.Escape when e.Modifiers == Keys.None && fullScreen:
                ToggleFullScreen();
                break;
            case Keys.F when e.Modifiers == Keys.None:
                canvas.Fit();
                break;
            case Keys.D1 or Keys.NumPad1 when e.Modifiers == Keys.None:
                canvas.ActualSize();
                break;
            case Keys.Left when e.Modifiers == Keys.None:
                Navigate(-1);
                break;
            case Keys.Right when e.Modifiers == Keys.None:
                Navigate(1);
                break;
            case Keys.Add or Keys.Oemplus when !e.Control && !e.Alt:
                canvas.ZoomIn();
                break;
            case Keys.Subtract or Keys.OemMinus when !e.Control && !e.Alt:
                canvas.ZoomOut();
                break;
            default:
                handled = false;
                break;
        }

        if (handled)
        {
            e.Handled = true;
            e.SuppressKeyPress = true;
        }
    }

    private void HandleDragEnter(object? sender, DragEventArgs e)
    {
        if (e.Data?.GetDataPresent(DataFormats.FileDrop) == true)
            e.Effect = DragDropEffects.Copy;
    }

    private void HandleDragDrop(object? sender, DragEventArgs e)
    {
        if (e.Data?.GetData(DataFormats.FileDrop) is not string[] paths || paths.Length == 0)
            return;

        string path = paths[0];
        if (Directory.Exists(path))
        {
            LoadFolder(path);
            if (files.Count > 0)
                ShowAt(0);
        }
        else if (File.Exists(path) && IsSupported(path))
        {
            LoadFolderAndSelect(path);
        }
    }

    private static bool IsSupported(string path) => SupportedExtensions.Contains(Path.GetExtension(path));
}