MainForm.cs

// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 YJZ

using System;
using System.ComponentModel;
using System.IO;
using System.Windows.Forms;
using System.Drawing;

namespace FolderEncryptor
{
    public sealed class MainForm : Form
    {
        private readonly TextBox encryptSource = new TextBox();
        private readonly TextBox encryptOutput = new TextBox();
        private readonly TextBox encryptPassword = new TextBox();
        private readonly TextBox encryptConfirm = new TextBox();
        private readonly Label replaceSourceLabel = new Label();
        private readonly Button encryptButton = new Button();

        private readonly TextBox decryptPackage = new TextBox();
        private readonly TextBox decryptDestination = new TextBox();
        private readonly TextBox decryptPassword = new TextBox();
        private readonly Button decryptButton = new Button();

        private readonly MenuStrip menuStrip = new MenuStrip();
        private readonly ToolStripMenuItem languageMenu = new ToolStripMenuItem();
        private readonly ToolStripMenuItem englishMenuItem = new ToolStripMenuItem();
        private readonly ToolStripMenuItem chineseMenuItem = new ToolStripMenuItem();
        private readonly TabControl mainTabs = new TabControl();
        private readonly TextBox logBox = new TextBox();

        private readonly Label sourceLabel = new Label();
        private readonly Label encryptOutputLabel = new Label();
        private readonly Label encryptPasswordLabel = new Label();
        private readonly Label encryptConfirmLabel = new Label();
        private readonly Label decryptPackageLabel = new Label();
        private readonly Label decryptDestinationLabel = new Label();
        private readonly Label decryptPasswordLabel = new Label();

        private readonly Button encryptFileButton = new Button();
        private readonly Button encryptFolderButton = new Button();
        private readonly Button decryptPackageBrowseButton = new Button();
        private readonly Button decryptDestinationBrowseButton = new Button();

        private TabPage encryptPage;
        private TabPage decryptPage;

        public MainForm()
        {
            StartPosition = FormStartPosition.CenterScreen;
            MinimumSize = new Size(600, 450);
            Size = new Size(700, 520);

            encryptOutput.ReadOnly = true;
            encryptPassword.UseSystemPasswordChar = true;
            encryptConfirm.UseSystemPasswordChar = true;
            decryptPassword.UseSystemPasswordChar = true;

            BuildMenu();

            mainTabs.Dock = DockStyle.Fill;
            mainTabs.TabPages.Add(BuildEncryptTab());
            mainTabs.TabPages.Add(BuildDecryptTab());

            logBox.Dock = DockStyle.Fill;
            logBox.Multiline = true;
            logBox.ReadOnly = true;
            logBox.ScrollBars = ScrollBars.Vertical;
            logBox.Font = new Font("Consolas", 9f);

            TableLayoutPanel mainLayout = new TableLayoutPanel();
            mainLayout.Dock = DockStyle.Fill;
            mainLayout.ColumnCount = 1;
            mainLayout.RowCount = 2;
            mainLayout.Padding = new Padding(8);
            mainLayout.RowStyles.Add(new RowStyle(SizeType.Absolute, 235));
            mainLayout.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
            mainLayout.Controls.Add(mainTabs, 0, 0);
            mainLayout.Controls.Add(logBox, 0, 1);

            Controls.Add(mainLayout);
            Controls.Add(menuStrip);
            MainMenuStrip = menuStrip;

            ApplyLanguage();
        }

        public void ShowEncryptTabAndBringToFront()
        {
            if (mainTabs.TabPages.Count > 0)
                mainTabs.SelectedIndex = 0;

            if (WindowState == FormWindowState.Minimized)
                WindowState = FormWindowState.Normal;

            Show();
            Activate();
            TopMost = true;
            TopMost = false;
            Focus();
        }

        private void BuildMenu()
        {
            menuStrip.Dock = DockStyle.Top;
            englishMenuItem.CheckOnClick = false;
            chineseMenuItem.CheckOnClick = false;
            englishMenuItem.Click += delegate { SetLanguage(AppLanguage.English); };
            chineseMenuItem.Click += delegate { SetLanguage(AppLanguage.Chinese); };
            languageMenu.DropDownItems.Add(englishMenuItem);
            languageMenu.DropDownItems.Add(chineseMenuItem);
            menuStrip.Items.Add(languageMenu);
        }

        private void SetLanguage(AppLanguage language)
        {
            AppText.CurrentLanguage = language;
            ApplyLanguage();
        }

        private void ApplyLanguage()
        {
            Text = AppText.Get("AppTitle");
            languageMenu.Text = AppText.Get("Language");
            englishMenuItem.Text = AppText.Get("English");
            chineseMenuItem.Text = AppText.Get("Chinese");
            englishMenuItem.Checked = AppText.CurrentLanguage == AppLanguage.English;
            chineseMenuItem.Checked = AppText.CurrentLanguage == AppLanguage.Chinese;

            if (encryptPage != null)
                encryptPage.Text = AppText.Get("TabEncrypt");
            if (decryptPage != null)
                decryptPage.Text = AppText.Get("TabDecrypt");

            sourceLabel.Text = AppText.Get("SourcePath");
            encryptOutputLabel.Text = AppText.Get("OutputPackage");
            encryptPasswordLabel.Text = AppText.Get("Password");
            encryptConfirmLabel.Text = AppText.Get("ConfirmPassword");
            decryptPackageLabel.Text = AppText.Get("Package");
            decryptDestinationLabel.Text = AppText.Get("Destination");
            decryptPasswordLabel.Text = AppText.Get("Password");

            encryptFileButton.Text = AppText.Get("BrowseFile");
            encryptFolderButton.Text = AppText.Get("BrowseFolder");
            decryptPackageBrowseButton.Text = AppText.Get("BrowseChoose");
            decryptDestinationBrowseButton.Text = AppText.Get("BrowseDirectory");
            replaceSourceLabel.Text = AppText.Get("EncryptNote");

            encryptButton.Text = AppText.Get("ButtonEncrypt");
            decryptButton.Text = AppText.Get("ButtonDecrypt");
        }

        private TabPage BuildEncryptTab()
        {
            encryptPage = new TabPage();
            TableLayoutPanel grid = CreateGrid(6);

            AddSourceRow(grid, 0);
            AddTextRow(grid, 1, encryptOutputLabel, encryptOutput);
            AddTextRow(grid, 2, encryptPasswordLabel, encryptPassword);
            AddTextRow(grid, 3, encryptConfirmLabel, encryptConfirm);
            AddReplaceSourceRow(grid, 4);

            encryptButton.Click += EncryptClicked;
            grid.Controls.Add(encryptButton, 3, 5);

            encryptPage.Controls.Add(grid);
            return encryptPage;
        }

        private TabPage BuildDecryptTab()
        {
            decryptPage = new TabPage();
            TableLayoutPanel grid = CreateGrid(5);

            AddPathRow(grid, 0, decryptPackageLabel, decryptPackage, decryptPackageBrowseButton, BrowseDecryptPackage);
            AddPathRow(grid, 1, decryptDestinationLabel, decryptDestination, decryptDestinationBrowseButton, BrowseDecryptDestination);
            AddTextRow(grid, 2, decryptPasswordLabel, decryptPassword);

            decryptButton.Click += DecryptClicked;
            grid.Controls.Add(decryptButton, 3, 3);

            decryptPage.Controls.Add(grid);
            return decryptPage;
        }

        private static TableLayoutPanel CreateGrid(int rows)
        {
            TableLayoutPanel grid = new TableLayoutPanel();
            grid.Dock = DockStyle.Fill;
            grid.ColumnCount = 4;
            grid.RowCount = rows;
            grid.Padding = new Padding(8);
            grid.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 96));
            grid.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100));
            grid.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 86));
            grid.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 96));

            for (int i = 0; i < rows; i++)
                grid.RowStyles.Add(new RowStyle(SizeType.Absolute, 30));

            return grid;
        }

        private void AddSourceRow(TableLayoutPanel grid, int row)
        {
            ConfigureLabel(sourceLabel);
            grid.Controls.Add(sourceLabel, 0, row);

            encryptSource.Anchor = AnchorStyles.Left | AnchorStyles.Right;
            grid.Controls.Add(encryptSource, 1, row);

            encryptFileButton.Click += BrowseEncryptFile;
            grid.Controls.Add(encryptFileButton, 2, row);

            encryptFolderButton.Click += BrowseEncryptFolder;
            grid.Controls.Add(encryptFolderButton, 3, row);
        }

        private static void ConfigureLabel(Label labelControl)
        {
            labelControl.TextAlign = ContentAlignment.MiddleLeft;
            labelControl.Dock = DockStyle.Fill;
        }

        private static void AddTextRow(TableLayoutPanel grid, int row, Label labelControl, TextBox textBox)
        {
            ConfigureLabel(labelControl);
            grid.Controls.Add(labelControl, 0, row);
            textBox.Anchor = AnchorStyles.Left | AnchorStyles.Right;
            grid.SetColumnSpan(textBox, 3);
            grid.Controls.Add(textBox, 1, row);
        }

        private void AddReplaceSourceRow(TableLayoutPanel grid, int row)
        {
            replaceSourceLabel.AutoSize = true;
            replaceSourceLabel.Anchor = AnchorStyles.Left;
            grid.SetColumnSpan(replaceSourceLabel, 3);
            grid.Controls.Add(replaceSourceLabel, 1, row);
        }

        private static void AddPathRow(TableLayoutPanel grid, int row, Label labelControl, TextBox textBox, Button button, EventHandler handler)
        {
            ConfigureLabel(labelControl);
            grid.Controls.Add(labelControl, 0, row);

            textBox.Anchor = AnchorStyles.Left | AnchorStyles.Right;
            grid.SetColumnSpan(textBox, 2);
            grid.Controls.Add(textBox, 1, row);

            button.Click += handler;
            grid.Controls.Add(button, 3, row);
        }

        private void BrowseEncryptFile(object sender, EventArgs e)
        {
            HiddenPathDialog dialog = new HiddenPathDialog(AppText.Get("DialogEncryptFileTitle"), HiddenPathDialogMode.OpenFile, encryptSource.Text);
            if (dialog.ShowDialog(this) != DialogResult.OK)
                return;

            encryptSource.Text = dialog.SelectedPath;
            SetDefaultOutput(dialog.SelectedPath);
        }

        private void BrowseEncryptFolder(object sender, EventArgs e)
        {
            HiddenPathDialog dialog = new HiddenPathDialog(AppText.Get("DialogEncryptFolderTitle"), HiddenPathDialogMode.OpenFolder, encryptSource.Text);
            if (dialog.ShowDialog(this) != DialogResult.OK)
                return;

            encryptSource.Text = dialog.SelectedPath;
            SetDefaultOutput(dialog.SelectedPath);
        }

        private void SetDefaultOutput(string sourcePath)
        {
            encryptOutput.Text = GetSiblingPackagePath(sourcePath);
        }

        private void BrowseDecryptPackage(object sender, EventArgs e)
        {
            HiddenPathDialog dialog = new HiddenPathDialog(AppText.Get("DialogDecryptPackageTitle"), HiddenPathDialogMode.OpenFile, decryptPackage.Text);
            if (dialog.ShowDialog(this) != DialogResult.OK)
                return;

            decryptPackage.Text = dialog.SelectedPath;
            if (string.IsNullOrEmpty(decryptDestination.Text))
                decryptDestination.Text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), AppText.Get("DefaultDecryptOutputFolder"));
        }

        private void BrowseDecryptDestination(object sender, EventArgs e)
        {
            HiddenPathDialog dialog = new HiddenPathDialog(AppText.Get("DialogDecryptDestinationTitle"), HiddenPathDialogMode.OpenFolder, decryptDestination.Text);
            if (dialog.ShowDialog(this) == DialogResult.OK)
                decryptDestination.Text = dialog.SelectedPath;
        }

        private void EncryptClicked(object sender, EventArgs e)
        {
            string sourcePath = encryptSource.Text;
            string outputPath = GetSiblingPackagePath(sourcePath);
            string password = encryptPassword.Text;

            encryptOutput.Text = outputPath;

            if (!File.Exists(sourcePath) && !Directory.Exists(sourcePath))
            {
                MessageBox.Show(this, AppText.Get("SourceMissing"), AppText.Get("SourceMissingTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (string.IsNullOrEmpty(outputPath))
            {
                MessageBox.Show(this, AppText.Get("OutputPathInvalid"), AppText.Get("PathErrorTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (string.Equals(Path.GetExtension(sourcePath), ".sfe", StringComparison.OrdinalIgnoreCase))
            {
                MessageBox.Show(this, AppText.Get("AlreadySfe"), AppText.Get("AlreadySfeTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (password.Length < 8)
            {
                MessageBox.Show(this, AppText.Get("PasswordTooShort"), AppText.Get("PasswordTooShortTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (password != encryptConfirm.Text)
            {
                MessageBox.Show(this, AppText.Get("PasswordMismatch"), AppText.Get("PasswordMismatchTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (IsDangerousSourcePath(sourcePath))
            {
                MessageBox.Show(this, AppText.Get("DangerousSource"), AppText.Get("DangerousSourceTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (File.Exists(outputPath))
            {
                DialogResult overwrite = MessageBox.Show(
                    this,
                    string.Format(AppText.Get("OverwritePackagePrompt"), outputPath),
                    AppText.Get("OverwritePackageTitle"),
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Warning);
                if (overwrite != DialogResult.Yes)
                    return;
            }

            DialogResult confirm = MessageBox.Show(
                this,
                AppText.Get("ConfirmEncryptPrompt"),
                AppText.Get("ConfirmEncryptTitle"),
                MessageBoxButtons.YesNo,
                MessageBoxIcon.Warning);
            if (confirm != DialogResult.Yes)
                return;

            RunWork(encryptButton, delegate
            {
                string temporaryPackage = CreateTemporaryPackagePath(outputPath);
                try
                {
                    FolderPackage.EncryptPath(sourcePath, temporaryPackage, password, Log);
                    FolderPackage.VerifyPackage(temporaryPackage, password);
                    ReplacePackageFile(temporaryPackage, outputPath);
                    Log(string.Format(AppText.Get("LogPackageVerified"), outputPath));
                    Log(string.Format(AppText.Get("LogSourceKept"), sourcePath));
                }
                finally
                {
                    DeleteTemporaryPackage(temporaryPackage);
                }
            }, delegate
            {
                ShowEncryptionSuccessNotice(sourcePath, outputPath);
            });
        }

        private void ShowEncryptionSuccessNotice(string sourcePath, string packagePath)
        {
            MessageBox.Show(
                this,
                string.Format(AppText.Get("EncryptSuccessMessage"), packagePath),
                AppText.Get("EncryptSuccessTitle"),
                MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }

        private void DecryptClicked(object sender, EventArgs e)
        {
            if (!File.Exists(decryptPackage.Text))
            {
                MessageBox.Show(this, AppText.Get("PackageMissing"), AppText.Get("PackageMissingTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            if (string.IsNullOrEmpty(decryptDestination.Text))
            {
                MessageBox.Show(this, AppText.Get("DestinationMissing"), AppText.Get("DestinationMissingTitle"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            RunWork(decryptButton, delegate
            {
                FolderPackage.DecryptPackage(decryptPackage.Text, decryptDestination.Text, decryptPassword.Text, Log);
            });
        }

        private static string GetSiblingPackagePath(string sourcePath)
        {
            if (string.IsNullOrEmpty(sourcePath))
                return string.Empty;

            string fullSource = Path.GetFullPath(sourcePath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
            string parent;
            if (File.Exists(fullSource))
            {
                parent = Path.GetDirectoryName(fullSource);
            }
            else
            {
                DirectoryInfo parentInfo = Directory.GetParent(fullSource);
                parent = parentInfo == null ? string.Empty : parentInfo.FullName;
            }

            string name = Path.GetFileName(fullSource);
            if (string.IsNullOrEmpty(parent) || string.IsNullOrEmpty(name))
                return string.Empty;
            return Path.Combine(parent, name + ".sfe");
        }

        private static string CreateTemporaryPackagePath(string outputPath)
        {
            string directory = Path.GetDirectoryName(Path.GetFullPath(outputPath));
            string name = Path.GetFileNameWithoutExtension(outputPath);
            return Path.Combine(directory, name + "." + Guid.NewGuid().ToString("N") + ".tmp");
        }

        private static void ReplacePackageFile(string temporaryPackage, string outputPath)
        {
            string directory = Path.GetDirectoryName(Path.GetFullPath(outputPath));
            if (!string.IsNullOrEmpty(directory))
                Directory.CreateDirectory(directory);

            if (File.Exists(outputPath))
            {
                File.SetAttributes(outputPath, FileAttributes.Normal);
                File.Delete(outputPath);
            }

            File.SetAttributes(temporaryPackage, FileAttributes.Normal);
            File.Move(temporaryPackage, outputPath);
        }

        private static void DeleteTemporaryPackage(string temporaryPackage)
        {
            if (string.IsNullOrEmpty(temporaryPackage) || !File.Exists(temporaryPackage))
                return;

            File.SetAttributes(temporaryPackage, FileAttributes.Normal);
            File.Delete(temporaryPackage);
        }

        private static bool IsDangerousSourcePath(string sourcePath)
        {
            if (!Directory.Exists(sourcePath))
                return false;

            string full = TrimDirectoryEnd(Path.GetFullPath(sourcePath));
            string root = TrimDirectoryEnd(Path.GetPathRoot(full));
            string user = TrimDirectoryEnd(Environment.GetEnvironmentVariable("USERPROFILE"));

            return string.Equals(full, root, StringComparison.OrdinalIgnoreCase) ||
                   string.Equals(full, user, StringComparison.OrdinalIgnoreCase);
        }

        private static string TrimDirectoryEnd(string path)
        {
            if (string.IsNullOrEmpty(path))
                return path;
            return path.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
        }

        private void RunWork(Button activeButton, Action work)
        {
            RunWork(activeButton, work, null);
        }

        private void RunWork(Button activeButton, Action work, Action afterSuccess)
        {
            SetBusy(activeButton, true);
            logBox.Clear();

            BackgroundWorker worker = new BackgroundWorker();
            worker.DoWork += delegate { work(); };
            worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e)
            {
                SetBusy(activeButton, false);
                if (e.Error != null)
                {
                    Log(e.Error.Message);
                    MessageBox.Show(this, e.Error.Message, AppText.Get("ErrorTitle"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                if (afterSuccess != null)
                    afterSuccess();
                else
                    MessageBox.Show(this, AppText.Get("OperationComplete"), AppText.Get("AppTitle"), MessageBoxButtons.OK, MessageBoxIcon.Information);
            };
            worker.RunWorkerAsync();
        }

        private void Log(string message)
        {
            if (InvokeRequired)
            {
                BeginInvoke(new Action<string>(Log), message);
                return;
            }

            logBox.AppendText("[" + DateTime.Now.ToString("HH:mm:ss") + "] " + message + Environment.NewLine);
        }

        private void SetBusy(Button activeButton, bool busy)
        {
            encryptButton.Enabled = !busy;
            decryptButton.Enabled = !busy;
            activeButton.Text = busy ? AppText.Get("Processing") : activeButton == encryptButton ? AppText.Get("ButtonEncrypt") : AppText.Get("ButtonDecrypt");
        }
    }
}