MainWindow.xaml.cs

using System.Collections.ObjectModel;
using System.IO;
using System.Windows;
using CloudIgnore.Models;
using CloudIgnore.Services;
using Microsoft.Win32;

namespace CloudIgnore;

public partial class MainWindow : Window
{
    private readonly DropboxIgnoreService _ignoreService = new();
    private readonly GitignoreParser _gitignoreParser = new();
    private readonly ObservableCollection<IgnoreProfile> _profiles = new();
    private readonly ObservableCollection<ScanMatch> _results = new();
    private readonly DropboxLocator _dropboxLocator = new();
    private readonly AppSettings _settings = AppSettings.Load();

    // No default root. On startup the app tries the folder used last time, then
    // auto-detects Dropbox, and only asks the user if neither works out.
    private string _rootPath = string.Empty;
    private IgnoreProfile _activeProfile;

    public MainWindow()
    {
        InitializeComponent();

        _profiles.Add(IgnoreProfile.DotNetBuildFolders());
        _profiles.Add(IgnoreProfile.WebNodeFolders());
        _activeProfile = _profiles[0];

        ProfileList.ItemsSource = _profiles;
        ProfileList.SelectedIndex = 0;
        ResultsGrid.ItemsSource = _results;

        ShowRootPath();
        UpdateStats();
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        // 1. The folder chosen last time, if it's still there.
        if (!string.IsNullOrWhiteSpace(_settings.RootPath) && Directory.Exists(_settings.RootPath))
        {
            SetRoot(_settings.RootPath, "Remembered from your last session.", save: false);
            return;
        }

        // 2. Dropbox's own settings, or a folder that carries its marker files.
        var detected = _dropboxLocator.FindRoots();
        if (detected.Count > 0)
        {
            var note = detected.Count == 1
                ? "Found your Dropbox folder automatically."
                : $"Found {detected.Count} Dropbox folders — using the first. Use Browse Root to switch.";

            SetRoot(detected[0], note);
            return;
        }

        // 3. Nothing found, so ask before the window is usable.
        PromptForRoot(
            "Choose your Dropbox folder",
            "CloudIgnore couldn't find your Dropbox folder. Please choose it so scans start in the right place.");
    }

    private void PromptForRoot(string title, string? explanation = null)
    {
        if (explanation is not null)
        {
            MessageBox.Show(explanation, "Choose a folder", MessageBoxButton.OK, MessageBoxImage.Information);
        }

        var dialog = new OpenFolderDialog
        {
            Title = title,
            InitialDirectory = DialogStartFolder
        };

        if (dialog.ShowDialog() == true)
            SetRoot(dialog.FolderName, "Chosen by you. CloudIgnore will remember it next time.");
    }

    // One place to change the root so the label, the saved setting, and the
    // scan all stay in step.
    private void SetRoot(string path, string note, bool save = true)
    {
        _rootPath = path;
        RootSourceText.Text = note;
        ShowRootPath();

        if (save)
        {
            _settings.RootPath = path;
            _settings.Save();
        }
    }

    private void ShowRootPath()
    {
        RootPathText.Text = string.IsNullOrWhiteSpace(_rootPath)
            ? "No folder selected — choose one with Browse Root"
            : _rootPath;
    }

    // The folder picker needs somewhere to start. Before a root is chosen,
    // fall back to the user's profile folder rather than a hardcoded path.
    private string DialogStartFolder =>
        string.IsNullOrWhiteSpace(_rootPath)
            ? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)
            : _rootPath;

    private void BrowseRoot_Click(object sender, RoutedEventArgs e)
    {
        PromptForRoot("Choose a root folder to scan");
    }

    private void ImportGitignore_Click(object sender, RoutedEventArgs e)
    {
        var dialog = new OpenFileDialog
        {
            Title = "Select a .gitignore file",
            Filter = ".gitignore|.gitignore|All files|*.*",
            FileName = ".gitignore",
            InitialDirectory = DialogStartFolder
        };

        if (dialog.ShowDialog() != true)
            return;

        var profile = _gitignoreParser.Parse(dialog.FileName);
        _profiles.Add(profile);
        ProfileList.SelectedItem = profile;
    }

    private void ProfileList_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
    {
        if (ProfileList.SelectedItem is IgnoreProfile profile)
        {
            _activeProfile = profile;
            ActiveProfileText.Text = profile.Name;
            RuleCountText.Text = $"{profile.Rules.Count} active";
        }
    }

    private void ScanNow_Click(object sender, RoutedEventArgs e)
    {
        if (string.IsNullOrWhiteSpace(_rootPath) || !Directory.Exists(_rootPath))
        {
            MessageBox.Show(
                "Choose a folder to scan first using Browse Root.",
                "No folder selected",
                MessageBoxButton.OK,
                MessageBoxImage.Information);
            return;
        }

        _results.Clear();

        var matches = _ignoreService.Scan(_rootPath, _activeProfile);
        foreach (var match in matches)
            _results.Add(match);

        UpdateStats();
    }

    private void ApplyIgnore_Click(object sender, RoutedEventArgs e)
    {
        foreach (var match in _results)
        {
            if (!match.Selected || match.Status == MatchStatus.AlreadyIgnored)
                continue;

            _ignoreService.Apply(match);
        }

        ResultsGrid.Items.Refresh();
        UpdateStats();
    }

    private void UndoIgnore_Click(object sender, RoutedEventArgs e)
    {
        foreach (var match in _results)
        {
            if (!match.Selected)
                continue;

            _ignoreService.Undo(match);
        }

        ResultsGrid.Items.Refresh();
        UpdateStats();
    }

    private void ClearResults_Click(object sender, RoutedEventArgs e)
    {
        _results.Clear();
        UpdateStats();
    }

    private void UpdateStats()
    {
        ActiveProfileText.Text = _activeProfile.Name;
        RuleCountText.Text = $"{_activeProfile.Rules.Count} active";
        MatchesFoundText.Text = _results.Count.ToString();
        ReadyToApplyText.Text = _results.Count(m => m.Status == MatchStatus.Pending).ToString();
    }
}