RaceService.cs

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

        public event EventHandler OnFileFinished;
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        private IFileService _fileService;
        private IPersonService _personService;
        private ICompetitionService _competitionService;
        private IWorkspaceService _workspaceService;
 
        private int _nextVariantID;

        public RaceService(IFileService fileService, IPersonService personService, ICompetitionService competitionService)
        {
            _fileService = fileService;
            _personService = personService;
            _personService.SetRaceServiceObj(this);        // Dependency Injection can't be used in the constructor because of circular dependency
            _competitionService = competitionService;
 
            _nextVariantID = 1;
        }

        public void SetWorkspaceServiceObj(IWorkspaceService workspaceService)
        {
            _workspaceService = workspaceService;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public ObservableCollection<RacesVariant> AllRacesVariants { get; private set; } = new ObservableCollection<RacesVariant>();

        public RacesVariant PersistedRacesVariant => AllRacesVariants.Where(r => r.IsPersistent).FirstOrDefault();

        private RacesVariant _persistedRacesVariantOnLoad { get; set; }

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

        public async Task<ObservableCollection<RacesVariant>> CalculateRacesVariants(CancellationToken cancellationToken, ProgressDelegate onProgressIteration = null, ProgressDelegate onProgressSolution = null)
        {
            // Collect all starts
            _competitionService.UpdateAllCompetitionsForPerson();
            List<PersonStart> starts = _personService.GetAllPersonStarts();
 
            // Create groups of competitions with same style and distance
            Dictionary<(SwimmingStyles, ushort), List<PersonStart>> groupedValuesStarts = new Dictionary<(SwimmingStyles, ushort), List<PersonStart>>();
            for (int i = 0; i < starts.Count; i++)
            {
                if (!starts[i].IsCompetitionObjAssigned) { continue; }
 
                (SwimmingStyles, ushort) key = (starts[i].CompetitionObj.SwimmingStyle, starts[i].CompetitionObj.Distance);
                if (!groupedValuesStarts.ContainsKey(key))
                {
                    groupedValuesStarts.Add(key, new List<PersonStart>());
                }
                else if (groupedValuesStarts[key] == null)
                {
                    groupedValuesStarts[key] = new List<PersonStart>();
                }
                groupedValuesStarts[key].Add(starts[i]);
            }
 
            ushort numSwimLanes = _workspaceService?.Settings?.GetSettingValue<ushort>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_NUMBER_OF_SWIM_LANES) ?? 0;
            ushort numberRequestedVariants = _workspaceService?.Settings?.GetSettingValue<ushort>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_NUM_RACE_VARIANTS_AFTER_CALCULATION) ?? 0;
            int maxRaceVariantCalculationLoops = _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_MAX_CALCULATION_LOOPS) ?? 0;
            double minRacesVariantsScore = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_MIN_RACES_VARIANTS_SCORE) ?? 0;
            int numberOfResultsToGenerate = Math.Max(0, numberRequestedVariants - AllRacesVariants.Count(r => r.KeepWhileRacesCalculation));
            
            RacesVariantsGenerator generator = new RacesVariantsGenerator(new Progress<double>(progress => onProgressIteration?.Invoke(this, (float)progress, "")),
                                                                          new Progress<double>(progress => onProgressSolution?.Invoke(this, (float)progress, "")),
                                                                          numberOfResultsToGenerate,
                                                                          maxRaceVariantCalculationLoops,
                                                                          minRacesVariantsScore,
                                                                          numSwimLanes);
            List<RacesVariant> tmpRacesVariants = await generator.GenerateBestRacesAsync(groupedValuesStarts.Values.ToList(), _workspaceService, cancellationToken);
 
            if (!cancellationToken.IsCancellationRequested)
            {
                List<RacesVariant> racesToDelete = AllRacesVariants.Where(r => !r.KeepWhileRacesCalculation).ToList();
                racesToDelete.ForEach(r => AllRacesVariants.Remove(r));
                tmpRacesVariants.ForEach(AddRacesVariant);
                SortVariantsByScore();
                OnPropertyChanged(nameof(PersistedRacesVariant));
            }
            return AllRacesVariants;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public async Task<bool> Load(string path, CancellationToken cancellationToken)
        {
            bool importingResult = false;
            Exception exception = null;
 
            SynchronizationContext uiContext = SynchronizationContext.Current;
            await Task.Run(() =>
            {
                try
                {
                    if (!File.Exists(path))
                    {
                        OnFileProgress?.Invoke(this, 0);
                        uiContext.Send((d) => { ClearAllRacesVariants(); }, null);
                        OnFileProgress?.Invoke(this, 100);
                    }
                    else
                    {
                        List<Race> raceList = _fileService.LoadFromCsv<Race>(path, cancellationToken, setRacePropertyFromString, OnFileProgress, (header) =>
                        {
                            return PropertyNameLocalizedStringHelper.FindProperty(typeof(Race), header);
                        });
                        RacesVariant bestRacesVariant = new RacesVariant(raceList, _workspaceService);
                        bestRacesVariant.IsPersistent = true;
                        uiContext.Send((d) =>
                        {
                            ClearAllRacesVariants();
                            AddRacesVariant(bestRacesVariant);
                        }, null);
                    }
 
                    if (PersistedRacesVariant == null) { _persistedRacesVariantOnLoad = null; }
                    else { _persistedRacesVariantOnLoad = new RacesVariant(PersistedRacesVariant, true, true, _workspaceService); }
 
                    PersistentPath = path;
                    importingResult = true;
                }
                catch (OperationCanceledException)
                {
                    importingResult = false;
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
            });
            OnFileFinished?.Invoke(this, null);
            if (exception != null) { throw exception; }
            return importingResult;
        }
 
        private int _lastParsedDistance = 0;
        private SwimmingStyles _lastParsedStyle = SwimmingStyles.Unknown;
        private void setRacePropertyFromString(Race dataObj, string propertyName, string value)
        {
            if (string.IsNullOrEmpty(value)) return;
 
            switch (propertyName)
            {
                case nameof(Race.Distance): _lastParsedDistance = int.Parse(value); break;
                case nameof(Race.Style): if (EnumCoreLocalizedStringHelper.TryParse(value, out SwimmingStyles parsedStyle)) { _lastParsedStyle = parsedStyle; } break;
                default:
                    {
                        if (dataObj.Starts == null) { dataObj.Starts = new ObservableCollection<PersonStart>(); }
                        if(_lastParsedDistance != 0 && _lastParsedStyle != SwimmingStyles.Unknown)
                        {
                            string[] nameParts = value.Split(',');
                            string firstName = nameParts.Length > 0 ? nameParts[0].Trim() : "";
                            string name = nameParts.Length > 1 ? nameParts[1].Trim() : "";
                            PersonStart matchingStart = _personService.GetAllPersonStarts().Where(s =>  s.Style == _lastParsedStyle &&
                                                                                                        s.CompetitionObj?.Distance == _lastParsedDistance && 
                                                                                                        s.PersonObj?.FirstName == firstName &&
                                                                                                        s.PersonObj?.Name == name).FirstOrDefault();
                            if (matchingStart != null)
                            {
                                dataObj.Starts.Add(matchingStart);
                            }
                        }
                        break;
                    }
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        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
                {
                    if (PersistedRacesVariant == null)
                    {
                        if (File.Exists(path)) { File.Delete(path); }
                        _persistedRacesVariantOnLoad = null;
                    }
                    else
                    {
                        int maxNumberStarts = PersistedRacesVariant.Races.Count == 0 ? 0 : PersistedRacesVariant.Races.Select(r => r.Starts.Count).Max();
                        _fileService.SaveToCsv(path, PersistedRacesVariant.Races.ToList(), cancellationToken, OnFileProgress,
                        (data, parentObject, currentProperty) =>
                        {
                            if (data is IList<PersonStart> dataList)
                            {
                                return string.Join(";", dataList.Select(p => p.PersonObj?.FirstName + ", " + p.PersonObj?.Name));
                            }
                            else if (data is Enum dataEnum)
                            {
                                return EnumCoreLocalizedStringHelper.Convert(dataEnum);
                            }
                            else
                            {
                                return data.ToString();
                            }
                        },
                        (header, headerType) =>
                        {
                            if (headerType == typeof(ObservableCollection<PersonStart>))
                            {
                                string formatedHeader = "";
                                for(int i = 1; i <= maxNumberStarts; i++)
                                {
                                    formatedHeader += $"{PropertyNameLocalizedStringHelper.Convert(typeof(Race), "Person")} {i};";
                                }
                                formatedHeader = formatedHeader.Trim(';');
                                return formatedHeader;
                            }
                            else
                            {
                                return PropertyNameLocalizedStringHelper.Convert(typeof(Race), header);
                            }
                        });
 
                        _persistedRacesVariantOnLoad = new RacesVariant(PersistedRacesVariant, true, true, _workspaceService);
                    }
                    saveResult = true;
                }
                catch (OperationCanceledException)
                {
                    saveResult = false;
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
            });
            OnFileFinished?.Invoke(this, null);
            if (exception != null) { throw exception; }
            return saveResult;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void AddRacesVariant(RacesVariant racesVariant)
        {
            AllRacesVariants.Add(racesVariant);
            racesVariant.VariantID = _nextVariantID;
            _nextVariantID++;
            racesVariant.PropertyChanged += RacesVariant_PropertyChanged;
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void RemoveRacesVariant(RacesVariant racesVariant)
        {
            if(racesVariant == null) { return; }
            racesVariant.PropertyChanged -= RacesVariant_PropertyChanged;
            AllRacesVariants.Remove(racesVariant);
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void ClearAllRacesVariants()
        {
            foreach(RacesVariant racesVariant in AllRacesVariants)
            {
                racesVariant.PropertyChanged -= RacesVariant_PropertyChanged;
                AllRacesVariants.Remove(racesVariant);
            }
            OnPropertyChanged(nameof(HasUnsavedChanges));
            _nextVariantID = 1;
        }

        public void ResetToLoadedState()
        {
            int persistedRaceIndex = PersistedRacesVariant == null ? -1 : AllRacesVariants.IndexOf(PersistedRacesVariant);
            RacesVariant resetRaceVariant = new RacesVariant(_persistedRacesVariantOnLoad, true, false, _workspaceService) { IsPersistent = true };
            if (persistedRaceIndex != -1)
            {
                PersistedRacesVariant.PropertyChanged -= RacesVariant_PropertyChanged;
                AllRacesVariants[persistedRaceIndex] = resetRaceVariant;
                resetRaceVariant.PropertyChanged += RacesVariant_PropertyChanged;
            }
            else
            {
                AddRacesVariant(resetRaceVariant);
            }
            ReassignAllPersonStarts();
 
            OnPropertyChanged(nameof(AllRacesVariants));
            OnPropertyChanged(nameof(PersistedRacesVariant));
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void ReassignAllPersonStarts()
        {
            List<PersonStart> allStarts = _personService.GetAllPersonStarts();
            foreach (RacesVariant racesVariant in AllRacesVariants)
            {
                foreach (Race race in racesVariant.Races)
                {
                    ObservableCollection<PersonStart> newRaceStarts = new ObservableCollection<PersonStart>();
                    foreach (PersonStart oldStart in race.Starts)
                    {
                        PersonStart newStart = allStarts.Where(s => s.PersonObj.Equals(oldStart.PersonObj) && 
                                                                    s.Style == oldStart.Style).FirstOrDefault();
                        newRaceStarts.Add(newStart ?? oldStart);
                    }
                    race.Starts = newRaceStarts;
                }
                racesVariant.UpdateRaceStartsCollectionChangedEvent();
            }
        }

        public void SortVariantsByScore()
        {
            AllRacesVariants = new ObservableCollection<RacesVariant>(AllRacesVariants.OrderByDescending(r => r.Score));
            OnPropertyChanged(nameof(AllRacesVariants));
        }

        public int RecalculateVariantIDs(int oldVariantID = -1)
        {
            int newVariantID = -1;
            _nextVariantID = 1;
            foreach (RacesVariant racesVariant in AllRacesVariants)
            {
                if (racesVariant.VariantID == oldVariantID) { newVariantID = _nextVariantID; }
                racesVariant.VariantID = _nextVariantID;
                _nextVariantID++;
 
                racesVariant.UpdateNotAssignedStarts(_personService.GetAllPersonStarts());
            }
            OnPropertyChanged(nameof(AllRacesVariants));
            return newVariantID;
        }
 
        private void RacesVariant_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(RacesVariant.Races))
            {
                (sender as RacesVariant)?.UpdateNotAssignedStarts(_personService.GetAllPersonStarts());
            }
            OnPropertyChanged(nameof(HasUnsavedChanges));
            OnPropertyChanged(nameof(AllRacesVariants));
            OnPropertyChanged(nameof(PersistedRacesVariant));
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public void CleanupRacesVariants(bool removeInactiveStarts = true)
        {
            List<PersonStart> validPersonStarts = _personService.GetAllPersonStarts();
            
            foreach (RacesVariant racesVariant in AllRacesVariants)
            {
                foreach(Race race in racesVariant.Races)
                {
                    // Find all starts in this race that are no longer part of the valid PersonStarts and remove them from the Race
                    List<PersonStart> startsToDelete = race.Starts.Except(validPersonStarts, new PersonStartWithoutIsActiveEqualityComparer()).ToList();
                    if (removeInactiveStarts)
                    {
                        // Also remove all inactive starts
                        startsToDelete.AddRange(race.Starts.Where(s => !s.IsActive));
                        // Make sure to remove duplicate elements
                        startsToDelete = startsToDelete.Distinct(new PersonStartWithoutIsActiveEqualityComparer()).ToList();
                    }
                    // Remove the starts from the race
                    startsToDelete.ForEach(s => race.Starts.Remove(s));
                }
 
                // Find all empty races and remove them from the variant
                List<Race> racesToDelete = racesVariant.Races.Where(r => r.Starts.Count == 0).ToList();
                racesToDelete.ForEach(r => racesVariant.Races.Remove(r));
            }
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public bool HasUnsavedChanges
        {
            get
            {
                if(PersistedRacesVariant != null && _persistedRacesVariantOnLoad != null)
                {
                    RacesVariantFullEqualityComparer fullEqualityComparer = new RacesVariantFullEqualityComparer();
                    return !fullEqualityComparer.Equals(PersistedRacesVariant, _persistedRacesVariantOnLoad);
                }
                else if(PersistedRacesVariant == null && _persistedRacesVariantOnLoad == null)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
        }
    }
}