MainForm.cs

using System;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using FileOrganizer.Services;
using FileOrganizer.Models;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace FileOrganizer
{
    public partial class MainForm : Form
    {
        private readonly IFileOrganizerService _fileOrganizerService;
        private readonly IStatisticsService _statisticsService;
        private readonly ICleanupService _cleanupService;
        private readonly ISchedulerService _schedulerService;
        private readonly IDatabaseService _databaseService;
        private readonly ILogger<MainForm> _logger;
        private readonly AppConfig _config;

        private TabControl _tabControl;

        public MainForm(
            IFileOrganizerService fileOrganizerService,
            IStatisticsService statisticsService,
            ICleanupService cleanupService,
            ISchedulerService schedulerService,
            IDatabaseService databaseService,
            ILogger<MainForm> logger,
            IOptions<AppConfig> config)
        {
            _fileOrganizerService = fileOrganizerService;
            _statisticsService = statisticsService;
            _cleanupService = cleanupService;
            _schedulerService = schedulerService;
            _databaseService = databaseService;
            _logger = logger;
            _config = config.Value;

            InitializeComponent();
            InitializeDatabase();
            _ = _schedulerService.StartSchedulerAsync();
        }

        private async void InitializeDatabase()
        {
            try
            {
                await _databaseService.InitializeDatabaseAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error initializing database");
            }
        }

        private void InitializeComponent()
        {
            this.SuspendLayout();
            this.AutoScaleDimensions = new SizeF(7F, 15F);
            this.AutoScaleMode = AutoScaleMode.Font;
            this.ClientSize = new Size(1200, 700);
            this.Text = "Smart File Management System";
            this.MinimumSize = new Size(1000, 600);
            this.StartPosition = FormStartPosition.CenterScreen;
            this.FormClosing += async (s, e) => await _schedulerService.StopSchedulerAsync();

            _tabControl = new TabControl
            {
                Location = new Point(10, 10),
                Size = new Size(1180, 680),
                Dock = DockStyle.Fill
            };

            _tabControl.TabPages.Add(CreateOrganizeTab());
            _tabControl.TabPages.Add(CreateStatisticsTab());
            _tabControl.TabPages.Add(CreateRulesTab());
            _tabControl.TabPages.Add(CreateCleanupTab());
            _tabControl.TabPages.Add(CreateSchedulerTab());
            _tabControl.TabPages.Add(CreateHistoryTab());
            _tabControl.TabPages.Add(CreateSettingsTab());

            this.Controls.Add(_tabControl);
            this.ResumeLayout(false);
        }

        private TabPage CreateOrganizeTab()
        {
            var tab = new TabPage { Text = "Organize Files", Padding = new Padding(10) };

            var lblPath = new Label { Text = "Source Folder:", Location = new Point(10, 15), AutoSize = true };
            var txtPath = new TextBox
            {
                Location = new Point(120, 12),
                Size = new Size(800, 25),
                Text = _config.DefaultSourcePath
            };

            var btnBrowse = new Button
            {
                Text = "Browse...",
                Location = new Point(930, 12),
                Size = new Size(100, 25)
            };
            btnBrowse.Click += (s, e) =>
            {
                using (var dialog = new FolderBrowserDialog { SelectedPath = txtPath.Text })
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                        txtPath.Text = dialog.SelectedPath;
                }
            };

            var btnOrganize = new Button
            {
                Text = "Organize Now",
                Location = new Point(10, 55),
                Size = new Size(150, 35),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White,
                Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold)
            };

            var btnStartWatch = new Button
            {
                Text = "Start Real-Time Watch",
                Location = new Point(170, 55),
                Size = new Size(150, 35),
                BackColor = Color.FromArgb(107, 142, 35),
                ForeColor = Color.White
            };

            var btnStopWatch = new Button
            {
                Text = "Stop Watching",
                Location = new Point(330, 55),
                Size = new Size(150, 35),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            var btnScanNow = new Button
            {
                Text = "Scan Now",
                Location = new Point(490, 55),
                Size = new Size(100, 35),
                BackColor = Color.FromArgb(30, 144, 255),
                ForeColor = Color.White
            };

            var progressBar = new ProgressBar
            {
                Location = new Point(10, 100),
                Size = new Size(1020, 30),
                Visible = false
            };

            var logBox = new RichTextBox
            {
                Location = new Point(10, 140),
                Size = new Size(1020, 450),
                ReadOnly = true,
                BackColor = Color.White
            };

            btnOrganize.Click += async (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtPath.Text) || !Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Please select a valid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                btnOrganize.Enabled = false;
                progressBar.Visible = true;
                logBox.Clear();
                logBox.AppendText("\n=== ORGANIZATION STARTED ===\n");

                var files = Directory.GetFiles(txtPath.Text, "*", SearchOption.TopDirectoryOnly);
                progressBar.Maximum = files.Length > 0 ? files.Length : 1;
                progressBar.Value = 0;

                var progress = new Progress<string>(msg =>
                {
                    logBox.AppendText(msg + "\n");
                    if (progressBar.Value < progressBar.Maximum)
                        progressBar.Value++;
                });

                try
                {
                    // Actual file movement with rules enabled
                    var rules = await _databaseService.GetAllRulesAsync();
                    var result = await _fileOrganizerService.OrganizeFilesWithRulesAsync(txtPath.Text, rules, progress);
                    MessageBox.Show($"✓ Successfully moved {result.ProcessedFiles} files!", "Organization Complete",
                        MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                finally
                {
                    btnOrganize.Enabled = true;
                }
            };

            btnStartWatch.Click += (s, e) =>
            {
                _fileOrganizerService.StartRealTimeWatching(txtPath.Text);
                logBox.AppendText("✓ Real-time watching started\n");
                btnStartWatch.Enabled = false;
                btnStopWatch.Enabled = true;
            };

            btnStopWatch.Click += (s, e) =>
            {
                _fileOrganizerService.StopRealTimeWatching();
                logBox.AppendText("✓ Real-time watching stopped\n");
                btnStartWatch.Enabled = true;
                btnStopWatch.Enabled = false;
            };

            btnScanNow.Click += async (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtPath.Text) || !Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Please select a valid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                btnScanNow.Enabled = false;
                progressBar.Visible = true;
                logBox.AppendText("\n=== MANUAL SCAN STARTED (DRY RUN) ===\n");
                logBox.AppendText("Note: This prevents accidental file movement. No files will be moved.\n\n");

                var files = Directory.GetFiles(txtPath.Text, "*", SearchOption.TopDirectoryOnly);
                progressBar.Maximum = files.Length > 0 ? files.Length : 1;
                progressBar.Value = 0;

                try
                {
                    // Scan files acts strictly as a dry run - we use get preview which calculates matches but doesn't move files
                    var rules = await _databaseService.GetAllRulesAsync();
                    var preview = await _fileOrganizerService.GetPreviewChangesAsync(txtPath.Text, rules);
                    
                    int matchCount = 0;
                    foreach (var p in preview)
                    {
                        logBox.AppendText($"[SCAN] {p.FileName}\n");
                        logBox.AppendText($"   -> Matches Category/Rule: {p.Category}\n");
                        logBox.AppendText($"   -> Would move to: {p.DestinationPath}\n");
                        if (progressBar.Value < progressBar.Maximum) progressBar.Value++;
                        matchCount++;
                    }

                    logBox.AppendText($"\n✓ Scan Complete: Filtered matched {matchCount} files. (Dry Run - nothing moved)\n");
                    MessageBox.Show($"✓ Scanned {matchCount} files! No files were accidentally moved.", "Scan Complete", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                catch (Exception ex)
                {
                    logBox.AppendText($"❌ Error: {ex.Message}\n");
                }
                finally
                {
                    btnScanNow.Enabled = true;
                }
            };

            var btnPreview = new Button
            {
                Text = "Preview Changes",
                Location = new Point(600, 55),
                Size = new Size(120, 35),
                BackColor = Color.FromArgb(255, 140, 0),
                ForeColor = Color.White
            };

            btnPreview.Click += async (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtPath.Text) || !Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Please select a valid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                btnPreview.Enabled = false;
                logBox.Clear();
                logBox.AppendText("🔍 Generating preview of changes...\n\n");

                try
                {
                    var preview = await _fileOrganizerService.GetPreviewChangesAsync(txtPath.Text);
                    
                    if (preview.Count == 0)
                    {
                        logBox.AppendText("No files to organize.\n");
                        MessageBox.Show("No files found to organize", "Preview", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }

                    long totalSize = 0;
                    int conflictCount = 0;

                    logBox.AppendText($"📋 Preview Summary:\n");
                    logBox.AppendText($"Total files to organize: {preview.Count}\n\n");

                    foreach (var change in preview)
                    {
                        totalSize += change.FileSize;
                        if (change.WillConflict) conflictCount++;

                        logBox.AppendText($"📄 {change.FileName}\n");
                        logBox.AppendText($"   Current: {change.CurrentPath}\n");
                        logBox.AppendText($"   → Destination: {change.DestinationPath}\n");
                        logBox.AppendText($"   Category: {change.Category}\n");
                        if (change.WillConflict)
                            logBox.AppendText($"   ⚠ Conflict! Strategy: {change.ConflictResolution}\n");
                        logBox.AppendText("\n");
                    }

                    logBox.AppendText($"\n📊 Total Size: {FormatBytes(totalSize)}\n");
                    logBox.AppendText($"⚠ Conflicts: {conflictCount}\n");
                    logBox.AppendText($"\n✓ Preview generated successfully. Click 'Organize Now' to apply these changes.\n");
                }
                catch (Exception ex)
                {
                    logBox.AppendText($"❌ Error generating preview: {ex.Message}\n");
                    MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                finally
                {
                    btnPreview.Enabled = true;
                }
            };

            tab.Controls.AddRange(new Control[] { lblPath, txtPath, btnBrowse, btnOrganize, btnStartWatch, btnStopWatch, btnScanNow, btnPreview, progressBar, logBox });
            return tab;
        }

        private TabPage CreateStatisticsTab()
        {
            var tab = new TabPage { Text = "📊 Statistics", Padding = new Padding(10) };

            var lblPath = new Label { Text = "Analyze Folder:", Location = new Point(10, 15), AutoSize = true };
            var txtPath = new TextBox
            {
                Location = new Point(120, 12),
                Size = new Size(800, 25),
                Text = _config.DefaultSourcePath
            };

            var btnBrowse = new Button
            {
                Text = "Browse...",
                Location = new Point(930, 12),
                Size = new Size(100, 25)
            };
            btnBrowse.Click += (s, e) =>
            {
                using (var dialog = new FolderBrowserDialog { SelectedPath = txtPath.Text })
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                        txtPath.Text = dialog.SelectedPath;
                }
            };

            var btnAnalyze = new Button
            {
                Text = "Analyze",
                Location = new Point(10, 55),
                Size = new Size(120, 35),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White,
                Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold)
            };

            var statsBox = new RichTextBox
            {
                Location = new Point(10, 100),
                Size = new Size(1020, 490),
                ReadOnly = true,
                BackColor = Color.WhiteSmoke
            };

            btnAnalyze.Click += async (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtPath.Text) || !Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Please select a valid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                btnAnalyze.Enabled = false;
                statsBox.Clear();
                statsBox.AppendText("Analyzing folder...\n\n");

                try
                {
                    var stats = await _statisticsService.GetFolderStatisticsAsync(txtPath.Text);
                    var storage = await _statisticsService.GetStorageByCategoryAsync(txtPath.Text);
                    var largest = await _statisticsService.GetLargestFoldersAsync(txtPath.Text, 5);

                    statsBox.Clear();
                    statsBox.AppendText($"📁 FOLDER ANALYSIS: {txtPath.Text}\n");
                    statsBox.AppendText(new string('=', 100) + "\n\n");

                    statsBox.AppendText($"Total Size: {FolderStatistics.FormatBytes(stats.TotalSize)}\n");
                    statsBox.AppendText($"Total Files: {stats.TotalFiles}\n");
                    statsBox.AppendText($"Total Folders: {stats.TotalFolders}\n");
                    statsBox.AppendText($"Last Scanned: {stats.LastUpdated:yyyy-MM-dd HH:mm:ss}\n\n");

                    statsBox.AppendText("FILES BY CATEGORY:\n");
                    statsBox.AppendText(new string('-', 50) + "\n");
                    foreach (var cat in stats.FilesByCategory.OrderByDescending(x => x.Value))
                    {
                        var catStorage = storage.ContainsKey(cat.Key) ? FolderStatistics.FormatBytes(storage[cat.Key]) : "0 B";
                        statsBox.AppendText($"  {cat.Key,-20} {cat.Value,6} files    {catStorage,15}\n");
                    }

                    statsBox.AppendText("\nLARGEST FOLDERS:\n");
                    statsBox.AppendText(new string('-', 50) + "\n");
                    foreach (var folder in largest)
                    {
                        statsBox.AppendText($"  {folder.folder,-40} {FolderStatistics.FormatBytes(folder.size),15}\n");
                    }
                }
                catch (Exception ex)
                {
                    statsBox.AppendText($"❌ Error: {ex.Message}");
                }
                finally
                {
                    btnAnalyze.Enabled = true;
                }
            };

            var btnExportReport = new Button
            {
                Text = "Export Report",
                Location = new Point(140, 55),
                Size = new Size(120, 35),
                BackColor = Color.FromArgb(34, 139, 34),
                ForeColor = Color.White,
                Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold)
            };

            btnExportReport.Click += (s, e) =>
            {
                using (var dialog = new SaveFileDialog { Filter = "Text Files|*.txt|CSV Files|*.csv", DefaultExt = ".txt", FileName = $"FileOrganizer_Report_{DateTime.Now:yyyy-MM-dd}.txt" })
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                    {
                        try
                        {
                            System.IO.File.WriteAllText(dialog.FileName, statsBox.Text);
                            MessageBox.Show($"✓ Report exported to {Path.GetFileName(dialog.FileName)}", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }
            };

            tab.Controls.AddRange(new Control[] { lblPath, txtPath, btnBrowse, btnAnalyze, btnExportReport, statsBox });
            return tab;
        }

        private TabPage CreateRulesTab()
        {
            var tab = new TabPage { Text = "⚙️ Custom Rules", Padding = new Padding(10) };

            var lblRuleName = new Label { Text = "Rule Name:", Location = new Point(10, 15), AutoSize = true };
            var txtRuleName = new TextBox { Location = new Point(120, 12), Size = new Size(250, 25) };

            var lblPattern = new Label { Text = "File Pattern:", Location = new Point(10, 45), AutoSize = true };
            var txtPattern = new TextBox { Location = new Point(120, 42), Size = new Size(250, 25), Text = "*.pdf" };

            var lblFolder = new Label { Text = "Target Folder:", Location = new Point(10, 75), AutoSize = true };
            var txtFolder = new TextBox { Location = new Point(120, 72), Size = new Size(250, 25) };

            var chkKeyword = new CheckBox { Text = "Keyword Rule", Location = new Point(10, 105), AutoSize = true };
            var lblKeyword = new Label { Text = "Keyword:", Location = new Point(10, 135), AutoSize = true };
            var txtKeyword = new TextBox { Location = new Point(120, 132), Size = new Size(250, 25) };

            chkKeyword.CheckedChanged += (s, e) =>
            {
                txtPattern.Enabled = !chkKeyword.Checked;
                txtFolder.Enabled = !chkKeyword.Checked;
                txtKeyword.Enabled = chkKeyword.Checked;
            };

            var btnBrowse = new Button { Text = "Browse...", Location = new Point(380, 72), Size = new Size(80, 25) };
            btnBrowse.Click += (s, e) =>
            {
                using (var dialog = new FolderBrowserDialog())
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                        txtFolder.Text = dialog.SelectedPath;
                }
            };

            var btnAddRule = new Button
            {
                Text = "Add Rule",
                Location = new Point(120, 165),
                Size = new Size(100, 30),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White
            };

            var rulesList = new ListBox
            {
                Location = new Point(10, 205),
                Size = new Size(450, 285)
            };

            var btnDeleteRule = new Button
            {
                Text = "Delete Selected",
                Location = new Point(10, 500),
                Size = new Size(120, 30),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            var infoBox = new RichTextBox
            {
                Location = new Point(480, 205),
                Size = new Size(540, 325),
                ReadOnly = true,
                BackColor = Color.WhiteSmoke
            };

            Func<Task> RefreshRules = async () =>
            {
                var rules = await _databaseService.GetAllRulesAsync();
                rulesList.Items.Clear();
                foreach (var rule in rules)
                {
                    string display = rule.IsKeywordRule 
                        ? $"{(rule.Enabled ? "✓" : "✗")} {rule.RuleName} (Keyword: {rule.Keyword})"
                        : $"{(rule.Enabled ? "✓" : "✗")} {rule.RuleName} ({rule.FilePattern})";
                    rulesList.Items.Add(display);
                }
            };

            btnAddRule.Click += async (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtRuleName.Text))
                {
                    MessageBox.Show("Please enter a rule name", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                if (chkKeyword.Checked && string.IsNullOrWhiteSpace(txtKeyword.Text))
                {
                    MessageBox.Show("Please enter a keyword for keyword rule", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                var rule = new OrganizationRule
                {
                    RuleName = txtRuleName.Text,
                    FilePattern = chkKeyword.Checked ? "*.*" : txtPattern.Text,
                    TargetFolder = chkKeyword.Checked ? "" : txtFolder.Text,
                    IsKeywordRule = chkKeyword.Checked,
                    Keyword = chkKeyword.Checked ? txtKeyword.Text : null,
                    Enabled = true
                };

                await _databaseService.AddOrUpdateRuleAsync(rule);
                await RefreshRules();
                MessageBox.Show("✓ Rule added successfully!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

                txtRuleName.Clear();
                txtPattern.Text = "*.pdf";
                txtFolder.Clear();
                chkKeyword.Checked = false;
                txtKeyword.Clear();
            };

            rulesList.SelectedIndexChanged += async (s, e) =>
            {
                if (rulesList.SelectedIndex >= 0)
                {
                    var rules = await _databaseService.GetAllRulesAsync();
                    var rule = rules[rulesList.SelectedIndex];

                    infoBox.Clear();
                    infoBox.AppendText($"Rule: {rule.RuleName}\n");
                    infoBox.AppendText(new string('=', 50) + "\n\n");
                    infoBox.AppendText($"Status: {(rule.Enabled ? "✓ Enabled" : "✗ Disabled")}\n");
                    if (rule.IsKeywordRule)
                    {
                        infoBox.AppendText($"Type: Keyword Rule\n");
                        infoBox.AppendText($"Keyword: {rule.Keyword}\n");
                        infoBox.AppendText($"Target Folder: Auto-generated ({rule.Keyword})\n");
                    }
                    else
                    {
                        infoBox.AppendText($"File Pattern: {rule.FilePattern}\n");
                        infoBox.AppendText($"Target Folder: {rule.TargetFolder}\n");
                    }
                    infoBox.AppendText($"Min Size: {FolderStatistics.FormatBytes(rule.MinSizeBytes)}\n");
                    infoBox.AppendText($"Max Size: {FolderStatistics.FormatBytes(rule.MaxSizeBytes)}\n");
                    infoBox.AppendText($"Created: {rule.CreatedDate:yyyy-MM-dd HH:mm:ss}\n");
                }
            };

            btnDeleteRule.Click += async (s, e) =>
            {
                if (rulesList.SelectedIndex >= 0)
                {
                    var rules = await _databaseService.GetAllRulesAsync();
                    if (MessageBox.Show("Delete this rule?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        await _databaseService.DeleteRuleAsync(rules[rulesList.SelectedIndex].Id);
                        await RefreshRules();
                    }
                }
            };

            _ = RefreshRules();

            tab.Controls.AddRange(new Control[] { lblRuleName, txtRuleName, lblPattern, txtPattern, lblFolder, txtFolder, chkKeyword, lblKeyword, txtKeyword, btnBrowse, btnAddRule, rulesList, btnDeleteRule, infoBox });
            return tab;
        }

        private TabPage CreateCleanupTab()
        {
            var tab = new TabPage { Text = "🧹 Cleanup Tools", Padding = new Padding(10) };

            var lblPath = new Label { Text = "Target Folder:", Location = new Point(10, 15), AutoSize = true };
            var txtPath = new TextBox
            {
                Location = new Point(120, 12),
                Size = new Size(800, 25),
                Text = _config.DefaultSourcePath
            };

            var btnBrowse = new Button
            {
                Text = "Browse...",
                Location = new Point(930, 12),
                Size = new Size(100, 25)
            };
            btnBrowse.Click += (s, e) =>
            {
                using (var dialog = new FolderBrowserDialog { SelectedPath = txtPath.Text })
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                        txtPath.Text = dialog.SelectedPath;
                }
            };

            var lblDays = new Label { Text = "Delete files older than (days):", Location = new Point(10, 50), AutoSize = true };
            var spinDays = new NumericUpDown { Location = new Point(250, 47), Value = 30, Minimum = 1, Maximum = 365 };

            // Row 1: Remove Old Files
            var btnRemoveOldRecycle = new Button
            {
                Text = "Remove Old → Recycle",
                Location = new Point(10, 85),
                Size = new Size(160, 35),
                BackColor = Color.FromArgb(70, 130, 180),
                ForeColor = Color.White
            };

            var btnRemoveOldPermanent = new Button
            {
                Text = "Remove Old → Delete",
                Location = new Point(180, 85),
                Size = new Size(160, 35),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            // Row 2: Remove Empty Folders
            var btnRemoveEmptyRecycle = new Button
            {
                Text = "Empty Folders → Recycle",
                Location = new Point(10, 125),
                Size = new Size(160, 35),
                BackColor = Color.FromArgb(70, 130, 180),
                ForeColor = Color.White
            };

            var btnRemoveEmptyPermanent = new Button
            {
                Text = "Empty Folders → Delete",
                Location = new Point(180, 125),
                Size = new Size(160, 35),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            // Row 3: Clean Duplicates
            var btnCleanDuplicatesRecycle = new Button
            {
                Text = "Duplicates → Recycle",
                Location = new Point(10, 165),
                Size = new Size(160, 35),
                BackColor = Color.FromArgb(70, 130, 180),
                ForeColor = Color.White
            };

            var btnCleanDuplicatesPermanent = new Button
            {
                Text = "Duplicates → Delete",
                Location = new Point(180, 165),
                Size = new Size(160, 35),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            var resultBox = new RichTextBox
            {
                Location = new Point(10, 210),
                Size = new Size(1020, 380),
                ReadOnly = true,
                BackColor = Color.WhiteSmoke
            };

            btnRemoveOldRecycle.Click += async (s, e) =>
            {
                if (!Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Invalid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                resultBox.Clear();
                resultBox.AppendText($"Removing files older than {spinDays.Value} days (to Recycle Bin)...\n\n");

                var progress = new Progress<string>(msg => resultBox.AppendText(msg + "\n"));
                var count = await _cleanupService.RemoveOldFilesAsync(txtPath.Text, (int)spinDays.Value, DeletionMode.RecycleBin, progress);

                resultBox.AppendText($"\n✓ Removed {count} old files to Recycle Bin");
            };

            btnRemoveOldPermanent.Click += async (s, e) =>
            {
                if (!Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Invalid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                var result = MessageBox.Show(
                    "Are you sure? Files will be PERMANENTLY DELETED and cannot be recovered!",
                    "Permanent Delete Confirmation",
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Warning);

                if (result != DialogResult.Yes) return;

                resultBox.Clear();
                resultBox.AppendText($"Permanently deleting files older than {spinDays.Value} days...\n\n");

                var progress = new Progress<string>(msg => resultBox.AppendText(msg + "\n"));
                var count = await _cleanupService.RemoveOldFilesAsync(txtPath.Text, (int)spinDays.Value, DeletionMode.Permanent, progress);

                resultBox.AppendText($"\n✓ Permanently deleted {count} old files");
            };

            btnRemoveEmptyRecycle.Click += async (s, e) =>
            {
                if (!Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Invalid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                resultBox.Clear();
                resultBox.AppendText("Removing empty folders (to Recycle Bin)...\n\n");

                var progress = new Progress<string>(msg => resultBox.AppendText(msg + "\n"));
                var count = await _cleanupService.RemoveEmptyFoldersAsync(txtPath.Text, DeletionMode.RecycleBin, progress);

                resultBox.AppendText($"\n✓ Removed {count} empty folders to Recycle Bin");
            };

            btnRemoveEmptyPermanent.Click += async (s, e) =>
            {
                if (!Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Invalid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                var result = MessageBox.Show(
                    "Are you sure? Folders will be PERMANENTLY DELETED and cannot be recovered!",
                    "Permanent Delete Confirmation",
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Warning);

                if (result != DialogResult.Yes) return;

                resultBox.Clear();
                resultBox.AppendText("Permanently deleting empty folders...\n\n");

                var progress = new Progress<string>(msg => resultBox.AppendText(msg + "\n"));
                var count = await _cleanupService.RemoveEmptyFoldersAsync(txtPath.Text, DeletionMode.Permanent, progress);

                resultBox.AppendText($"\n✓ Permanently deleted {count} empty folders");
            };

            btnCleanDuplicatesRecycle.Click += async (s, e) =>
            {
                if (!Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Invalid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                resultBox.Clear();
                resultBox.AppendText("Scanning for duplicates and cleaning up (to Recycle Bin)...\n\n");

                var progress = new Progress<string>(msg => resultBox.AppendText(msg + "\n"));
                var freed = await _cleanupService.CleanupDuplicatesAsync(txtPath.Text, DeletionMode.RecycleBin, progress);

                resultBox.AppendText($"\n✓ Freed {FolderStatistics.FormatBytes(freed)} of disk space (to Recycle Bin)");
            };

            btnCleanDuplicatesPermanent.Click += async (s, e) =>
            {
                if (!Directory.Exists(txtPath.Text))
                {
                    MessageBox.Show("Invalid folder", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                var result = MessageBox.Show(
                    "Are you sure? Duplicates will be PERMANENTLY DELETED and cannot be recovered!",
                    "Permanent Delete Confirmation",
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Warning);

                if (result != DialogResult.Yes) return;

                resultBox.Clear();
                resultBox.AppendText("Permanently deleting duplicate files...\n\n");

                var progress = new Progress<string>(msg => resultBox.AppendText(msg + "\n"));
                var freed = await _cleanupService.CleanupDuplicatesAsync(txtPath.Text, DeletionMode.Permanent, progress);

                resultBox.AppendText($"\n✓ Permanently deleted duplicates, freed {FolderStatistics.FormatBytes(freed)} of disk space");
            };

            tab.Controls.AddRange(new Control[] { 
                lblPath, txtPath, btnBrowse, lblDays, spinDays, 
                btnRemoveOldRecycle, btnRemoveOldPermanent,
                btnRemoveEmptyRecycle, btnRemoveEmptyPermanent,
                btnCleanDuplicatesRecycle, btnCleanDuplicatesPermanent,
                resultBox 
            });
            return tab;
        }

        private TabPage CreateSchedulerTab()
        {
            var tab = new TabPage { Text = "⏰ Scheduler", Padding = new Padding(10) };

            var lblTaskName = new Label { Text = "Task Name:", Location = new Point(10, 15), AutoSize = true };
            var txtTaskName = new TextBox { Location = new Point(120, 12), Size = new Size(300, 25) };

            var lblFolder = new Label { Text = "Source Folder:", Location = new Point(10, 45), AutoSize = true };
            var txtFolder = new TextBox { Location = new Point(120, 42), Size = new Size(300, 25) };

            var btnBrowse = new Button { Text = "Browse...", Location = new Point(430, 42), Size = new Size(80, 25) };
            btnBrowse.Click += (s, e) =>
            {
                using (var dialog = new FolderBrowserDialog())
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                        txtFolder.Text = dialog.SelectedPath;
                }
            };

            var chkCleanup = new CheckBox { Text = "Remove Old Files", Location = new Point(10, 75), AutoSize = true, Checked = true };
            var chkDuplicates = new CheckBox { Text = "Clean Duplicates", Location = new Point(200, 75), AutoSize = true };
            var chkEmpty = new CheckBox { Text = "Remove Empty Folders", Location = new Point(400, 75), AutoSize = true };

            var lblDay = new Label { Text = "Day:", Location = new Point(10, 105), AutoSize = true };
            var cmbDay = new ComboBox { Location = new Point(50, 102), Size = new Size(150, 25), DropDownStyle = ComboBoxStyle.DropDownList };
            foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))
                cmbDay.Items.Add(day);
            cmbDay.SelectedIndex = 0;

            var lblTime = new Label { Text = "Time (HH:mm):", Location = new Point(220, 105), AutoSize = true };
            var txtTime = new TextBox { Location = new Point(320, 102), Size = new Size(100, 25), Text = "02:00" };

            var btnAddTask = new Button
            {
                Text = "Add Scheduled Task",
                Location = new Point(10, 140),
                Size = new Size(150, 35),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White
            };

            var tasksList = new ListBox
            {
                Location = new Point(10, 185),
                Size = new Size(450, 305)
            };

            var btnDeleteTask = new Button
            {
                Text = "Delete Selected",
                Location = new Point(10, 500),
                Size = new Size(120, 30),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            var infoBox = new RichTextBox
            {
                Location = new Point(480, 185),
                Size = new Size(540, 345),
                ReadOnly = true,
                BackColor = Color.WhiteSmoke
            };

            Func<Task> RefreshTasks = async () =>
            {
                var tasks = await _databaseService.GetAllScheduledTasksAsync();
                tasksList.Items.Clear();
                foreach (var task in tasks)
                    tasksList.Items.Add($"{(task.Enabled ? "✓" : "✗")} {task.TaskName}");
            };

            btnAddTask.Click += async (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtTaskName.Text) || string.IsNullOrWhiteSpace(txtFolder.Text))
                {
                    MessageBox.Show("Please fill all fields", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                if (!TimeSpan.TryParse(txtTime.Text, out var time))
                {
                    MessageBox.Show("Invalid time format", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                var task = new ScheduledTask
                {
                    TaskName = txtTaskName.Text,
                    SourceFolder = txtFolder.Text,
                    EnableCleanup = chkCleanup.Checked,
                    EnableDuplicateFinder = chkDuplicates.Checked,
                    EnableEmptyFolderRemover = chkEmpty.Checked,
                    ScheduleDay = (DayOfWeek)cmbDay.SelectedItem,
                    ScheduleTime = time,
                    Enabled = true
                };

                await _databaseService.AddOrUpdateScheduledTaskAsync(task);
                await RefreshTasks();
                MessageBox.Show("✓ Task scheduled!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

                txtTaskName.Clear();
                txtFolder.Clear();
            };

            tasksList.SelectedIndexChanged += async (s, e) =>
            {
                if (tasksList.SelectedIndex >= 0)
                {
                    var tasks = await _databaseService.GetAllScheduledTasksAsync();
                    var task = tasks[tasksList.SelectedIndex];

                    infoBox.Clear();
                    infoBox.AppendText($"Task: {task.TaskName}\n");
                    infoBox.AppendText(new string('=', 50) + "\n\n");
                    infoBox.AppendText($"Status: {(task.Enabled ? "✓ Enabled" : "✗ Disabled")}\n");
                    infoBox.AppendText($"Folder: {task.SourceFolder}\n");
                    infoBox.AppendText($"Schedule: {task.ScheduleDay} at {task.ScheduleTime:hh\\:mm}\n\n");
                    infoBox.AppendText("Operations:\n");
                    if (task.EnableCleanup) infoBox.AppendText("  ✓ Remove old files\n");
                    if (task.EnableDuplicateFinder) infoBox.AppendText("  ✓ Clean duplicates\n");
                    if (task.EnableEmptyFolderRemover) infoBox.AppendText("  ✓ Remove empty folders\n");
                    if (task.LastExecuted != DateTime.MinValue)
                        infoBox.AppendText($"\nLast Executed: {task.LastExecuted:yyyy-MM-dd HH:mm:ss}\n");
                }
            };

            btnDeleteTask.Click += async (s, e) =>
            {
                if (tasksList.SelectedIndex >= 0)
                {
                    var tasks = await _databaseService.GetAllScheduledTasksAsync();
                    if (MessageBox.Show("Delete this task?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        await _databaseService.DeleteScheduledTaskAsync(tasks[tasksList.SelectedIndex].Id);
                        await RefreshTasks();
                    }
                }
            };

            _ = RefreshTasks();

            tab.Controls.AddRange(new Control[] { lblTaskName, txtTaskName, lblFolder, txtFolder, btnBrowse, chkCleanup, chkDuplicates, chkEmpty, lblDay, cmbDay, lblTime, txtTime, btnAddTask, tasksList, btnDeleteTask, infoBox });
            return tab;
        }

        private TabPage CreateHistoryTab()
        {
            var tab = new TabPage { Text = "📜 History & Undo", Padding = new Padding(10) };

            // Filter Controls
            var lblFilters = new Label { Text = "Filters:", Location = new Point(10, 15), AutoSize = true, Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold) };
            
            var lblDateFrom = new Label { Text = "From:", Location = new Point(10, 40), AutoSize = true };
            var dtpDateFrom = new DateTimePicker { Location = new Point(50, 37), Size = new Size(150, 25), Value = DateTime.Now.AddDays(-30) };
            
            var lblDateTo = new Label { Text = "To:", Location = new Point(210, 40), AutoSize = true };
            var dtpDateTo = new DateTimePicker { Location = new Point(240, 37), Size = new Size(150, 25), Value = DateTime.Now };
            
            var lblOperationType = new Label { Text = "Operation:", Location = new Point(410, 40), AutoSize = true };
            var cmbOperation = new ComboBox { Location = new Point(480, 37), Size = new Size(150, 25), DropDownStyle = ComboBoxStyle.DropDownList };
            cmbOperation.Items.AddRange(new object[] { "All", "MOVE", "DELETE", "UNDO" });
            cmbOperation.SelectedIndex = 0;

            var lblStatus = new Label { Text = "Status:", Location = new Point(650, 40), AutoSize = true };
            var cmbStatus = new ComboBox { Location = new Point(700, 37), Size = new Size(120, 25), DropDownStyle = ComboBoxStyle.DropDownList };
            cmbStatus.Items.AddRange(new object[] { "All", "Success", "Failed" });
            cmbStatus.SelectedIndex = 0;

            var btnFilter = new Button
            {
                Text = "Apply Filter",
                Location = new Point(830, 35),
                Size = new Size(100, 30),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White
            };

            var btnExport = new Button
            {
                Text = "Export to CSV",
                Location = new Point(940, 35),
                Size = new Size(100, 30),
                BackColor = Color.FromArgb(34, 139, 34),
                ForeColor = Color.White
            };

            var btnRefresh = new Button
            {
                Text = "Refresh",
                Location = new Point(10, 75),
                Size = new Size(100, 30),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White
            };

            var btnUndo = new Button
            {
                Text = "Undo Last",
                Location = new Point(120, 75),
                Size = new Size(100, 30),
                BackColor = Color.FromArgb(255, 165, 0),
                ForeColor = Color.White
            };

            var btnClearHistory = new Button
            {
                Text = "Clear History",
                Location = new Point(230, 75),
                Size = new Size(110, 30),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            var historyGrid = new DataGridView
            {
                Location = new Point(10, 115),
                Size = new Size(1020, 375),
                ReadOnly = true,
                AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells,
                AllowUserToAddRows = false
            };

            historyGrid.Columns.Add("fileName", "File Name");
            historyGrid.Columns.Add("baseName", "File (base)");
            historyGrid.Columns.Add("ext", "Extension");
            historyGrid.Columns.Add("type", "Type");
            historyGrid.Columns.Add("sourceFull", "Source (Full)");
            historyGrid.Columns.Add("sourceFolder", "Source Folder");
            historyGrid.Columns.Add("sourceDrive", "Source Drive");
            historyGrid.Columns.Add("destinationFull", "Destination (Full)");
            historyGrid.Columns.Add("destinationFolder", "Destination Folder");
            historyGrid.Columns.Add("destinationDrive", "Destination Drive");
            historyGrid.Columns.Add("timestamp", "Date/Time");
            historyGrid.Columns.Add("status", "Status");

            Func<Task> RefreshWithFilters = async () =>
            {
                try
                {
                    DateTime? dateFrom = dtpDateFrom.Checked ? dtpDateFrom.Value : (DateTime?)null;
                    DateTime? dateTo = dtpDateTo.Checked ? dtpDateTo.Value : (DateTime?)null;
                    string operationType = cmbOperation.SelectedIndex == 0 ? null : cmbOperation.SelectedItem.ToString();
                    bool? success = cmbStatus.SelectedIndex == 0 ? (bool?)null : (cmbStatus.SelectedIndex == 1);

                    var history = await _databaseService.GetFilteredHistoryAsync(dateFrom, dateTo, operationType, success, 500);
                    historyGrid.Rows.Clear();

                    foreach (var op in history.OrderByDescending(x => x.Timestamp))
                    {
                        var fileName = op.FileName ?? string.Empty;
                        var baseName = Path.GetFileNameWithoutExtension(fileName);
                        var ext = Path.GetExtension(fileName);

                        var lower = (ext ?? string.Empty).ToLowerInvariant();
                        string type = "Other";
                        var imageExts = new[] { ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".tiff" };
                        var docExts = new[] { ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".txt", ".md" };
                        if (imageExts.Contains(lower)) type = "Image";
                        else if (docExts.Contains(lower)) type = "Document";

                        string sourceFull = op.SourcePath ?? string.Empty;
                        try
                        {
                            if (!string.IsNullOrWhiteSpace(sourceFull) && !sourceFull.EndsWith(fileName, StringComparison.OrdinalIgnoreCase))
                                sourceFull = Path.Combine(sourceFull, fileName);
                        }
                        catch { }

                        string sourceFolder = string.Empty;
                        string sourceDrive = string.Empty;
                        try
                        {
                            sourceFolder = !string.IsNullOrWhiteSpace(sourceFull) ? Path.GetDirectoryName(sourceFull) ?? op.SourcePath ?? string.Empty : op.SourcePath ?? string.Empty;
                            sourceDrive = !string.IsNullOrWhiteSpace(sourceFolder) ? Path.GetPathRoot(sourceFolder) ?? string.Empty : string.Empty;
                        }
                        catch { sourceFolder = op.SourcePath ?? string.Empty; }

                        string destFull = op.DestinationPath ?? string.Empty;
                        try
                        {
                            if (!string.IsNullOrWhiteSpace(destFull) && !destFull.EndsWith(fileName, StringComparison.OrdinalIgnoreCase))
                                destFull = Path.Combine(destFull, fileName);
                        }
                        catch { }

                        string destFolder = string.Empty;
                        string destDrive = string.Empty;
                        try
                        {
                            destFolder = !string.IsNullOrWhiteSpace(destFull) ? Path.GetDirectoryName(destFull) ?? op.DestinationPath ?? string.Empty : op.DestinationPath ?? string.Empty;
                            destDrive = !string.IsNullOrWhiteSpace(destFolder) ? Path.GetPathRoot(destFolder) ?? string.Empty : string.Empty;
                        }
                        catch { destFolder = op.DestinationPath ?? string.Empty; }

                        historyGrid.Rows.Add(
                            fileName, baseName, ext, type,
                            sourceFull, sourceFolder, sourceDrive,
                            destFull, destFolder, destDrive,
                            op.Timestamp.ToString("yyyy-MM-dd HH:mm:ss"),
                            op.Success ? "✓ Success" : "✗ Failed"
                        );
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            };

            btnRefresh.Click += async (s, e) => await RefreshWithFilters();

            btnFilter.Click += async (s, e) => await RefreshWithFilters();

            btnExport.Click += async (s, e) =>
            {
                using (var dialog = new SaveFileDialog { Filter = "CSV Files|*.csv", DefaultExt = ".csv", FileName = $"FileOrganizer_History_{DateTime.Now:yyyy-MM-dd}.csv" })
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                    {
                        try
                        {
                            DateTime? dateFrom = dtpDateFrom.Checked ? dtpDateFrom.Value : (DateTime?)null;
                            DateTime? dateTo = dtpDateTo.Checked ? dtpDateTo.Value : (DateTime?)null;
                            string operationType = cmbOperation.SelectedIndex == 0 ? null : cmbOperation.SelectedItem.ToString();

                            await _databaseService.ExportHistoryToCsvAsync(dialog.FileName, dateFrom, dateTo, operationType);
                            MessageBox.Show($"✓ Exported to {dialog.FileName}", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }
            };

            btnUndo.Click += async (s, e) =>
            {
                if (MessageBox.Show("Undo the last operation?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    try
                    {
                        await _databaseService.UndoLastOperationAsync();
                        MessageBox.Show("✓ Operation undone!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        await RefreshWithFilters();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            };

            btnClearHistory.Click += async (s, e) =>
            {
                if (MessageBox.Show("Clear all history? (older than 90 days)", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    try
                    {
                        await _databaseService.ClearOldHistoryAsync(90);
                        MessageBox.Show("✓ Old history cleared!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        await RefreshWithFilters();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show($"Error: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            };

            _ = Task.Run(() => btnRefresh.PerformClick());

            tab.Controls.AddRange(new Control[] { lblFilters, lblDateFrom, dtpDateFrom, lblDateTo, dtpDateTo, lblOperationType, cmbOperation, lblStatus, cmbStatus, btnFilter, btnExport, btnRefresh, btnUndo, btnClearHistory, historyGrid });
            return tab;
        }

        private TabPage CreateSettingsTab()
        {
            var tab = new TabPage { Text = "⚙️ Settings", Padding = new Padding(10) };

            // Forbidden Folders Section
            var lblForbidden = new Label { Text = "Forbidden Folders (never organize):", Location = new Point(10, 15), AutoSize = true, Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold) };
            
            var lstForbidden = new ListBox
            {
                Location = new Point(10, 40),
                Size = new Size(500, 150)
            };

            // Load existing forbidden folders
            foreach (var folder in _config.ForbiddenFolders)
                lstForbidden.Items.Add(folder);

            var txtForbiddenFolder = new TextBox
            {
                Location = new Point(10, 200),
                Size = new Size(400, 25),
                PlaceholderText = "Enter folder path to forbid..."
            };

            var btnAddForbidden = new Button
            {
                Text = "Add Folder",
                Location = new Point(420, 200),
                Size = new Size(90, 25),
                BackColor = Color.FromArgb(34, 139, 34),
                ForeColor = Color.White
            };

            var btnRemoveForbidden = new Button
            {
                Text = "Remove Selected",
                Location = new Point(520, 200),
                Size = new Size(100, 25),
                BackColor = Color.FromArgb(220, 20, 60),
                ForeColor = Color.White
            };

            btnAddForbidden.Click += (s, e) =>
            {
                if (string.IsNullOrWhiteSpace(txtForbiddenFolder.Text))
                {
                    MessageBox.Show("Please enter a folder path", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                var path = txtForbiddenFolder.Text.Trim();
                if (!Directory.Exists(path))
                {
                    MessageBox.Show("Folder does not exist", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                if (!_config.ForbiddenFolders.Contains(path))
                {
                    _config.ForbiddenFolders.Add(path);
                    lstForbidden.Items.Add(path);
                    txtForbiddenFolder.Clear();
                    MessageBox.Show("✓ Folder added to forbidden list", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    MessageBox.Show("Folder already in list", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            };

            btnRemoveForbidden.Click += (s, e) =>
            {
                if (lstForbidden.SelectedItem != null)
                {
                    var folder = lstForbidden.SelectedItem.ToString();
                    _config.ForbiddenFolders.Remove(folder);
                    lstForbidden.Items.Remove(folder);
                    MessageBox.Show("✓ Folder removed from forbidden list", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            };

            // Collision Strategy Section
            var lblCollisionStrategy = new Label { Text = "Default Collision Strategy:", Location = new Point(10, 240), AutoSize = true, Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold) };
            
            var cmbCollisionStrategy = new ComboBox
            {
                Location = new Point(10, 265),
                Size = new Size(300, 25),
                DropDownStyle = ComboBoxStyle.DropDownList
            };

            cmbCollisionStrategy.Items.AddRange(new object[] { "Skip", "Overwrite", "Rename with Suffix", "Move to Conflicts Folder" });
            cmbCollisionStrategy.SelectedIndex = (int)_config.DefaultCollisionStrategy;

            cmbCollisionStrategy.SelectedValueChanged += (s, e) =>
            {
                _config.DefaultCollisionStrategy = (CollisionStrategy)cmbCollisionStrategy.SelectedIndex;
                MessageBox.Show("✓ Collision strategy updated", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
            };

            // Undo History Limit Section
            var lblUndoLimit = new Label { Text = "Max Undo History Operations:", Location = new Point(10, 310), AutoSize = true, Font = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Bold) };
            
            var numUndoLimit = new NumericUpDown
            {
                Location = new Point(10, 335),
                Size = new Size(200, 25),
                Minimum = 50,
                Maximum = 10000,
                Value = _config.MaxUndoHistoryOperations
            };

            var btnSaveUndoLimit = new Button
            {
                Text = "Save Limit",
                Location = new Point(220, 335),
                Size = new Size(90, 25),
                BackColor = Color.FromArgb(0, 122, 204),
                ForeColor = Color.White
            };

            btnSaveUndoLimit.Click += async (s, e) =>
            {
                _config.MaxUndoHistoryOperations = (int)numUndoLimit.Value;
                await _databaseService.CleanupOldHistoryByLimitAsync(_config.MaxUndoHistoryOperations);
                MessageBox.Show($"✓ Undo limit set to {_config.MaxUndoHistoryOperations} operations", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
            };

            tab.Controls.AddRange(new Control[] 
            {
                lblForbidden, lstForbidden, txtForbiddenFolder, btnAddForbidden, btnRemoveForbidden,
                lblCollisionStrategy, cmbCollisionStrategy,
                lblUndoLimit, numUndoLimit, btnSaveUndoLimit
            });

            return tab;
        }

        private string FormatBytes(long bytes)
        {
            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
            double len = bytes;
            int order = 0;
            while (len >= 1024 && order < sizes.Length - 1)
            {
                order++;
                len = len / 1024;
            }
            return $"{len:0.##} {sizes[order]}";
        }
    }
}