CompetitionViewModel.cs

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data;
using System.Windows.Data;
using System.Windows.Input;
using Microsoft.Win32;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using MahApps.Metro.Controls.Dialogs;
using Vereinsmeisterschaften.Contracts.ViewModels;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Models;
using Vereinsmeisterschaften.Properties;
 
namespace Vereinsmeisterschaften.ViewModels;

public partial class CompetitionViewModel : ObservableObject, INavigationAware
{
    [ObservableProperty]
    private ObservableCollection<Competition> _competitions;
 
    private ICollectionView _competitionsCollectionView;
    public ICollectionView CompetitionsCollectionView
    {
        get => _competitionsCollectionView;
        private set => SetProperty(ref _competitionsCollectionView, value);
    }

    [ObservableProperty]
    private Competition _selectedCompetition;

    public bool IsAnyDistanceInvalid => Competitions.Any(c => !c.IsDistanceValid);

    public bool HasDuplicateCompetitions => Competitions?.Any(c => c.HasDuplicates) ?? false;
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------

    [ObservableProperty]
    private ObservableCollection<CompetitionDistanceRule> _competitionDistanceRules;
 
    private ICollectionView _competitionDistanceRuleCollectionView;
    public ICollectionView CompetitionDistanceRuleCollectionView
    {
        get => _competitionDistanceRuleCollectionView;
        private set => SetProperty(ref _competitionDistanceRuleCollectionView, value);
    }

    public List<CompetitionDistanceRuleValidationIssue> CompetitionDistanceRuleValidationIssues
        => _competitionDistanceRuleService.ValidateRules();
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    private List<SwimmingStyles> _availableSwimmingStyles = Enum.GetValues(typeof(SwimmingStyles)).Cast<SwimmingStyles>().Where(s => s != SwimmingStyles.Unknown).ToList();
    public List<SwimmingStyles> AvailableSwimmingStyles => _availableSwimmingStyles;
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    private ICompetitionService _competitionService;
    private ICompetitionDistanceRuleService _competitionDistanceRuleService;
    private IWorkspaceService _workspaceService;
    private IDialogCoordinator _dialogCoordinator;
    private ShellViewModel _shellVM;

    public CompetitionViewModel(ICompetitionService competitionService, ICompetitionDistanceRuleService competitionDistanceRuleService, IWorkspaceService workspaceService, IDialogCoordinator dialogCoordinator, ShellViewModel shellVM)
    {
        _competitionService = competitionService;
        _competitionDistanceRuleService = competitionDistanceRuleService;
        _workspaceService = workspaceService;
        _dialogCoordinator = dialogCoordinator;
        _shellVM = shellVM;
 
        _competitionDistanceRuleService.PropertyChanged += (sender, e) =>
        {
            switch(e.PropertyName)
            {
                case nameof(ICompetitionDistanceRuleService.HasUnsavedChanges): OnPropertyChanged(nameof(CompetitionDistanceRuleValidationIssues)); break;
                default: break;
            }
        };
    }
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    
    private ICommand _addCompetitionCommand;
    public ICommand AddCompetitionCommand => _addCompetitionCommand ?? (_addCompetitionCommand = new RelayCommand(() =>
    {
        Competition competition = new Competition();
        _competitionService.AddCompetition(competition);
        competition.PropertyChanged += Competition_PropertyChanged;
        SelectedCompetition = competition;
        OnPropertyChanged(nameof(IsAnyDistanceInvalid));
        OnPropertyChanged(nameof(HasDuplicateCompetitions));
    }));
 
    private ICommand _removeCompetitionCommand;
    public ICommand RemoveCompetitionCommand => _removeCompetitionCommand ?? (_removeCompetitionCommand = new RelayCommand<Competition>(async (competition) =>
    {
        MessageDialogResult result = await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.RemoveCompetitionString, Resources.RemoveCompetitionConfirmationString, MessageDialogStyle.AffirmativeAndNegative, new MetroDialogSettings() { NegativeButtonText = Resources.CancelString });
        if (result == MessageDialogResult.Affirmative)
        {
            competition.PropertyChanged -= Competition_PropertyChanged;
            _competitionService.RemoveCompetition(competition);
            OnPropertyChanged(nameof(IsAnyDistanceInvalid));
            OnPropertyChanged(nameof(HasDuplicateCompetitions));
        }
    }));
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------
 
    private ICommand _addDistanceRuleCommand;
    public ICommand AddDistanceRuleCommand => _addDistanceRuleCommand ?? (_addDistanceRuleCommand = new RelayCommand(() =>
    {
        CompetitionDistanceRule rule = new CompetitionDistanceRule();
        _competitionDistanceRuleService.AddDistanceRule(rule);
    }));
 
    private ICommand _removeDistanceRuleCommand;
    public ICommand RemoveDistanceRuleCommand => _removeDistanceRuleCommand ?? (_removeDistanceRuleCommand = new RelayCommand<CompetitionDistanceRule>(async (rule) =>
    {
        MessageDialogResult result = await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.RemoveDistanceRuleString, Resources.RemoveDistanceRuleConfirmationString, MessageDialogStyle.AffirmativeAndNegative, new MetroDialogSettings() { NegativeButtonText = Resources.CancelString });
        if (result == MessageDialogResult.Affirmative)
        {
            _competitionDistanceRuleService.RemoveDistanceRule(rule);
        }
    }));
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------
 
    private ICommand _updateCompetitionTimesFromRudolphTableCommand;
    public ICommand UpdateCompetitionTimesFromRudolphTableCommand => _updateCompetitionTimesFromRudolphTableCommand ?? (_updateCompetitionTimesFromRudolphTableCommand = new RelayCommand(async () =>
    {
        OpenFileDialog fileDialog = new OpenFileDialog();
        fileDialog.InitialDirectory = _workspaceService.PersistentPath;
        fileDialog.Filter = Resources.FileDialogCsvFilterString;
        fileDialog.Title = Resources.SelectRudolphTableString;
        if (fileDialog.ShowDialog() == true)
        {
            string inputStr = await _dialogCoordinator.ShowInputAsync(_shellVM, Resources.RudolphTableString, Resources.EnterRudolphScoreString, new MetroDialogSettings() { NegativeButtonText = Resources.CancelString });
            if (inputStr != null)
            {
                byte rudolphScore = 0;
                if (byte.TryParse(inputStr, out rudolphScore) && rudolphScore >= 1 && rudolphScore <= 20)
                {
                    _competitionService.UpdateAllCompetitionTimesFromRudolphTable(fileDialog.FileName, rudolphScore);
                    await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.RudolphTableString, Resources.FinishedUpdateFromRudolphTableString);
                }
                else
                {
                    await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.ErrorString, Resources.ErrorUpdatingFromRudolphTableString);
                }
            }
            else
            {
                // User canceled
            }
        }
    }));
 
    private ICommand _createCompetitionsFromRudolphTableCommand;
    public ICommand CreateCompetitionsFromRudolphTableCommand => _createCompetitionsFromRudolphTableCommand ?? (_createCompetitionsFromRudolphTableCommand = new RelayCommand(async () =>
    {
        MessageDialogResult result = await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.RudolphTableString, Resources.RudolphTableCompetitionDeletionConfirmationString, MessageDialogStyle.AffirmativeAndNegative, new MetroDialogSettings() { NegativeButtonText = Resources.CancelString });
        if (result == MessageDialogResult.Affirmative)
        {
            OpenFileDialog fileDialog = new OpenFileDialog();
            fileDialog.InitialDirectory = _workspaceService.PersistentPath;
            fileDialog.Filter = Resources.FileDialogCsvFilterString;
            fileDialog.Title = Resources.SelectRudolphTableString;
            if (fileDialog.ShowDialog() == true)
            {
                string inputStr = await _dialogCoordinator.ShowInputAsync(_shellVM, Resources.RudolphTableString, Resources.EnterRudolphScoreString, new MetroDialogSettings() { NegativeButtonText = Resources.CancelString });
                if (inputStr != null)
                {
                    byte rudolphScore = 0;
                    if (byte.TryParse(inputStr, out rudolphScore) && rudolphScore >= 1 && rudolphScore <= 20)
                    {
                        _competitionService.CreateCompetitionsFromRudolphTable(fileDialog.FileName, rudolphScore);
                        await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.RudolphTableString, Resources.FinishedUpdateFromRudolphTableString);
                        OnPropertyChanged(nameof(IsAnyDistanceInvalid));
                    }
                    else
                    {
                        await _dialogCoordinator.ShowMessageAsync(_shellVM, Resources.ErrorString, Resources.ErrorUpdatingFromRudolphTableString);
                    }
                }
                else
                {
                    // User canceled
                }
            }
        }
    }));
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    public void OnNavigatedTo(object parameter)
    {
        Competitions = _competitionService?.GetCompetitions();
        CompetitionsCollectionView = CollectionViewSource.GetDefaultView(Competitions);
        SelectedCompetition = Competitions?.FirstOrDefault();
 
        CompetitionDistanceRules = _competitionDistanceRuleService?.GetCompetitionDistanceRules();
        CompetitionDistanceRuleCollectionView = CollectionViewSource.GetDefaultView(CompetitionDistanceRules);
 
        foreach (Competition competition in Competitions)
        {
            // Unsubscribe from and resubscribe to the event to avoid multiple subscriptions
            competition.PropertyChanged -= Competition_PropertyChanged;
            competition.PropertyChanged += Competition_PropertyChanged;
        }
 
        OnPropertyChanged(nameof(IsAnyDistanceInvalid));
        OnPropertyChanged(nameof(HasDuplicateCompetitions));
        OnPropertyChanged(nameof(CompetitionDistanceRuleValidationIssues));
    }

    public void OnNavigatedFrom()
    {
        // Unsubscribe from the event to avoid raising this event on another page (not necessary there)
        foreach (Competition competition in Competitions)
        {
            competition.PropertyChanged -= Competition_PropertyChanged;
        }
    }
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    #region Property changed event handler
 
    private void Competition_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        switch (e.PropertyName)
        {
            case nameof(Competition.HasDuplicates): OnPropertyChanged(nameof(HasDuplicateCompetitions)); break;
            case nameof(Competition.IsDistanceValid): OnPropertyChanged(nameof(IsAnyDistanceInvalid)); break;
            default: break;
        }
    }
 
    #endregion
 
}