Mimante/Mimante/Core/MainWindow.DataSettings.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Windows;
using AutoBidder.Data;
using AutoBidder.Utilities;

namespace AutoBidder
{
    /// <summary>
    /// La cartella dei database (con la migrazione quando cambia) e le esportazioni dello
    /// storico, che chiedono sempre dove salvare.
    /// </summary>
    public partial class MainWindow
    {
        // ── Cartella dei database ────────────────────────────────────────

        /// <summary>Il campo mostra sempre il percorso in uso: selezionabile, copiabile.</summary>
        private void RefreshDataFolderFields()
        {
            try { Settings.DatabaseFolderTextBox.Text = AppPaths.DatabaseFolder; }
            catch { }
        }

        /// <summary>
        /// Traduce quello che c'è nel campo in ciò che va salvato: vuoto = predefinito,
        /// uguale al predefinito = vuoto, un percorso davvero diverso = quel percorso.
        /// </summary>
        private static string NormalizeFolderChoice(string? typed, string resolvedDefault, string previouslySaved)
        {
            var text = typed?.Trim() ?? "";

            if (text.Length == 0) return "";

            if (string.Equals(text, resolvedDefault, StringComparison.OrdinalIgnoreCase) &&
                string.IsNullOrWhiteSpace(previouslySaved))
                return "";

            return text;
        }

        private void Settings_BrowseDatabaseFolderClicked(object sender, RoutedEventArgs e)
        {
            var chosen = PickFolder("Scegli la cartella dei database (non una cartella sincronizzata)", AppPaths.DatabaseFolder);
            if (chosen != null) Settings.DatabaseFolderTextBox.Text = chosen;
        }

        private void Settings_OpenDatabaseFolderClicked(object sender, RoutedEventArgs e)
            => OpenFolder(AppPaths.DatabaseFolder);

        /// <summary>
        /// Selettore di cartella. Usa quello di WinForms perché WPF non ne offre uno.
        /// </summary>
        private static string? PickFolder(string description, string startFrom)
        {
            try
            {
                using var dialog = new System.Windows.Forms.FolderBrowserDialog
                {
                    Description = description,
                    UseDescriptionForTitle = true,
                    SelectedPath = Directory.Exists(startFrom) ? startFrom : "",
                    ShowNewFolderButton = true
                };

                return dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK
                    ? dialog.SelectedPath
                    : null;
            }
            catch
            {
                return null;
            }
        }

        private void OpenFolder(string path)
        {
            try
            {
                Directory.CreateDirectory(path);
                Process.Start(new ProcessStartInfo { FileName = path, UseShellExecute = true });
            }
            catch (Exception ex)
            {
                Log($"[DATI] Impossibile aprire {path}: {ex.Message}", LogLevel.Error);
            }
        }

        /// <summary>
        /// Dopo un salvataggio con la cartella dei database cambiata: chiede se spostare i
        /// file nella nuova posizione, li sposta a database chiusi, e riavvia. Senza
        /// riavvio gli archivi terrebbero in memoria i dati letti dalla posizione vecchia.
        /// </summary>
        private void ApplyDatabaseFolderSetting(AppSettings settings, string previousFolder)
        {
            var newFolder = settings.DatabaseFolder.Length > 0 ? settings.DatabaseFolder : AppPaths.DefaultDatabaseFolder;

            try { newFolder = Path.GetFullPath(newFolder); } catch { }

            if (string.Equals(previousFolder.TrimEnd('\\'), newFolder.TrimEnd('\\'), StringComparison.OrdinalIgnoreCase))
            {
                RefreshDataFolderFields();
                return;
            }

            var answer = MessageBox.Show(this,
                $"La cartella dei database cambia da\n{previousFolder}\na\n{newFolder}\n\n" +
                "Vuoi spostare i database esistenti nella nuova cartella?\n\n" +
                "Sì: sposto i file e riavvio l'applicazione.\n" +
                "No: la nuova cartella parte vuota (i vecchi file restano dove sono) e riavvio.\n" +
                "Annulla: torno alla cartella di prima.",
                "Cartella dei database", MessageBoxButton.YesNoCancel, MessageBoxImage.Question);

            if (answer == MessageBoxResult.Cancel)
            {
                settings.DatabaseFolder = string.Equals(previousFolder, AppPaths.DefaultDatabaseFolder, StringComparison.OrdinalIgnoreCase) ? "" : previousFolder;
                SettingsManager.Save(settings);
                RefreshDataFolderFields();
                return;
            }

            try
            {
                if (answer == MessageBoxResult.Yes)
                {
                    // Prima si chiudono: un file SQLite aperto non si sposta, e il giornale
                    // WAL va con lui.
                    AuctionDatabase.CloseInstance();
                    OperationalDatabase.CloseInstance();
                    Directory.CreateDirectory(newFolder);

                    var moved = 0;
                    foreach (var db in new[] { AppPaths.DatabaseFile, AppPaths.OperationalDatabaseFile })
                    {
                        foreach (var f in AppPaths.DatabaseFiles(db))
                        {
                            var target = Path.Combine(newFolder, Path.GetFileName(f));
                            if (File.Exists(target)) File.Delete(target);
                            File.Move(f, target);
                            moved++;
                        }
                    }

                    Log($"[DATI] Database spostati in {newFolder} ({moved} file). Riavvio.", LogLevel.Warning);
                }
                else
                {
                    Log($"[DATI] Nuova cartella dei database: {newFolder} (vuota). Riavvio.", LogLevel.Warning);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"Spostamento non riuscito: {ex.Message}\n\nLa cartella resta quella di prima.",
                    "Cartella dei database", MessageBoxButton.OK, MessageBoxImage.Error);
                settings.DatabaseFolder = string.Equals(previousFolder, AppPaths.DefaultDatabaseFolder, StringComparison.OrdinalIgnoreCase) ? "" : previousFolder;
                SettingsManager.Save(settings);
                RefreshDataFolderFields();
                return;
            }

            RestartApplication();
        }

        /// <summary>Riavvia l'applicazione: lo stesso eseguibile, e questa istanza si chiude.</summary>
        private void RestartApplication()
        {
            try
            {
                var exe = Environment.ProcessPath;
                if (!string.IsNullOrEmpty(exe))
                    Process.Start(new ProcessStartInfo { FileName = exe, UseShellExecute = true });
            }
            catch (Exception ex)
            {
                Log($"[APP] Riavvio non riuscito: {ex.Message}. Riapri l'applicazione a mano.", LogLevel.Error);
            }

            Application.Current.Shutdown();
        }

        // ── Esportazione dello storico: chiede sempre dove ───────────────

        private void ExportStatsCsvButton_Click(object sender, RoutedEventArgs e)
        {
            var path = AskWhereToSave("Esporta lo storico in CSV", $"storico-aste-{DateTime.Now:yyyyMMdd-HHmm}.csv", "CSV (foglio di calcolo)|*.csv");
            if (path == null) return;
            RunExport(StatsExporter.ExportCsv(path), "CSV");
        }

        private void ExportStatsJsonButton_Click(object sender, RoutedEventArgs e)
        {
            var path = AskWhereToSave("Esporta lo storico in JSON", $"storico-aste-{DateTime.Now:yyyyMMdd-HHmm}.json", "JSON|*.json");
            if (path == null) return;
            RunExport(StatsExporter.ExportJson(path), "JSON");
        }

        /// <summary>La finestra «Salva con nome»: nessun percorso predefinito, decide l'utente.</summary>
        private string? AskWhereToSave(string title, string fileName, string filter)
        {
            try
            {
                var dialog = new Microsoft.Win32.SaveFileDialog
                {
                    Title = title,
                    FileName = fileName,
                    Filter = filter,
                    OverwritePrompt = true,
                    AddExtension = true
                };
                return dialog.ShowDialog(this) == true ? dialog.FileName : null;
            }
            catch (Exception ex)
            {
                Log($"[ESPORTA] Finestra di salvataggio non disponibile: {ex.Message}", LogLevel.Error);
                return null;
            }
        }

        private void RunExport(StatsExporter.Result result, string format)
        {
            if (!result.Success)
            {
                MessageBox.Show(this, result.Error ?? "Esportazione non riuscita.",
                    $"Esporta {format}", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            Log($"[EXPORT] {result.Records} aste esportate in {result.Path}", LogLevel.Success);

            var answer = MessageBox.Show(this,
                $"Esportate {result.Records} aste in formato {format}.\n\n{result.Path}\n\n" +
                "Vuoi aprire la cartella?",
                $"Esporta {format}", MessageBoxButton.YesNo, MessageBoxImage.Information);

            if (answer == MessageBoxResult.Yes)
            {
                OpenFolder(Path.GetDirectoryName(result.Path) ?? AppPaths.ConfigRoot);
            }
        }
    }
}