RacesVariant.cs

using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using CommunityToolkit.Mvvm.ComponentModel;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Settings;
 
namespace Vereinsmeisterschaften.Core.Models
{
    public partial class RacesVariant : ObservableObject, IEquatable<RacesVariant>, ICloneable
    {
        #region Constructors / Destructor
 
        private IWorkspaceService _workspaceService;

        public RacesVariant(IWorkspaceService workspaceService = null)
        {
            Races = new ObservableCollection<Race>();
            Races.CollectionChanged += Races_CollectionChanged;
            _workspaceService = workspaceService;
            if (_workspaceService != null) { _workspaceService.PropertyChanged += workspaceServicePropertyChangedEvent; }
        }

        public RacesVariant(List<Race> races, IWorkspaceService workspaceService = null)
        {
            Races = new ObservableCollection<Race>(races);
            Races.CollectionChanged += Races_CollectionChanged;
            _workspaceService = workspaceService;
            if (_workspaceService != null) { _workspaceService.PropertyChanged += workspaceServicePropertyChangedEvent; }
 
            Races_CollectionChanged(Races, null);
        }

        public RacesVariant(ObservableCollection<Race> races, IWorkspaceService workspaceService = null)
        {
            Races = races;
            Races.CollectionChanged += Races_CollectionChanged;
            _workspaceService = workspaceService;
            if (_workspaceService != null) { _workspaceService.PropertyChanged += workspaceServicePropertyChangedEvent; }
 
            Races_CollectionChanged(Races, null);
        }

        public RacesVariant(RacesVariant other, bool deepClone = true, bool deepCloneRaces = true, IWorkspaceService workspaceService = null) : this()
        {
            if (other == null) { return; }
            if (deepClone)
            {
                // Create a deep copy of the list
                Races = new ObservableCollection<Race>(other.Races.Select(item => new Race(item, deepCloneRaces)));
            }
            else
            {
                // Create a new list but keep the references to the <see cref="Race"/> objects
                Races = new ObservableCollection<Race>(other.Races);
            }
 
            Races.CollectionChanged += Races_CollectionChanged;
            _workspaceService = workspaceService ?? other._workspaceService;
            if (_workspaceService != null) { _workspaceService.PropertyChanged += workspaceServicePropertyChangedEvent; }
 
            VariantID = other.VariantID;
            Races_CollectionChanged(Races, null);
        }

        ~RacesVariant()
        {
            if (_workspaceService != null) { _workspaceService.PropertyChanged -= workspaceServicePropertyChangedEvent; }
        }
 
        #endregion
        
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Basic properties

        public ObservableCollection<Race> Races { get; set; }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Not assigned starts
 
        private List<PersonStart> _notAssignedStarts;
        [FileServiceIgnore]
        public List<PersonStart> NotAssignedStarts
        {
            get => _notAssignedStarts;
            set => SetProperty(ref _notAssignedStarts, value);
        }

        public void UpdateNotAssignedStarts(List<PersonStart> allStarts)
        {
            List<PersonStart> raceStarts = GetAllStarts();
            if (allStarts == null)
            {
                NotAssignedStarts = new List<PersonStart>();
            }
            else if (raceStarts == null)
            {
                NotAssignedStarts = allStarts.Where(s => s.IsActive).ToList();
            }
            else
            {
                NotAssignedStarts = allStarts?.Except(raceStarts)?.Where(s => s.IsActive)?.ToList();
            }
            OnPropertyChanged(nameof(IsValid_AllRacesValid));
            OnPropertyChanged(nameof(IsValid_AllStartsAssigned));
            OnPropertyChanged(nameof(IsValid));
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Other properties
 
        private int _variantID;
        [FileServiceIgnore]
        public int VariantID
        {
            get => _variantID;
            set => SetProperty(ref _variantID, value);
        }
 
        private bool _isPersistent;
        [FileServiceIgnore]
        public bool IsPersistent
        {
            get => _isPersistent;
            set
            {
                if (SetProperty(ref _isPersistent, value))
                {
                    OnPropertyChanged(nameof(KeepWhileRacesCalculation));
                }
            }
        }
 
        private bool _keepWhileRacesCalculation;
        [FileServiceIgnore]
        public bool KeepWhileRacesCalculation
        {
            get => _keepWhileRacesCalculation || IsPersistent;
            set => SetProperty(ref _keepWhileRacesCalculation, value);
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Validation properties

        [FileServiceIgnore]
        public bool IsValid_AllRacesValid => Races?.All(r => r.IsValid) ?? true;

        [FileServiceIgnore]
        public bool IsValid_AllStartsAssigned => NotAssignedStarts?.Count == 0;

        public bool IsValid => IsValid_AllRacesValid && IsValid_AllStartsAssigned;
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Event handlers
 
        private void workspaceServicePropertyChangedEvent(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(IWorkspaceService.Settings))
            {
                CalculateScore();
            }
        }

        public void UpdateRaceStartsCollectionChangedEvent()
        {
            OnPropertyChanged(nameof(Races));
            foreach (Race race in Races)
            {
                race.Starts.CollectionChanged -= raceStartsCollectionChangedEventHandler;
                race.Starts.CollectionChanged += raceStartsCollectionChangedEventHandler;
            }
        }
 
        private void raceStartsCollectionChangedEventHandler(object sender, NotifyCollectionChangedEventArgs e)
        {
            CalculateScore();
            OnPropertyChanged(nameof(Races));
            OnPropertyChanged(nameof(IsValid_AllRacesValid));
            OnPropertyChanged(nameof(IsValid_AllStartsAssigned));
            OnPropertyChanged(nameof(IsValid));
        }
 
        private void Races_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            updateRaceIDs();
            CalculateScore();
            UpdateRaceStartsCollectionChangedEvent();
            OnPropertyChanged(nameof(IsValid_AllRacesValid));
            OnPropertyChanged(nameof(IsValid_AllStartsAssigned));
            OnPropertyChanged(nameof(IsValid));
        }

        private void updateRaceIDs()
        {
            int id = 1;
            foreach(Race race in Races)
            {
                race.RaceID = id;
                id++;
            }
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Helper methods

        public List<PersonStart> GetAllStarts()
        {
            return Races.SelectMany(r => r.Starts).ToList();
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Score properties

        public double Score
        {
            get
            {
                double weightSingleStarts = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_WEIGHT_SINGLE_STARTS) ?? 5;
                double weightSameStyleSequence = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_WEIGHT_SAME_STYLE_SEQUENCE) ?? 5;
                double weightPersonStartPauses = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_WEIGHT_PERSON_START_PAUSES) ?? 60;
                double weightStyleOrder = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_WEIGHT_STYLE_ORDER) ?? 10;
                double weightStartGenders = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_WEIGHT_START_GENDERS) ?? 5;
                double weightFriendships = _workspaceService?.Settings?.GetSettingValue<double>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_WEIGHT_FRIENDSHIP) ?? 5;
                weightFriendships = AreFriendshipsDefined ? weightFriendships : 0;
                double sumWeights = weightSingleStarts + weightSameStyleSequence + weightPersonStartPauses + weightStyleOrder + weightStartGenders + weightFriendships;
 
                double score = 0;
                score += ScoreSingleStarts * (weightSingleStarts / sumWeights);
                score += ScoreSameStyleSequence * (weightSameStyleSequence / sumWeights);
                score += ScorePersonStartPauses * (weightPersonStartPauses / sumWeights);
                score += ScoreStyleOrder * (weightStyleOrder / sumWeights);
                score += ScoreStartGenders * (weightStartGenders / sumWeights);
                score += ScoreFriendships * (weightFriendships / sumWeights);
 
                return LimitValue(score, 0, 100);
            }
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        [ObservableProperty]
        private double _scoreSingleStarts;
        
        [ObservableProperty]
        private double _scoreSameStyleSequence;
        
        [ObservableProperty]
        private double _scorePersonStartPauses;
        
        [ObservableProperty]
        private double _scoreStyleOrder;

        [ObservableProperty]
        private double _scoreStartGenders;

        [ObservableProperty]
        private double _scoreFriendships;

        [ObservableProperty]
        private bool _areFriendshipsDefined;
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Additional score properties
 
        private List<Person> _personStartPausesSeverelyAffectedPersons;
        public List<Person> PersonStartPausesSeverelyAffectedPersons
        {
            get => _personStartPausesSeverelyAffectedPersons;
            set
            {
                if(SetProperty(ref _personStartPausesSeverelyAffectedPersons, value))
                {
                    OnPropertyChanged(nameof(AreStartPausesSeverelyAffectedPersonsAvailable));
                }
            }
        }

        public bool AreStartPausesSeverelyAffectedPersonsAvailable => (PersonStartPausesSeverelyAffectedPersons?.Count ?? 0) > 0;
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Score calculation methods

        public double CalculateScore()
        {
            if (Races.Count == 0)
            {
                ScoreSingleStarts = 0;
                ScoreSameStyleSequence = 0;
                ScorePersonStartPauses = 0;
                ScoreStyleOrder = 0;
                ScoreStartGenders = 0;
                ScoreFriendships = 0;
            }
            else
            {
                ScoreSingleStarts = EvaluateSingleStarts();
                ScoreSameStyleSequence = EvaluateSameStyleSequence();
                ScorePersonStartPauses = EvaluatePersonStartPauses();
                ScoreStyleOrder = EvaluateStyleOrder();
                ScoreStartGenders = EvaluateStartGenders();
                ScoreFriendships = EvaluateFriendships();
            }
            OnPropertyChanged(nameof(Score));
            return Score;
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        private double EvaluateSingleStarts()
        {
            if (Races.Count == 0) return 0.0;
 
            int singleStarts = Races.Count(r => r.Starts.Count == 1);
            double ratio = (double)singleStarts / Races.Count;
 
            // The less single starts, the better
            return 100 * (1 - ratio);
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        private double EvaluateSameStyleSequence()
        {
            if (Races.Count <= 1) return 100.0;   // Only one race = no evaluation needed
 
            int matchingPairs = 0;
            for (int i = 1; i < Races.Count; i++)
            {
                if (Races[i].Style == Races[i - 1].Style)
                    matchingPairs++;
            }
 
            return 100 * ((double)matchingPairs / (Races.Count - 1));
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        private double EvaluatePersonStartPauses()
        {
            double penalty = 0;
            double maxPenalty = 0;  // This is calculated dynamically
 
            Dictionary<Person, int> lastRaceIndex = new();
            Dictionary<Person, double> individualPenalties = new();
            List<Person> severelyAffectedPersons = new List<Person>();
 
            uint shortPausesThreshold = _workspaceService?.Settings?.GetSettingValue<uint>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_SHORT_PAUSE_THRESHOLD) ?? 3;
            int severelyAffectedPersonsCount = 0;    // Number of persons with hard penalty
 
            for (int i = 0; i < Races.Count; i++)
            {
                foreach (var personStart in Races[i].Starts)
                {
                    // Only consider active starts
                    if (!personStart.IsActive) { continue; }
 
                    Person person = personStart.PersonObj;
 
                    if (lastRaceIndex.TryGetValue(person, out int lastIndex))
                    {
                        int distance = i - lastIndex;
 
                        double personPenalty = distance switch
                        {
                            1 => 100,   // Extremly high penalty for directly consecutive starts
                            2 => 100,   // Extremly high penalty for only one race pause
                            3 => 50,    // Noticeable penalty for two races pause
                            4 => 30,   // Noticeable penalty for three races pause
                            _ => Math.Max(0, 10 - distance) // Minimal penalty for 3+ races pause
                        };
 
                        // if the distance is below shortPausesThreshold races, this is regarded as severly affected
                        if (distance < shortPausesThreshold)
                        {
                            severelyAffectedPersonsCount++;
                            severelyAffectedPersons.Add(person);
                        }
 
                        // Save the highest penalty for a person
                        if (!individualPenalties.ContainsKey(person) || individualPenalties[person] < personPenalty)
                        {
                            individualPenalties[person] = personPenalty;
 
                            maxPenalty += 100;  // Add the highest possible penalty
                        }
                    }
 
                    lastRaceIndex[person] = i;
                }
            }
 
            PersonStartPausesSeverelyAffectedPersons = severelyAffectedPersons.Distinct().ToList();
 
            // Return the worst score if there are severely affected persons
            if (severelyAffectedPersonsCount > 0)
            {
                return 0;
            }
            else
            {
                // Sum up the hardest penalties per person
                penalty = individualPenalties.Values.Sum();
                double score = 100 - (penalty / maxPenalty * 100);
                return LimitValue(score, 0, 100);
            }
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        private double EvaluateStyleOrder()
        {
            if (Races.Count == 0) return 100.0;
 
            // lower numbers should start earlier
            Dictionary<SwimmingStyles, int> StylePriorities = new()
            {
                { SwimmingStyles.Breaststroke, _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_PRIORITY_STYLE_BREASTSTROKE) ?? 1 },
                { SwimmingStyles.Freestyle, _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_PRIORITY_STYLE_FREESTYLE) ?? 2 },
                { SwimmingStyles.Backstroke, _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_PRIORITY_STYLE_BACKSTROKE) ?? 3 },
                { SwimmingStyles.Butterfly, _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_PRIORITY_STYLE_BUTTERFLY) ?? 4 },
                { SwimmingStyles.Medley, _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_PRIORITY_STYLE_MEDLEY) ?? 5 },
                { SwimmingStyles.WaterFlea, _workspaceService?.Settings?.GetSettingValue<int>(WorkspaceSettings.GROUP_RACE_CALCULATION, WorkspaceSettings.SETTING_RACE_CALCULATION_PRIORITY_STYLE_WATERFLEA) ?? 6 }
            };
 
            double penalty = 0;
            foreach (var (race, index) in Races.Select((r, i) => (r, i)))
            {
                if (StylePriorities.TryGetValue(race.Style, out int priority))
                {
                    int expectedMinIndex = Races.Count * priority / StylePriorities.Count;
                    if (index < expectedMinIndex)
                    {
                        penalty += (expectedMinIndex - index);
                    }
                }
            }
 
            double maxPenalty = Races.Count * StylePriorities.Count;
            return 100 - LimitValue(100 * (penalty / maxPenalty), 0, 100);
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        private double EvaluateStartGenders()
        {
            if (Races.Count == 0) return 100.0;
 
            int totalRaces = Races.Count;
            int homogeneousCount = 0;
 
            foreach (Race race in Races)
            {
                List<Genders> genders = race.Starts.Select(s => s.PersonObj.Gender).Distinct().ToList();
                if (genders.Count == 1)
                {
                    homogeneousCount++;
                }
            }
 
            double score = 100.0 * homogeneousCount / totalRaces;
            return LimitValue(score, 0, 100);
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        public double EvaluateFriendships()
        {
            if (Races == null || Races.Count == 0) return 100.0;
 
            double totalFriendScore = 0;
            double maxPossibleScore = 0;
            AreFriendshipsDefined = false;
 
            foreach (Race race in Races)
            {
                List<Person> personsInRace = race.Starts.Select(s => s.PersonObj).ToList();
 
                // Skip races where all persons have no friends
                if (!personsInRace.Any(p => p.Friends != null && p.Friends.Count > 0)) continue;
 
                double raceScore = 0;
                double raceMax = 0;
 
                foreach (Person p1 in personsInRace)
                {
                    if (p1.Friends == null || p1.Friends.Count == 0 || !p1.IsActive) continue;
 
                    AreFriendshipsDefined = true;
 
                    // Only evaluate friends that could compete in the same style / distance
                    List<Person> potentialFriends = p1.Friends.Where(f =>
                    {
                        PersonStart friendStart = f.GetStartByStyle(race.Style);
                        return friendStart != null && friendStart.CompetitionObj != null && friendStart.CompetitionObj?.Distance == race.Distance;
                    }).ToList();
 
                    if (potentialFriends.Count == 0) continue;
 
                    int friendCountInRace = personsInRace.Count(p2 => potentialFriends.Contains(p2));
 
                    raceScore += friendCountInRace;
                    raceMax += potentialFriends.Count;
                }
 
                if (raceMax > 0)
                {
                    totalFriendScore += raceScore / raceMax;
                    maxPossibleScore += 1;
                }
            }
 
            // Neutral score if no friendships are defined
            if (maxPossibleScore == 0) return 50.0;
 
            double score = (totalFriendScore / maxPossibleScore) * 100.0;
            return LimitValue(score, 0, 100);
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        private static double LimitValue(double value, double min, double max)
        {
            return Math.Max(min, Math.Min(max, value));
        }
 
#endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Equality, HashCode, ToString, Clone

        public override bool Equals(object obj)
            => obj is RacesVariant r && r.VariantID == VariantID;

        public bool Equals(RacesVariant other)
            => Equals((object)other);

        public override int GetHashCode()
            => VariantID.GetHashCode();

        public object Clone()
            => new RacesVariant(this, true, true);
 
        #endregion
    }
}