CompetitionDistanceRuleService.cs

using CommunityToolkit.Mvvm.ComponentModel;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data;
using System.Runtime.Intrinsics.X86;
using System.Text;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Helpers;
using Vereinsmeisterschaften.Core.Models;
 
namespace Vereinsmeisterschaften.Core.Services
{
    public class CompetitionDistanceRuleService : ObservableObject, ICompetitionDistanceRuleService
    {
        public event ProgressDelegate OnFileProgress;

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

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

        private ObservableCollection<CompetitionDistanceRule> _competitionDistanceRules { get; set; }

        private List<CompetitionDistanceRule> _competitionDistanceRulesOnLoad { get; set; }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        private IFileService _fileService;
        private ICompetitionService _competitionService;

        public CompetitionDistanceRuleService(IFileService fileService)
        {
            _competitionDistanceRules = new ObservableCollection<CompetitionDistanceRule>();
            _competitionDistanceRules.CollectionChanged += _competitionDistanceRules_CollectionChanged;
            _fileService = fileService;
        }

        public void SetCompetitionServiceObj(ICompetitionService competitionService)
        {
            _competitionService = competitionService;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        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<CompetitionDistanceRule> list = _fileService.LoadFromCsv<CompetitionDistanceRule>(path, cancellationToken, CompetitionDistanceRule.SetPropertyFromString, OnFileProgress, (header) =>
                        {
                            return PropertyNameLocalizedStringHelper.FindProperty(typeof(CompetitionDistanceRule), header);
                        });
                        _competitionDistanceRules = new ObservableCollection<CompetitionDistanceRule>();
                        foreach (CompetitionDistanceRule rule in list)
                        {
                            AddDistanceRule(rule);
                        }
                        _competitionDistanceRules.CollectionChanged += _competitionDistanceRules_CollectionChanged;
                    }
 
                    _competitionDistanceRulesOnLoad = _competitionDistanceRules.ToList().ConvertAll(cr => new CompetitionDistanceRule(cr));
 
                    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, _competitionDistanceRules.ToList(), cancellationToken, OnFileProgress, (data, parentObject, currentProperty) =>
                    {
                        if (data is Enum dataEnum)
                        {
                            return EnumCoreLocalizedStringHelper.Convert(dataEnum);
                        }
                        else
                        {
                            return data.ToString();
                        }
                    },
                    (header, type) =>
                    {
                        return PropertyNameLocalizedStringHelper.Convert(typeof(CompetitionDistanceRule), header);
                    });
 
                    _competitionDistanceRulesOnLoad = _competitionDistanceRules.ToList().ConvertAll(cr => new CompetitionDistanceRule(cr));
                    saveResult = true;
                }
                catch (OperationCanceledException)
                {
                    saveResult = false;
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
            });
            OnFileFinished?.Invoke(this, null);
            if (exception != null) { throw exception; }
            return saveResult;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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

        public ObservableCollection<CompetitionDistanceRule> GetCompetitionDistanceRules() => _competitionDistanceRules;

        public void ClearAll()
        {
            if (_competitionDistanceRules == null)
            {
                _competitionDistanceRules = new ObservableCollection<CompetitionDistanceRule>();
                _competitionDistanceRules.CollectionChanged += _competitionDistanceRules_CollectionChanged;
            }
            foreach (CompetitionDistanceRule rule in _competitionDistanceRules)
            {
                rule.PropertyChanged -= DistanceRule_PropertyChanged;
            }
            if (_competitionDistanceRules.Count > 0) { _competitionDistanceRules.Clear(); }
 
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void ResetToLoadedState()
        {
            if (_competitionDistanceRulesOnLoad == null) { return; }
            _competitionDistanceRules.CollectionChanged -= _competitionDistanceRules_CollectionChanged;
            ClearAll();
            foreach (CompetitionDistanceRule rule in _competitionDistanceRulesOnLoad)
            {
                AddDistanceRule(new CompetitionDistanceRule(rule));
            }
            _competitionDistanceRules.CollectionChanged += _competitionDistanceRules_CollectionChanged;
        }

        public void AddDistanceRule(CompetitionDistanceRule distanceRule)
        {
            if (_competitionDistanceRules == null)
            {
                _competitionDistanceRules = new ObservableCollection<CompetitionDistanceRule>();
                _competitionDistanceRules.CollectionChanged += _competitionDistanceRules_CollectionChanged;
            }
            _competitionDistanceRules.Add(distanceRule);
            distanceRule.PropertyChanged += DistanceRule_PropertyChanged;
 
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public void RemoveDistanceRule(CompetitionDistanceRule distanceRule)
        {
            distanceRule.PropertyChanged -= DistanceRule_PropertyChanged;
            _competitionDistanceRules?.Remove(distanceRule);
 
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }
 
        private void DistanceRule_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            _competitionService.UpdateAllCompetitionDistancesFromDistanceRules();
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }
 
        private void _competitionDistanceRules_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            _competitionService.UpdateAllCompetitionDistancesFromDistanceRules();
            OnPropertyChanged(nameof(HasUnsavedChanges));
        }

        public ushort GetCompetitionDistanceFromRules(byte age, SwimmingStyles swimmingStyle)
        {
            CompetitionDistanceRule rule = _competitionDistanceRules.FirstOrDefault(r => age >= r.MinAge &&
                                                                                         age <= r.MaxAge &&
                                                                                         r.SwimmingStyle == swimmingStyle);
            if (rule == null)
            {
                return 0;   // No distance rule found
            }
            return rule.Distance;
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Validation

        public List<CompetitionDistanceRuleValidationIssue> ValidateRules()
        {
            List<CompetitionDistanceRuleValidationIssue> result = new List<CompetitionDistanceRuleValidationIssue>();
 
            List<SwimmingStyles> ruleStyles = _competitionDistanceRules.Select(r => r.SwimmingStyle).Distinct().ToList();
            foreach (SwimmingStyles style in ruleStyles)
            {
                result.AddRange(validateAgeGaps(style));
                result.AddRange(validateOverlaps(style));
                result.AddRange(validateUnreachableRules(style));
            }
 
            // Each unreachable rule is also overlapped completely by another rule.
            // It is enough to only report the unreachable state.
            HashSet<CompetitionDistanceRule> unreachableRules = result.Where(i => i.IssueType == CompetitionDistanceRuleValidationIssue.CompetitionDistanceRuleValidationIssueType.UnreachableRule)
                                                                      .Select(i => i.Rule1)
                                                                      .ToHashSet();
            result.RemoveAll(i => i.IssueType == CompetitionDistanceRuleValidationIssue.CompetitionDistanceRuleValidationIssueType.Overlap &&
                                  (unreachableRules.Contains(i.Rule1) || unreachableRules.Contains(i.Rule2)));
 
            return result;
        }

        private List<CompetitionDistanceRuleValidationIssue> validateAgeGaps(SwimmingStyles style)
        {
            List<CompetitionDistanceRuleValidationIssue> validationResult = new List<CompetitionDistanceRuleValidationIssue>();
 
            List<CompetitionDistanceRule> orderedAndFilteredRules = _competitionDistanceRules.Where(r => r.SwimmingStyle == style)?.OrderBy(r => r.MinAge).ToList();
            for (int i = 0; i < orderedAndFilteredRules.Count - 1; i++)
            {
                CompetitionDistanceRule currentRule = orderedAndFilteredRules[i];
                CompetitionDistanceRule nextRule = orderedAndFilteredRules[i + 1];
 
                if (currentRule.MaxAge + 1 < nextRule.MinAge)
                {
                    CompetitionDistanceRuleValidationIssue issue = new CompetitionDistanceRuleValidationIssue
                    {
                        IssueType = CompetitionDistanceRuleValidationIssue.CompetitionDistanceRuleValidationIssueType.AgeGap,
                        SwimmingStyle = style,
                        MinAge = (byte)(currentRule.MaxAge + 1),
                        MaxAge = (byte)(nextRule.MinAge - 1),
                        Rule1 = currentRule,
                        Rule2 = nextRule
                    };
 
                    validationResult.Add(issue);
                }
            }
            return validationResult;
        }

        private List<CompetitionDistanceRuleValidationIssue> validateOverlaps(SwimmingStyles style)
        {
            List<CompetitionDistanceRuleValidationIssue> validationResult = new List<CompetitionDistanceRuleValidationIssue>();
 
            List<CompetitionDistanceRule> orderedAndFilteredRules = _competitionDistanceRules.Where(r => r.SwimmingStyle == style)?.OrderBy(r => r.MinAge).ToList();
            for (int i = 0; i < orderedAndFilteredRules.Count - 1; i++)
            {
                CompetitionDistanceRule currentRule = orderedAndFilteredRules[i];
                CompetitionDistanceRule nextRule = orderedAndFilteredRules[i + 1];
 
                if (nextRule.MinAge <= currentRule.MaxAge)
                {
                    CompetitionDistanceRuleValidationIssue issue = new CompetitionDistanceRuleValidationIssue
                    {
                        IssueType = CompetitionDistanceRuleValidationIssue.CompetitionDistanceRuleValidationIssueType.Overlap,
                        SwimmingStyle = style,
                        MinAge = nextRule.MinAge,
                        MaxAge = (byte)Math.Min(currentRule.MaxAge, nextRule.MaxAge),
                        Rule1 = currentRule,
                        Rule2 = nextRule
                    };
 
                    validationResult.Add(issue);
                }
            }
            return validationResult;
        }

        private List<CompetitionDistanceRuleValidationIssue> validateUnreachableRules(SwimmingStyles style)
        {
            List<CompetitionDistanceRuleValidationIssue> validationResult = new List<CompetitionDistanceRuleValidationIssue>();
 
            List<CompetitionDistanceRule> filteredRules = _competitionDistanceRules.Where(r => r.SwimmingStyle == style).ToList();
 
            HashSet<byte> coveredAges = new HashSet<byte>();
            foreach (CompetitionDistanceRule rule in filteredRules)
            {
                bool anyReachable = false;
 
                for (byte age = rule.MinAge; age <= rule.MaxAge; age++)
                {
                    if (!coveredAges.Contains(age))
                    {
                        anyReachable = true;
                        break;
                    }
                }
 
                if (!anyReachable)
                {
                    CompetitionDistanceRuleValidationIssue issue = new CompetitionDistanceRuleValidationIssue
                    {
                        IssueType = CompetitionDistanceRuleValidationIssue.CompetitionDistanceRuleValidationIssueType.UnreachableRule,
                        SwimmingStyle = style,
                        Rule1 = rule
                    };
                    validationResult.Add(issue);
                }
 
                for (byte age = rule.MinAge; age <= rule.MaxAge; age++)
                {
                    coveredAges.Add(age);
                }
            }
            return validationResult;
        }
 
        #endregion
    }
}