TimeInputViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using System.ComponentModel;
using System.Windows.Data;
using Vereinsmeisterschaften.Contracts.ViewModels;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Models;
using Vereinsmeisterschaften.Core.Settings;
 
namespace Vereinsmeisterschaften.ViewModels;

public partial class TimeInputViewModel : ObservableObject, INavigationAware
{
    public List<PersonStart> AvailablePersonStarts { get; set; }
 
    private ICollectionView _availablePersonStartsCollectionView;
    public ICollectionView AvailablePersonStartsCollectionView
    {
        get => _availablePersonStartsCollectionView;
        private set => SetProperty(ref _availablePersonStartsCollectionView, value);
    }

    public RacesVariant PersistedRacesVariant => _raceService?.PersistedRacesVariant;
 
    private int _timeInputMillisecondDigits;
    public int TimeInputMillisecondDigits
    {
        get => _timeInputMillisecondDigits;
        set
        {
            if (SetProperty(ref _timeInputMillisecondDigits, value))
            {
                OnPropertyChanged(nameof(TimeInputFormatString));
            }
        }
    }

    public string TimeInputFormatString => $"mm:ss.{new string('f', TimeInputMillisecondDigits)}";

    public bool IsTimeInputMissing => AvailablePersonStarts.Any(s => s.IsActive && s.CompetitionObj != null && !s.IsTimeSet);
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    #region Filter Feature
 
    private TimeInputPersonStartFilterModes _filterPersonStartMode = TimeInputPersonStartFilterModes.None;
    public TimeInputPersonStartFilterModes FilterPersonStartMode
    {
        get => _filterPersonStartMode;
        set
        {
            if (SetProperty(ref _filterPersonStartMode, value))
            {
                AvailablePersonStartsCollectionView.Refresh();
            }
        }
    }
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------

    public List<Person> AvailablePersons => _personService?.GetPersons().OrderBy(p => p.Name).ToList();
 
    private Person _filteredPerson;
    public Person FilteredPerson
    {
        get => _filteredPerson;
        set
        {
            if (SetProperty(ref _filteredPerson, value))
            {
                AvailablePersonStartsCollectionView.Refresh();
            }
        }
    }
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------
 
    private int _filteredRaceID = 1;
    public int FilteredRaceID
    {
        get => _filteredRaceID;
        set
        {
            if (SetProperty(ref _filteredRaceID, value))
            {
                AvailablePersonStartsCollectionView.Refresh();
            }
        }
    }
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------
 
    private int _filteredCompetitionID = 1;
    public int FilteredCompetitionID
    {
        get => _filteredCompetitionID;
        set
        {
            if (SetProperty(ref _filteredCompetitionID, value))
            {
                AvailablePersonStartsCollectionView.Refresh();
            }
        }
    }
 
    // ----------------------------------------------------------------------------------------------------------------------------------------------

    public Predicate<object> AvailablePersonStartsFilterPredicate
    {
        get
        {
            return (item) =>
            {
                PersonStart personStart = item as PersonStart;
 
                bool filterResult = true;
                switch(FilterPersonStartMode)
                {
                    case TimeInputPersonStartFilterModes.Person:
                        return personStart?.PersonObj == FilteredPerson;
                    case TimeInputPersonStartFilterModes.RaceID:
                        Race race = PersistedRacesVariant?.Races?.Where(r => r.Starts.Contains(personStart)).FirstOrDefault();
                        return race == null ? false : race.RaceID == FilteredRaceID;
                    case TimeInputPersonStartFilterModes.CompetitionID:
                        return (personStart?.CompetitionObj?.Id ?? -1) == FilteredCompetitionID;
                    case TimeInputPersonStartFilterModes.None:
                    default:
                        break;
                }
                return filterResult;
            };
        }
    }
 
    #endregion
 
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    private readonly IPersonService _personService;
    private readonly IRaceService _raceService;
    private readonly IWorkspaceService _workspaceService;

    public TimeInputViewModel(IPersonService personService, IRaceService raceService, IWorkspaceService workspaceService)
    {
        _personService = personService;
        _raceService = raceService;
        _workspaceService = workspaceService;
    }

    public void OnNavigatedTo(object parameter)
    {
        AvailablePersonStarts = _personService.GetAllPersonStarts().Where(s => s.IsActive).ToList();
        AvailablePersonStartsCollectionView = CollectionViewSource.GetDefaultView(AvailablePersonStarts);
        AvailablePersonStartsCollectionView.Filter += AvailablePersonStartsFilterPredicate;
 
        TimeInputMillisecondDigits = _workspaceService?.Settings?.GetSettingValue<ushort>(WorkspaceSettings.GROUP_GENERAL, WorkspaceSettings.SETTING_GENERAL_TIMEINPUT_NUMBER_MILLISECOND_DIGITS) ?? 2;
 
        foreach (PersonStart start in AvailablePersonStarts)
        {
            // Unsubscribe from and resubscribe to the event to avoid multiple subscriptions
            start.PropertyChanged -= Start_PropertyChanged;
            start.PropertyChanged += Start_PropertyChanged;
        }
 
        OnPropertyChanged(nameof(PersistedRacesVariant));
        OnPropertyChanged(nameof(AvailablePersons));
        OnPropertyChanged(nameof(IsTimeInputMissing));
    }

    public void OnNavigatedFrom()
    {
        // Unsubscribe from the event to avoid raising this event on another page (not necessary there)
        foreach (PersonStart start in AvailablePersonStarts)
        {
            start.PropertyChanged -= Start_PropertyChanged;
        }
    }
    
    private void Start_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        switch (e.PropertyName)
        {
            case nameof(PersonStart.IsActive):
            case nameof(PersonStart.IsTimeSet):
                OnPropertyChanged(nameof(IsTimeInputMissing));
                break;
            default: break;
        }
    }
}