MessageBox.Show("Файл успішно збережено!");

MessageBoxResult result = MessageBox.Show(
    messageBoxText: "Ви впевнені, що хочете видалити цей файл?",
    caption: "Підтвердження видалення",
    button: MessageBoxButton.YesNo,
    icon: MessageBoxImage.Warning
);

if (result == MessageBoxResult.Yes)
{
    DeleteFile();
}

// OK — одна кнопка
MessageBox.Show("Операція завершена", "Інформація", MessageBoxButton.OK);

// OKCancel — дві кнопки
var result = MessageBox.Show("Продовжити?", "Підтвердження", MessageBoxButton.OKCancel);

// YesNo — дві кнопки
var result = MessageBox.Show("Зберегти зміни?", "Збереження", MessageBoxButton.YesNo);

// YesNoCancel — три кнопки
var result = MessageBox.Show(
    "Зберегти зміни перед закриттям?", 
    "Збереження", 
    MessageBoxButton.YesNoCancel
);

// Інформація (синя іконка "i")
MessageBox.Show("Файл збережено", "Інформація", 
    MessageBoxButton.OK, MessageBoxImage.Information);

// Попередження (жовтий трикутник з "!")
MessageBox.Show("Файл вже існує", "Попередження", 
    MessageBoxButton.OK, MessageBoxImage.Warning);

// Помилка (червоний круг з "X")
MessageBox.Show("Не вдалося зберегти файл", "Помилка", 
    MessageBoxButton.OK, MessageBoxImage.Error);

// Питання (синій круг з "?")
MessageBox.Show("Видалити файл?", "Підтвердження", 
    MessageBoxButton.YesNo, MessageBoxImage.Question);

MessageBoxResult result = MessageBox.Show(
    "Зберегти зміни перед закриттям?",
    "Збереження",
    MessageBoxButton.YesNoCancel,
    MessageBoxImage.Question
);

switch (result)
{
    case MessageBoxResult.Yes:
        SaveChanges();
        CloseWindow();
        break;
    
    case MessageBoxResult.No:
        CloseWindow();
        break;
    
    case MessageBoxResult.Cancel:
        // Нічого не робимо — залишаємось у вікні
        break;
}

// У code-behind MainWindow
MessageBox.Show(
    this,  // owner — поточне вікно
    "Файл збережено",
    "Інформація",
    MessageBoxButton.OK,
    MessageBoxImage.Information
);

private void DeleteButton_Click(object sender, RoutedEventArgs e)
{
    var selectedItem = ItemsListBox.SelectedItem as FileItem;
    if (selectedItem == null)
    {
        MessageBox.Show(
            this,
            "Оберіть файл для видалення",
            "Помилка",
            MessageBoxButton.OK,
            MessageBoxImage.Warning
        );
        return;
    }
    
    var result = MessageBox.Show(
        this,
        $"Ви впевнені, що хочете видалити файл '{selectedItem.Name}'?\n\nЦю дію неможливо скасувати.",
        "Підтвердження видалення",
        MessageBoxButton.YesNo,
        MessageBoxImage.Question
    );
    
    if (result == MessageBoxResult.Yes)
    {
        try
        {
            File.Delete(selectedItem.Path);
            Items.Remove(selectedItem);
            
            MessageBox.Show(
                this,
                "Файл успішно видалено",
                "Успіх",
                MessageBoxButton.OK,
                MessageBoxImage.Information
            );
        }
        catch (Exception ex)
        {
            MessageBox.Show(
                this,
                $"Не вдалося видалити файл:\n{ex.Message}",
                "Помилка",
                MessageBoxButton.OK,
                MessageBoxImage.Error
            );
        }
    }
}

using Microsoft.Win32;  // Namespace для OpenFileDialog

private void OpenFile_Click(object sender, RoutedEventArgs e)
{
    var dialog = new OpenFileDialog();
    
    // ShowDialog() повертає bool? — true якщо користувач обрав файл
    bool? result = dialog.ShowDialog();
    
    if (result == true)
    {
        string filename = dialog.FileName;
        LoadFile(filename);
    }
}

var dialog = new OpenFileDialog
{
    Title = "Відкрити текстовий файл",
    Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*",
    FilterIndex = 1,
    InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
    CheckFileExists = true,
    CheckPathExists = true,
    Multiselect = false
};

if (dialog.ShowDialog() == true)
{
    string filename = dialog.FileName;
    // Обробка файлу
}

"Опис1|Маска1|Опис2|Маска2|..."

// Лише текстові файли
dialog.Filter = "Text files (*.txt)|*.txt";

// Текстові та всі файли
dialog.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*";

// Зображення (кілька розширень)
dialog.Filter = "Image files (*.png;*.jpg;*.jpeg)|*.png;*.jpg;*.jpeg|All files (*.*)|*.*";

// Документи
dialog.Filter = "Word documents (*.docx)|*.docx|PDF files (*.pdf)|*.pdf|All files (*.*)|*.*";

dialog.Filter = "Text files (*.txt)|*.txt|CSV files (*.csv)|*.csv|All files (*.*)|*.*";
dialog.FilterIndex = 2;  // За замовчуванням обрано CSV files

var dialog = new OpenFileDialog
{
    Title = "Оберіть файли для імпорту",
    Filter = "CSV files (*.csv)|*.csv",
    Multiselect = true  // Дозволити вибір кількох файлів
};

if (dialog.ShowDialog() == true)
{
    // FileNames — масив усіх обраних файлів
    foreach (string filename in dialog.FileNames)
    {
        ImportFile(filename);
    }
    
    MessageBox.Show($"Імпортовано {dialog.FileNames.Length} файлів");
}

// Папка "Мої документи"
dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

// Папка "Робочий стіл"
dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

// Поточна папка застосунку
dialog.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;

// Кастомна папка
dialog.InitialDirectory = @"C:\Projects\MyApp\Data";

private string? _currentFilePath;

private void OpenFile_Click(object sender, RoutedEventArgs e)
{
    var dialog = new OpenFileDialog
    {
        Title = "Відкрити текстовий файл",
        Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*",
        FilterIndex = 1,
        InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
    };
    
    if (dialog.ShowDialog() == true)
    {
        try
        {
            string content = File.ReadAllText(dialog.FileName);
            EditorTextBox.Text = content;
            _currentFilePath = dialog.FileName;
            Title = $"Text Editor - {Path.GetFileName(dialog.FileName)}";
        }
        catch (Exception ex)
        {
            MessageBox.Show(
                this,
                $"Не вдалося відкрити файл:\n{ex.Message}",
                "Помилка",
                MessageBoxButton.OK,
                MessageBoxImage.Error
            );
        }
    }
}

using Microsoft.Win32;

private void SaveFile_Click(object sender, RoutedEventArgs e)
{
    var dialog = new SaveFileDialog();
    
    if (dialog.ShowDialog() == true)
    {
        string filename = dialog.FileName;
        SaveToFile(filename);
    }
}

var dialog = new SaveFileDialog
{
    Title = "Зберегти документ",
    Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*",
    FilterIndex = 1,
    FileName = "document.txt",  // Запропоноване ім'я файлу
    DefaultExt = "txt",  // Розширення за замовчуванням
    AddExtension = true,  // Автоматично додавати розширення
    OverwritePrompt = true,  // Попередження при перезаписі
    CreatePrompt = false,  // Попередження при створенні нового файлу
    InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
};

if (dialog.ShowDialog() == true)
{
    File.WriteAllText(dialog.FileName, EditorTextBox.Text);
}

dialog.DefaultExt = "txt";
dialog.AddExtension = true;

dialog.OverwritePrompt = true;

private string? _currentFilePath;

// Save — зберегти у поточний файл або викликати Save As
private void Save_Click(object sender, RoutedEventArgs e)
{
    if (_currentFilePath != null)
    {
        // Файл вже відкрито — зберігаємо у нього
        SaveToFile(_currentFilePath);
    }
    else
    {
        // Файл ще не збережено — викликаємо Save As
        SaveAs_Click(sender, e);
    }
}

// Save As — завжди показувати діалог
private void SaveAs_Click(object sender, RoutedEventArgs e)
{
    var dialog = new SaveFileDialog
    {
        Title = "Зберегти файл як",
        Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*",
        FilterIndex = 1,
        FileName = _currentFilePath != null 
            ? Path.GetFileName(_currentFilePath) 
            : "document.txt",
        DefaultExt = "txt",
        AddExtension = true,
        OverwritePrompt = true
    };
    
    if (dialog.ShowDialog() == true)
    {
        SaveToFile(dialog.FileName);
        _currentFilePath = dialog.FileName;
        Title = $"Text Editor - {Path.GetFileName(dialog.FileName)}";
    }
}

private void SaveToFile(string filename)
{
    try
    {
        File.WriteAllText(filename, EditorTextBox.Text);
        MessageBox.Show(
            this,
            "Файл успішно збережено",
            "Успіх",
            MessageBoxButton.OK,
            MessageBoxImage.Information
        );
    }
    catch (Exception ex)
    {
        MessageBox.Show(
            this,
            $"Не вдалося зберегти файл:\n{ex.Message}",
            "Помилка",
            MessageBoxButton.OK,
            MessageBoxImage.Error
        );
    }
}

dotnet add package System.Windows.Forms

using System.Windows.Forms;  // FolderBrowserDialog з WinForms

private void SelectFolder_Click(object sender, RoutedEventArgs e)
{
    using var dialog = new FolderBrowserDialog();
    dialog.Description = "Оберіть папку для експорту";
    dialog.ShowNewFolderButton = true;
    
    DialogResult result = dialog.ShowDialog();
    
    if (result == DialogResult.OK && !string.IsNullOrWhiteSpace(dialog.SelectedPath))
    {
        string folderPath = dialog.SelectedPath;
        ExportToFolder(folderPath);
    }
}

private void SelectFolder_Click(object sender, RoutedEventArgs e)
{
    var dialog = new OpenFileDialog
    {
        Title = "Оберіть папку",
        CheckFileExists = false,
        CheckPathExists = true,
        FileName = "Folder Selection",
        Filter = "Folders|\n",
        ValidateNames = false
    };
    
    if (dialog.ShowDialog() == true)
    {
        string folderPath = Path.GetDirectoryName(dialog.FileName);
        ExportToFolder(folderPath);
    }
}

dotnet add package Microsoft.WindowsAPICodePack-Shell

using Microsoft.WindowsAPICodePack.Dialogs;

private void SelectFolder_Click(object sender, RoutedEventArgs e)
{
    using var dialog = new CommonOpenFileDialog
    {
        IsFolderPicker = true,
        Title = "Оберіть папку для експорту",
        InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
    };
    
    if (dialog.ShowDialog() == CommonFileDialogResult.Ok)
    {
        string folderPath = dialog.FileName;
        ExportToFolder(folderPath);
    }
}

<Window x:Class="MyApp.Dialogs.ConfirmDialog"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Підтвердження"
        Width="400" Height="200"
        WindowStartupLocation="CenterOwner"
        ResizeMode="NoResize">
    
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        
        <!-- Іконка та заголовок -->
        <StackPanel Grid.Row="0" Orientation="Horizontal" Margin="0,0,0,12">
            <TextBlock Text="⚠️" FontSize="24" Margin="0,0,12,0"/>
            <TextBlock x:Name="TitleTextBlock" 
                       Text="Підтвердження дії"
                       FontSize="16" FontWeight="Bold"
                       VerticalAlignment="Center"/>
        </StackPanel>
        
        <!-- Повідомлення -->
        <TextBlock Grid.Row="1" 
                   x:Name="MessageTextBlock"
                   Text="Ви впевнені, що хочете виконати цю дію?"
                   TextWrapping="Wrap"
                   Margin="0,0,0,12"/>
        
        <!-- Checkbox "Більше не показувати" -->
        <CheckBox Grid.Row="2" 
                  x:Name="DontShowAgainCheckBox"
                  Content="Більше не показувати це повідомлення"
                  VerticalAlignment="Bottom"
                  Margin="0,0,0,12"/>
        
        <!-- Кнопки -->
        <StackPanel Grid.Row="3" 
                    Orientation="Horizontal" 
                    HorizontalAlignment="Right">
            <Button Content="Так" 
                    Width="80" 
                    IsDefault="True"
                    Click="YesButton_Click"
                    Margin="0,0,8,0"/>
            <Button Content="Ні" 
                    Width="80" 
                    IsCancel="True"
                    Click="NoButton_Click"/>
        </StackPanel>
    </Grid>
</Window>

public partial class ConfirmDialog : Window
{
    public bool DontShowAgain => DontShowAgainCheckBox.IsChecked == true;
    
    public ConfirmDialog(string title, string message)
    {
        InitializeComponent();
        TitleTextBlock.Text = title;
        MessageTextBlock.Text = message;
    }
    
    private void YesButton_Click(object sender, RoutedEventArgs e)
    {
        DialogResult = true;  // Закрити з результатом true
    }
    
    private void NoButton_Click(object sender, RoutedEventArgs e)
    {
        DialogResult = false;  // Закрити з результатом false
    }
}

private void DeleteButton_Click(object sender, RoutedEventArgs e)
{
    var dialog = new ConfirmDialog(
        title: "Підтвердження видалення",
        message: "Ви впевнені, що хочете видалити обраний файл?\n\nЦю дію неможливо скасувати."
    );
    
    dialog.Owner = this;  // Центрувати відносно MainWindow
    
    bool? result = dialog.ShowDialog();
    
    if (result == true)
    {
        // Користувач натиснув "Так"
        DeleteFile();
        
        // Перевірити checkbox
        if (dialog.DontShowAgain)
        {
            SaveSetting("DontShowDeleteConfirmation", true);
        }
    }
}

public class EditPersonDialogViewModel : ViewModelBase
{
    private string _name = "";
    public string Name
    {
        get => _name;
        set => SetField(ref _name, value);
    }
    
    private int _age;
    public int Age
    {
        get => _age;
        set => SetField(ref _age, value);
    }
    
    private string _email = "";
    public string Email
    {
        get => _email;
        set => SetField(ref _email, value);
    }
    
    public ICommand SaveCommand { get; }
    public ICommand CancelCommand { get; }
    
    public event EventHandler<bool>? RequestClose;
    
    public EditPersonDialogViewModel(Person? person = null)
    {
        if (person != null)
        {
            Name = person.Name;
            Age = person.Age;
            Email = person.Email;
        }
        
        SaveCommand = new RelayCommand(_ => Save(), _ => CanSave());
        CancelCommand = new RelayCommand(_ => Cancel());
    }
    
    private bool CanSave()
    {
        return !string.IsNullOrWhiteSpace(Name) && 
               Age > 0 && 
               !string.IsNullOrWhiteSpace(Email);
    }
    
    private void Save()
    {
        RequestClose?.Invoke(this, true);
    }
    
    private void Cancel()
    {
        RequestClose?.Invoke(this, false);
    }
}

public partial class EditPersonDialog : Window
{
    private readonly EditPersonDialogViewModel _viewModel;
    
    public Person? Result { get; private set; }
    
    public EditPersonDialog(Person? person = null)
    {
        InitializeComponent();
        
        _viewModel = new EditPersonDialogViewModel(person);
        _viewModel.RequestClose += OnRequestClose;
        DataContext = _viewModel;
    }
    
    private void OnRequestClose(object? sender, bool dialogResult)
    {
        if (dialogResult)
        {
            Result = new Person(
                Name: _viewModel.Name,
                Age: _viewModel.Age,
                Email: _viewModel.Email
            );
        }
        
        DialogResult = dialogResult;
    }
}

private void EditPerson_Click(object sender, RoutedEventArgs e)
{
    var selectedPerson = (Person)PeopleListBox.SelectedItem;
    
    var dialog = new EditPersonDialog(selectedPerson);
    dialog.Owner = this;
    
    if (dialog.ShowDialog() == true && dialog.Result != null)
    {
        UpdatePerson(dialog.Result);
    }
}

// ❌ ПОГАНО — ViewModel залежить від View
public class MainViewModel : ViewModelBase
{
    [RelayCommand]
    private void DeleteItem()
    {
        // ViewModel не повинна знати про MessageBox або Window!
        var result = MessageBox.Show("Видалити?", "Підтвердження", 
            MessageBoxButton.YesNo);
        
        if (result == MessageBoxResult.Yes)
        {
            // Видалення
        }
    }
}

// Services/IDialogService.cs
public interface IDialogService
{
    bool ShowConfirmation(string title, string message);
    void ShowInformation(string title, string message);
    void ShowWarning(string title, string message);
    void ShowError(string title, string message);
    
    string? OpenFile(string title, string filter);
    string? SaveFile(string title, string filter, string defaultFileName);
    string? SelectFolder(string title);
    
    T? ShowDialog<T>(object viewModel) where T : class;
}

// Services/DialogService.cs
public class DialogService : IDialogService
{
    public bool ShowConfirmation(string title, string message)
    {
        var result = MessageBox.Show(
            message,
            title,
            MessageBoxButton.YesNo,
            MessageBoxImage.Question
        );
        return result == MessageBoxResult.Yes;
    }
    
    public void ShowInformation(string title, string message)
    {
        MessageBox.Show(message, title, MessageBoxButton.OK, MessageBoxImage.Information);
    }
    
    public void ShowWarning(string title, string message)
    {
        MessageBox.Show(message, title, MessageBoxButton.OK, MessageBoxImage.Warning);
    }
    
    public void ShowError(string title, string message)
    {
        MessageBox.Show(message, title, MessageBoxButton.OK, MessageBoxImage.Error);
    }
    
    public string? OpenFile(string title, string filter)
    {
        var dialog = new OpenFileDialog
        {
            Title = title,
            Filter = filter
        };
        
        return dialog.ShowDialog() == true ? dialog.FileName : null;
    }
    
    public string? SaveFile(string title, string filter, string defaultFileName)
    {
        var dialog = new SaveFileDialog
        {
            Title = title,
            Filter = filter,
            FileName = defaultFileName,
            AddExtension = true,
            OverwritePrompt = true
        };
        
        return dialog.ShowDialog() == true ? dialog.FileName : null;
    }
    
    public string? SelectFolder(string title)
    {
        using var dialog = new FolderBrowserDialog
        {
            Description = title,
            ShowNewFolderButton = true
        };
        
        return dialog.ShowDialog() == DialogResult.OK ? dialog.SelectedPath : null;
    }
    
    public T? ShowDialog<T>(object viewModel) where T : class
    {
        // Створення діалогу на основі ViewModel
        Window? dialog = viewModel switch
        {
            EditPersonDialogViewModel vm => new EditPersonDialog { DataContext = vm },
            ConfirmDialogViewModel vm => new ConfirmDialog { DataContext = vm },
            _ => throw new ArgumentException($"Unknown ViewModel type: {viewModel.GetType()}")
        };
        
        if (dialog == null)
            return null;
        
        dialog.Owner = Application.Current.MainWindow;
        
        bool? result = dialog.ShowDialog();
        
        // Повернути результат з діалогу
        return result == true ? (dialog as dynamic)?.Result as T : null;
    }
}

public class MainViewModel : ViewModelBase
{
    private readonly IDialogService _dialogService;
    
    public MainViewModel(IDialogService dialogService)
    {
        _dialogService = dialogService;
    }
    
    [RelayCommand]
    private void DeleteItem()
    {
        bool confirmed = _dialogService.ShowConfirmation(
            "Підтвердження видалення",
            "Ви впевнені, що хочете видалити обраний файл?"
        );
        
        if (confirmed)
        {
            // Видалення
            _dialogService.ShowInformation("Успіх", "Файл успішно видалено");
        }
    }
    
    [RelayCommand]
    private void OpenFile()
    {
        string? filename = _dialogService.OpenFile(
            "Відкрити файл",
            "Text files (*.txt)|*.txt|All files (*.*)|*.*"
        );
        
        if (filename != null)
        {
            LoadFile(filename);
        }
    }
    
    [RelayCommand]
    private void EditPerson()
    {
        var viewModel = new EditPersonDialogViewModel(SelectedPerson);
        
        Person? result = _dialogService.ShowDialog<Person>(viewModel);
        
        if (result != null)
        {
            UpdatePerson(result);
        }
    }
}

// App.xaml.cs або Program.cs
public static IServiceProvider ConfigureServices()
{
    var services = new ServiceCollection();
    
    // Singleton для DialogService
    services.AddSingleton<IDialogService, DialogService>();
    
    // ViewModels
    services.AddTransient<MainViewModel>();
    
    return services.BuildServiceProvider();
}

// Tests/MockDialogService.cs
public class MockDialogService : IDialogService
{
    public bool ConfirmationResult { get; set; } = true;
    public string? OpenFileResult { get; set; }
    
    public bool ShowConfirmation(string title, string message)
    {
        return ConfirmationResult;
    }
    
    public void ShowInformation(string title, string message) { }
    public void ShowWarning(string title, string message) { }
    public void ShowError(string title, string message) { }
    
    public string? OpenFile(string title, string filter)
    {
        return OpenFileResult;
    }
    
    public string? SaveFile(string title, string filter, string defaultFileName)
    {
        return null;
    }
    
    public string? SelectFolder(string title)
    {
        return null;
    }
    
    public T? ShowDialog<T>(object viewModel) where T : class
    {
        return null;
    }
}

[Fact]
public void DeleteItem_UserConfirms_DeletesItem()
{
    // Arrange
    var mockDialogService = new MockDialogService
    {
        ConfirmationResult = true  // Користувач підтвердив
    };
    var viewModel = new MainViewModel(mockDialogService);
    viewModel.Items.Add(new FileItem { Name = "test.txt" });
    viewModel.SelectedItem = viewModel.Items[0];
    
    // Act
    viewModel.DeleteItemCommand.Execute(null);
    
    // Assert
    Assert.Empty(viewModel.Items);
}

public class FileItem
{
    public string Name { get; set; } = "";
    public string Path { get; set; } = "";
    public long Size { get; set; }
}

private void DeleteButton_Click(object sender, RoutedEventArgs e)
{
    var selectedItem = FilesListBox.SelectedItem as FileItem;
    
    if (selectedItem == null)
    {
        MessageBox.Show(
            this,
            "Оберіть файл для видалення",
            "Помилка",
            MessageBoxButton.OK,
            MessageBoxImage.Warning
        );
        return;
    }
    
    var result = MessageBox.Show(
        this,
        $"Ви впевнені, що хочете видалити файл '{selectedItem.Name}'?",
        "Підтвердження видалення",
        MessageBoxButton.YesNo,
        MessageBoxImage.Question
    );
    
    if (result == MessageBoxResult.Yes)
    {
        Files.Remove(selectedItem);
        MessageBox.Show(
            this,
            "Файл успішно видалено",
            "Успіх",
            MessageBoxButton.OK,
            MessageBoxImage.Information
        );
    }
}

private string? _currentFilePath;
private bool _isModified;

private void OpenFile_Click(object sender, RoutedEventArgs e)
{
    if (_isModified)
    {
        var result = MessageBox.Show(
            this,
            "Зберегти зміни перед відкриттям нового файлу?",
            "Незбережені зміни",
            MessageBoxButton.YesNoCancel,
            MessageBoxImage.Question
        );
        
        if (result == MessageBoxResult.Yes)
            Save_Click(sender, e);
        else if (result == MessageBoxResult.Cancel)
            return;
    }
    
    var dialog = new OpenFileDialog
    {
        Title = "Відкрити текстовий файл",
        Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*",
        FilterIndex = 1
    };
    
    if (dialog.ShowDialog() == true)
    {
        EditorTextBox.Text = File.ReadAllText(dialog.FileName);
        _currentFilePath = dialog.FileName;
        _isModified = false;
        UpdateTitle();
    }
}

private void EditorTextBox_TextChanged(object sender, TextChangedEventArgs e)
{
    _isModified = true;
    UpdateTitle();
}

private void UpdateTitle()
{
    string filename = _currentFilePath != null 
        ? Path.GetFileName(_currentFilePath) 
        : "Untitled";
    string modified = _isModified ? "*" : "";
    Title = $"{filename}{modified} - Text Editor";
}

public interface IDialogService
{
    bool ShowConfirmation(string title, string message);
    void ShowInformation(string title, string message);
    void ShowError(string title, string message);
    
    T? ShowDialog<T>(object viewModel) where T : class;
    string? SaveFile(string title, string filter, string defaultFileName);
}

public class MainViewModel : ViewModelBase
{
    private readonly IDialogService _dialogService;
    
    public ObservableCollection<User> Users { get; } = new();
    
    public MainViewModel(IDialogService dialogService)
    {
        _dialogService = dialogService;
    }
    
    [RelayCommand]
    private void DeleteUser(User user)
    {
        bool confirmed = _dialogService.ShowConfirmation(
            "Підтвердження видалення",
            $"Ви впевнені, що хочете видалити користувача '{user.Name}'?"
        );
        
        if (confirmed)
        {
            Users.Remove(user);
            _dialogService.ShowInformation("Успіх", "Користувача видалено");
        }
    }
    
    [RelayCommand]
    private void ExportUsers()
    {
        string? filename = _dialogService.SaveFile(
            "Експортувати користувачів",
            "CSV files (*.csv)|*.csv",
            "users.csv"
        );
        
        if (filename != null)
        {
            ExportToCsv(filename);
        }
    }
}

[Fact]
public void DeleteUser_UserConfirms_RemovesUser()
{
    // Arrange
    var mockDialogService = new MockDialogService
    {
        ConfirmationResult = true
    };
    var viewModel = new MainViewModel(mockDialogService);
    var user = new User("John Doe", 30);
    viewModel.Users.Add(user);
    
    // Act
    viewModel.DeleteUserCommand.Execute(user);
    
    // Assert
    Assert.Empty(viewModel.Users);
}

[Fact]
public void DeleteUser_UserCancels_DoesNotRemoveUser()
{
    // Arrange
    var mockDialogService = new MockDialogService
    {
        ConfirmationResult = false
    };
    var viewModel = new MainViewModel(mockDialogService);
    var user = new User("John Doe", 30);
    viewModel.Users.Add(user);
    
    // Act
    viewModel.DeleteUserCommand.Execute(user);
    
    // Assert
    Assert.Single(viewModel.Users);
}