CompetitionService.cs

using CommunityToolkit.Mvvm.ComponentModel;
using MathNet.Numerics;
using System.Collections.ObjectModel;
using System.ComponentModel;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Helpers;
using Vereinsmeisterschaften.Core.Models;
using Vereinsmeisterschaften.Core.Settings;
 
namespace Vereinsmeisterschaften.Core.Services
{
    public class CompetitionService : ObservableObject, ICompetitionService
    {
        public event ProgressDelegate OnFileProgress;

        public event EventHandler OnFileFinished;
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public string PersistentPath { get; set; }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        private ObservableCollection<Competition> _competitionList { get; set; }

        private List<Competition> _competitionListOnLoad { get; set; }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        private IFileService _fileService;
        private IPersonService _personService;
        private IWorkspaceService _workspaceService;
        private ICompetitionDistanceRuleService _competitionDistanceRuleService;

        public CompetitionService(IFileService fileService, IPersonService personService, ICompetitionDistanceRuleService competitionDistanceRuleService)
        {
            _competitionList = new ObservableCollection<Competition>();
            _competitionList.CollectionChanged += _competitionList_CollectionChanged;
            _fileService = fileService;
            _personService = personService;
            _personService.SetCompetitionServiceObj(this);                          // Dependency Injection can't be used in the constructor because of circular dependency
            _competitionDistanceRuleService = competitionDistanceRuleService;
            _competitionDistanceRuleService.SetCompetitionServiceObj(this);         // Dependency Injection can't be used in the constructor because of circular dependency
        }

        public void SetWorkspaceServiceObj(IWorkspaceService workspaceService)
        {
            _workspaceService = workspaceService;
 
            if(_workspaceService != null)
            {
                _workspaceService.PropertyChanged += (sender, e) =>
                {
                    if (e.PropertyName == nameof(IWorkspaceService.Settings))
                    {
                        UpdateAllCompetitionsForPerson();
                    }
                };
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public async Task<bool> Load(string path, CancellationToken cancellationToken)
        {
            bool importingResult = false;
            Exception exception = null;
            await Task.Run(() =>
            {
                try
                {
                    if (!File.Exists(path))
                    {
                        OnFileProgress?.Invoke(this, 0);
                        ClearAll();
                        OnFileProgress?.Invoke(this, 100);
                    }
                    else
                    {
                        List<Competition> list = _fileService.LoadFromCsv<Competition>(path, cancellationToken, Competition.SetPropertyFromString, OnFileProgress, (header) =>
                        {
                            return PropertyNameLocalizedStringHelper.FindProperty(typeof(Competition), header);
                        });
                        _competitionList = new ObservableCollection<Competition>();
                        foreach (Competition competition in list)
                        {
                            AddCompetition(competition);
                        }
                        _competitionList.CollectionChanged += _competitionList_CollectionChanged;
                    }
 
                    _competitionListOnLoad = _competitionList.ToList().ConvertAll(c => new Competition(c));
 
                    PersistentPath = path;
                    importingResult = true;
                }
                catch (OperationCanceledException)
                {
                    importingResult = false;
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
            });
            OnFileFinished?.Invoke(this, null);
            if (exception != null) { throw exception; }
            return importingResult;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public async Task<bool> Save(CancellationToken cancellationToken, string path = "")
        {
            if (string.IsNullOrEmpty(path)) { path = PersistentPath; }
 
            bool saveResult = false;
            Exception exception = null;
            await Task.Run(() =>
            {
                try
                {
                    _fileService.SaveToCsv(path, _competitionList.ToList(), cancellationToken, OnFileProgress, (data, parentObject, currentProperty) =>
                    {
                        if (data is Enum dataEnum)
                        {
                            return EnumCoreLocalizedStringHelper.Convert(dataEnum);
                        }
                        else if (data is bool dataBool)
                        {
                            return dataBool ? "X" : "";
                        }
                        else
                        {
                            return data.ToString();
                        }
                    },
                    (header, type) =>
                    {
                        return PropertyNameLocalizedStringHelper.Convert(typeof(Competition), header);
                    });
 
                    _competitionListOnLoad = _competitionList.ToList().ConvertAll(c => new Competition(c));
                    saveResult = true;
                }
                catch (OperationCanceledException)
                {
                    saveResult = false;
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
            });
            OnFileFinished?.Invoke(this, null);
            if (exception != null) { throw exception; }
            return saveResult;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public ObservableCollection<Competition> GetCompetitions() => _competitionList;

        public void ClearAll()
        {
            if (_competitionList == null) 
            { 
                _competitionList = new ObservableCollection<Competition>();
                _competitionList.CollectionChanged += _competitionList_CollectionChanged;
            }
            foreach (Competition competition in _competitionList)
            {
                competition.PropertyChanged -= Competition_PropertyChanged;
            }
            if (_competitionList.Count > 0) { _competitionList.Clear(); }
 
            OnPropertyChanged(nameof(CompetitionCount));
            UpdateAllCompetitionsForPerson();
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void ResetToLoadedState()
        {
            if (_competitionListOnLoad == null) { return; }
            _competitionList.CollectionChanged -= _competitionList_CollectionChanged;
            ClearAll();
            foreach (Competition competition in _competitionListOnLoad)
            {
                AddCompetition(new Competition(competition));
            }
            _competitionList.CollectionChanged += _competitionList_CollectionChanged;
            UpdateAllCompetitionDistancesFromDistanceRules(true);
        }

        public void AddCompetition(Competition competition)
        {
            if (_competitionList == null) 
            { 
                _competitionList = new ObservableCollection<Competition>(); 
                _competitionList.CollectionChanged += _competitionList_CollectionChanged;
            }
            _competitionList.Add(competition);
 
            competition.PropertyChanged += Competition_PropertyChanged;
 
            UpdateHasDuplicatesForCompetitions();
 
            OnPropertyChanged(nameof(CompetitionCount));
            UpdateAllCompetitionsForPerson();
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void RemoveCompetition(Competition competition)
        {
            competition.PropertyChanged -= Competition_PropertyChanged;
            _competitionList?.Remove(competition);
 
            UpdateHasDuplicatesForCompetitions();
 
            OnPropertyChanged(nameof(CompetitionCount));
            UpdateAllCompetitionsForPerson();
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }
 
        private void Competition_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            switch (e.PropertyName)
            {
                case nameof(Competition.Gender):
                case nameof(Competition.SwimmingStyle):
                case nameof(Competition.Age):
                    UpdateHasDuplicatesForCompetitions();
                    UpdateAllCompetitionsForPerson();
                    UpdateCompetitionDistanceFromDistanceRules(sender as Competition, false);
                    break;
                default: break;
            }            
            
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }
 
        private void _competitionList_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            UpdateHasDuplicatesForCompetitions();
            UpdateAllCompetitionsForPerson();
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public int CompetitionCount => _competitionList?.Count ?? 0;

        public void UpdateHasDuplicatesForCompetitions()
        {
            CompetitionBasicEqualityComparer basicCompetitionComparer = new CompetitionBasicEqualityComparer();
            IEnumerable<IGrouping<Competition, Competition>> duplicateGroups = _competitionList.GroupBy(c => c, basicCompetitionComparer).Where(g => g.Count() > 1);
 
            // Reset all HasDuplicates flags
            foreach (Competition c in _competitionList) { c.HasDuplicates = false; }
 
            // Set HasDuplicates flag for all competitions that are in a duplicate group
            foreach (IGrouping<Competition, Competition> duplicateGroup in duplicateGroups)
            {
                foreach (Competition c in duplicateGroup) { c.HasDuplicates = true; }
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public bool HasUnsavedChanges => (_competitionList != null && _competitionListOnLoad != null) ? !_competitionList.SequenceEqual(_competitionListOnLoad) : false;
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public Competition GetCompetitionForPerson(Person person, SwimmingStyles swimmingStyle, out bool isUsingMaxAgeCompetition, out bool isUsingExactAgeCompetition)
        {
            isUsingMaxAgeCompetition = false;
            isUsingExactAgeCompetition = true;
 
            // Get all competitions that match the gender and swimming style
            List<Competition> competitions = _competitionList.Where(c => c.Gender == person.Gender && c.SwimmingStyle == swimmingStyle)
                                                             .OrderBy(c => c.Age).ToList();
            if (competitions.Count == 0) { return null; }
 
            CompetitionSearchModes searchMode = _workspaceService?.Settings?.GetSettingValue<CompetitionSearchModes>(WorkspaceSettings.GROUP_GENERAL, WorkspaceSettings.SETTING_GENERAL_COMPETITIONSEARCHMODE) ?? CompetitionSearchModes.ExactOrNextLowerOnlyMaxAge;
            ushort competitionYear = _workspaceService?.Settings?.GetSettingValue<ushort>(WorkspaceSettings.GROUP_GENERAL, WorkspaceSettings.SETTING_GENERAL_COMPETITIONYEAR) ?? 0;
            int personAge = competitionYear - person.BirthYear;
            byte maxAge = competitions.Max(c => c.Age);
            byte minAge = competitions.Min(c => c.Age);
 
            // Special case WaterFlea
            if (swimmingStyle == SwimmingStyles.WaterFlea)
            {
                return competitions.Where(c => personAge <= c.Age).FirstOrDefault();
            }
 
            Competition foundCompetition = null;
            switch (searchMode)
            {
                case CompetitionSearchModes.OnlyExactAge:
                    foundCompetition = competitions.FirstOrDefault(c => c.Age == personAge);
                    break;
                case CompetitionSearchModes.ExactOrNextLowerAge:
                    foundCompetition = competitions.LastOrDefault(c => c.Age <= personAge);
                    break;
                case CompetitionSearchModes.ExactOrNextHigherAge:
                    foundCompetition = competitions.FirstOrDefault(c => c.Age >= personAge);
                    break;
                case CompetitionSearchModes.ExactOrNextLowerOnlyMaxAge:
                    foundCompetition = competitions.FirstOrDefault(c => c.Age == personAge);
                    if (foundCompetition == null && personAge > maxAge)    // if no exact match was found and the person age is greater than the max age, use the competition with the max age
                    {
                        foundCompetition = competitions.FirstOrDefault(c => c.Age == maxAge);
                    }
                    break;
                case CompetitionSearchModes.ExactOrNearestPreferLower:
                    foundCompetition = competitions.FirstOrDefault(c => c.Age == personAge);
                    if (foundCompetition == null)
                    {
                        // Calculate age distance and order by minimal distance. Prefer lower age on equal distance.
                        foundCompetition = competitions.OrderBy(c => Math.Abs(c.Age - personAge)).ThenBy(c => c.Age).FirstOrDefault();
                    }
                    break;
                case CompetitionSearchModes.ExactOrNearestPreferHigher:
                    foundCompetition = competitions.FirstOrDefault(c => c.Age == personAge);
                    if (foundCompetition == null)
                    {
                        // Calculate age distance and order by minimal distance. Prefer higher age on equal distance.
                        foundCompetition = competitions.OrderBy(c => Math.Abs(c.Age - personAge)).ThenByDescending(c => c.Age).FirstOrDefault();
                    }
                    break;
            }
 
            if (foundCompetition != null && foundCompetition.Age == maxAge) { isUsingMaxAgeCompetition = true; }
            if (foundCompetition != null && foundCompetition.Age != personAge) { isUsingExactAgeCompetition = false; }
 
            return foundCompetition;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void UpdateAllCompetitionsForPerson(Person person)
        {
            // Update the available competitions for the person
            List<SwimmingStyles> _availableSwimmingStyles = Enum.GetValues(typeof(SwimmingStyles)).Cast<SwimmingStyles>().Where(s => s != SwimmingStyles.Unknown).ToList();
            Dictionary<SwimmingStyles, Competition> availableCompetitions = new Dictionary<SwimmingStyles, Competition>();
            Dictionary<SwimmingStyles, bool> isUsingMaxAgeCompetitionDict = new Dictionary<SwimmingStyles, bool>();
            Dictionary<SwimmingStyles, bool> isUsingExactAgeCompetitionDict = new Dictionary<SwimmingStyles, bool>();
            foreach (SwimmingStyles swimmingStyle in _availableSwimmingStyles)
            {
                bool isUsingMaxAgeCompetition, isUsingExactAgeCompetition;
                Competition competition = GetCompetitionForPerson(person, swimmingStyle, out isUsingMaxAgeCompetition, out isUsingExactAgeCompetition);
                
                availableCompetitions[swimmingStyle] = competition;
                isUsingMaxAgeCompetitionDict[swimmingStyle] = isUsingMaxAgeCompetition;
                isUsingExactAgeCompetitionDict[swimmingStyle] = isUsingExactAgeCompetition;
            }
            person.AvailableCompetitions = availableCompetitions;
            person.IsUsingMaxAgeCompetitionDict = isUsingMaxAgeCompetitionDict;
            person.IsUsingExactAgeCompetitionDict = isUsingExactAgeCompetitionDict;
 
            // Update the competitions for the person starts
            foreach (PersonStart personStart in _personService.GetAllPersonStarts(PersonStartFilters.Person, person))
            {
                personStart.CompetitionObj = person.AvailableCompetitions[personStart.Style];
                personStart.IsUsingMaxAgeCompetition = person.IsUsingMaxAgeCompetitionDict[personStart.Style];
                personStart.IsUsingExactAgeCompetition = person.IsUsingExactAgeCompetitionDict[personStart.Style];
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void UpdateAllCompetitionsForPerson()
        {
            foreach (Person person in _personService.GetPersons())
            {
                UpdateAllCompetitionsForPerson(person);
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void UpdateCompetitionDistanceFromDistanceRules(Competition competition, bool keepRudolphTableFlags)
        {
            if (competition == null) { return; }
            bool isTimeFromRudolphTable = competition.IsTimeFromRudolphTable;
            bool isTimeInterpolatedFromRudolphTable = competition.IsTimeInterpolatedFromRudolphTable;
            bool isOpenAgeTimeFromRudolphTable = competition.IsOpenAgeTimeFromRudolphTable;
            competition.Distance = _competitionDistanceRuleService.GetCompetitionDistanceFromRules(competition.Age, competition.SwimmingStyle);
            if(keepRudolphTableFlags)
            {
                competition.IsTimeFromRudolphTable = isTimeFromRudolphTable;
                competition.IsTimeInterpolatedFromRudolphTable = isTimeInterpolatedFromRudolphTable;
                competition.IsOpenAgeTimeFromRudolphTable = isOpenAgeTimeFromRudolphTable;
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void UpdateAllCompetitionDistancesFromDistanceRules(bool keepRudolphTableFlags)
        {
            foreach (Competition competition in _competitionList)
            {
                UpdateCompetitionDistanceFromDistanceRules(competition, keepRudolphTableFlags);
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void CreateCompetitionsFromRudolphTable(string rudolphTableCsvFile, byte rudolphScore)
        {
            RudolphTable rudolphTable = new RudolphTable(rudolphTableCsvFile);
 
            // Find the maximum ages for each swimming style in the rudolph table
            Dictionary<SwimmingStyles, byte> maxAgesBySwimmingStyles = rudolphTable.Entries
                                                                        .GroupBy(e => e.SwimmingStyle)
                                                                        .ToDictionary(g => g.Key, g => g.Max(e => e.Age));
 
            List<Competition> competitions = rudolphTable.Entries
                                                .Where(e => e.RudolphScore == rudolphScore &&
                                                            e.Distance == _competitionDistanceRuleService.GetCompetitionDistanceFromRules(e.IsOpenAge ? maxAgesBySwimmingStyles[e.SwimmingStyle] : e.Age, e.SwimmingStyle))
                                                .Select(e => new Competition
                                                             {
                                                                 Gender = e.Gender,
                                                                 Age = e.IsOpenAge ? (byte)(maxAgesBySwimmingStyles[e.SwimmingStyle] + 1) : e.Age,      // for the open age, use the maximum age + 1
                                                                 SwimmingStyle = e.SwimmingStyle,
                                                                 Distance = e.Distance,
                                                                 BestTime = e.Time,
                                                                 IsTimeFromRudolphTable = true,
                                                                 IsTimeInterpolatedFromRudolphTable = false,
                                                                 IsOpenAgeTimeFromRudolphTable = e.IsOpenAge
                                                             }
                                                ).ToList();
 
            // All competitions should be deleted here that are later added from the competitions list.
            // All competitions that are not in this list are kept.
            CompetitionBasicEqualityComparer basicEqualityComparer = new CompetitionBasicEqualityComparer();
            List<Competition> competitionsToDelete = _competitionList.Intersect(competitions, basicEqualityComparer).ToList();
            foreach (Competition competition in competitionsToDelete)
            {
                competition.PropertyChanged -= Competition_PropertyChanged;
                _competitionList.Remove(competition);
            }
            OnPropertyChanged(nameof(CompetitionCount));
            UpdateAllCompetitionsForPerson();
            // Reset the IsTimeInterpolatedFromRudolphTable and IsOpenAgeTimeFromRudolphTable flag for all remaining competitions
            foreach (Competition competition in _competitionList)
            {
                competition.IsTimeInterpolatedFromRudolphTable = false;
                competition.IsOpenAgeTimeFromRudolphTable = false;
            }
            OnPropertyChanged(nameof(HasUnsavedChanges));
 
            // Add all new competitions
            int id = 1;
            foreach (Competition competition in competitions)
            {
                List<int> currentIds = _competitionList.Select(c => c.Id).ToList();
                while (currentIds.Contains(id)) { id++; }
 
                competition.Id = id;
                AddCompetition(competition);
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void UpdateAllCompetitionTimesFromRudolphTable(string rudolphTableCsvFile, byte rudolphScore)
        {
            RudolphTable rudolphTable = new RudolphTable(rudolphTableCsvFile);
 
            foreach (Competition competition in _competitionList)
            {
                RudolphTableEntry foundRudolphTableEntry = rudolphTable.GetEntryByParameters(competition.Gender, competition.Age, competition.SwimmingStyle, competition.Distance, rudolphScore);
                if (foundRudolphTableEntry != null)
                {
                    competition.BestTime = foundRudolphTableEntry.Time;
                    competition.IsTimeFromRudolphTable = true;
                    competition.IsTimeInterpolatedFromRudolphTable = false;
                    competition.IsOpenAgeTimeFromRudolphTable = foundRudolphTableEntry.IsOpenAge;
                }
                else
                {
                    competition.IsTimeFromRudolphTable = false;
                    competition.IsTimeInterpolatedFromRudolphTable = false;
                    competition.IsOpenAgeTimeFromRudolphTable = false;
                }
            }
            interpolateMissingCompetitionTimesFromRudolphTable(rudolphTable, rudolphScore);
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        private void interpolateMissingCompetitionTimesFromRudolphTable(RudolphTable rudolphTable, byte rudolphScore)
        {
            // Create groups for specific combinations of SwimmingStyle, Gender and Distance
            var groups = _competitionList.GroupBy(c => (c.SwimmingStyle, c.Gender, c.Distance));
            List<string> groupErrorStrings = new List<string>();
            foreach(var group in groups)
            {
                SwimmingStyles groupSwimmingStyle = group.Key.SwimmingStyle;
                Genders groupGender = group.Key.Gender;
                ushort groupDistance = group.Key.Distance;
 
                List<Competition> competitionsRudolphTable = group.Where(c => c.IsTimeFromRudolphTable).ToList();
                List<Competition> competitionsMissingTimes = group.Where(c => !c.IsTimeFromRudolphTable).ToList();
 
                // Continue if the swimming style is WaterFlea. This is not supported by the Rudolph Table and will always produce errors.
                if(groupSwimmingStyle == SwimmingStyles.WaterFlea)
                {
                    continue;
                }
 
                // Continue if all times are from the rudolph table (nothing to do)
                if (competitionsMissingTimes.Count == 0)
                {
                    continue;
                }
 
                // Create error entry and continue when there are too less times from the rudolph table (not able to interpolate)
                if (competitionsRudolphTable.Count < 3)
                {
                    groupErrorStrings.Add(string.Format(Properties.Resources.InterpolateMissingCompetitionTimesFromRudolphTableErrorFormatString, groupDistance, EnumCoreLocalizedStringHelper.Convert(groupSwimmingStyle), EnumCoreLocalizedStringHelper.Convert(groupGender)));
                    continue;
                }
 
                double[] dataX = competitionsRudolphTable.Select(c => (double)c.Age).ToArray();
                double[] dataY = competitionsRudolphTable.Select(c => c.BestTime.TotalMilliseconds).ToArray();
 
                // Rudolph data seems to use a polynom of 3th grade: https://schwimmlexikon.de/rudolph-tabelle/
                Polynomial poly = Polynomial.Fit(dataX, dataY, 3);
                foreach (Competition missingTimeCompetition in competitionsMissingTimes)
                {
                    double interpolatedTimeMilliseconds = poly.Evaluate(missingTimeCompetition.Age);
                    missingTimeCompetition.BestTime = new TimeSpan(0, 0, 0, 0, (int)interpolatedTimeMilliseconds);
                    missingTimeCompetition.IsTimeInterpolatedFromRudolphTable = true;
                }
            }
            if(groupErrorStrings.Count > 0)
            {
                string errorString = string.Join(Environment.NewLine, groupErrorStrings);
                throw new Exception(errorString);
            }
        }
    }
}