Person.cs

using CommunityToolkit.Mvvm.ComponentModel;
using System.Collections.ObjectModel;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Helpers;
 
namespace Vereinsmeisterschaften.Core.Models
{
    public class Person : ObservableObject, IEquatable<Person>, ICloneable
    {
        #region Constructors

        public Person()
        {
            Starts = new Dictionary<SwimmingStyles, PersonStart>();
            List<SwimmingStyles> availableSwimmingStyles = Enum.GetValues(typeof(SwimmingStyles)).Cast<SwimmingStyles>().ToList();
            availableSwimmingStyles.Remove(SwimmingStyles.Unknown);
            foreach(SwimmingStyles style in availableSwimmingStyles)
            {
                Starts.Add(style, null);
 
                // prepare a PersonStart object for each style and store it in the available starts dictionary
                PersonStart newStart = new PersonStart() { Style = style, PersonObj = this };
                newStart.PropertyChanged += PersonStart_PropertyChanged;
                _availableStartsDict.Add(style, newStart);
            }
        }

        public Person(Person other) : this()
        {
            if (other == null) { return; }
            this.Name = other.Name;
            this.FirstName = other.FirstName;
            this.Gender = other.Gender;
            this.BirthYear = other.BirthYear;
 
            // Shallow clone of the Friends list
            this.FriendGroupIDs = (other.FriendGroupIDs != null) ? new ObservableCollection<int>(other.FriendGroupIDs) : null;
            this.Friends = (other.Friends != null) ? new List<Person>(other.Friends) : null;
 
            // Deep clone of the Starts dictionary
            this.Starts = other.Starts.ToDictionary(kvp => kvp.Key, kvp => kvp.Value?.Clone() as PersonStart);
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Basic properties
 
        private string _name = string.Empty;
        [FileServiceOrder]
        public string Name
        {
            get => _name;
            set => SetProperty(ref _name, value);
        }
 
        private string _firstName = string.Empty;
        [FileServiceOrder]
        public string FirstName
        {
            get => _firstName;
            set => SetProperty(ref _firstName, value);
        }
 
        private Genders _gender;
        [FileServiceOrder]
        public Genders Gender
        {
            get => _gender;
            set => SetProperty(ref _gender, value);
        }
 
        private UInt16 _birthYear;
        [FileServiceOrder]
        public UInt16 BirthYear
        {
            get => _birthYear;
            set => SetProperty(ref _birthYear, value);
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Competition related properties
 
        private Dictionary<SwimmingStyles, Competition> _availableCompetitions = new Dictionary<SwimmingStyles, Competition>();
        [FileServiceIgnore]
        public Dictionary<SwimmingStyles, Competition> AvailableCompetitions
        {
            get => _availableCompetitions;
            set
            {
                if (SetProperty(ref _availableCompetitions, value))
                {
                    OnPropertyChanged(nameof(AvailableCompetitionsFlags));
                }
            }
        }

        [FileServiceIgnore]
        public Dictionary<SwimmingStyles, bool> AvailableCompetitionsFlags
        {
            get
            {
                Dictionary<SwimmingStyles, bool> availableCompetitionsFlags = new Dictionary<SwimmingStyles, bool>();
                foreach (KeyValuePair<SwimmingStyles, Competition> kvp in AvailableCompetitions)
                {
                    availableCompetitionsFlags.Add(kvp.Key, kvp.Value != null);
                }
                return availableCompetitionsFlags;
            }
        }

        [FileServiceIgnore]
        public Dictionary<SwimmingStyles, int> AvailableCompetitionsIDs
        {
            get
            {
                Dictionary<SwimmingStyles, int> availableCompetitionsIDs = new Dictionary<SwimmingStyles, int>();
                foreach (KeyValuePair<SwimmingStyles, Competition> kvp in AvailableCompetitions)
                {
                    availableCompetitionsIDs.Add(kvp.Key, kvp.Value?.Id ?? -1);
                }
                return availableCompetitionsIDs;
            }
        }
 
        private Dictionary<SwimmingStyles, bool> _isUsingMaxAgeCompetitionDict = new Dictionary<SwimmingStyles, bool>();
        [FileServiceIgnore]
        public Dictionary<SwimmingStyles, bool> IsUsingMaxAgeCompetitionDict
        {
            get => _isUsingMaxAgeCompetitionDict;
            set => SetProperty(ref _isUsingMaxAgeCompetitionDict, value);
        }
 
        private Dictionary<SwimmingStyles, bool> _isUsingExactAgeCompetitionDict = new Dictionary<SwimmingStyles, bool>();
        [FileServiceIgnore]
        public Dictionary<SwimmingStyles, bool> IsUsingExactAgeCompetitionDict
        {
            get => _isUsingExactAgeCompetitionDict;
            set => SetProperty(ref _isUsingExactAgeCompetitionDict, value);
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Starts management

        private Dictionary<SwimmingStyles, PersonStart> _availableStartsDict = new Dictionary<SwimmingStyles, PersonStart>();
 
        private Dictionary<SwimmingStyles, PersonStart> _starts = new Dictionary<SwimmingStyles, PersonStart>();
        [FileServiceIgnore]
        public Dictionary<SwimmingStyles, PersonStart> Starts
        {
            get => _starts;
            set => SetProperty(ref _starts, value);
        }

        [FileServiceIgnore]
        public bool HasStarts => Starts?.Values?.Any(s => s != null) ?? false;

        public PersonStart GetStartByStyle(SwimmingStyles style)
        {
            return Starts[style];
        }

        public void SetStartAvailable(SwimmingStyles style, bool available)
        {
            PersonStart start = GetStartByStyle(style);
            if (start == null && available)
            {
                Starts[style] = _availableStartsDict[style];
            }
            else if (start != null && !available)
            {
                Starts[style] = null;
            }
            OnPropertyChanged(nameof(Starts));
            OnPropertyChanged(nameof(HasStarts));
            OnPropertyChanged(nameof(IsActive));
        }

        public void SetStartTime(SwimmingStyles style, TimeSpan time)
        {
            PersonStart start = GetStartByStyle(style);
            if (start == null) { return; }
            start.Time = time;
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Properties derived from the starts

        [FileServiceIgnore]
        public PersonStart HighestScoreStart => Starts?.Values?.Where(s => s != null && s.IsActive)?.OrderByDescending(s => s.Score).FirstOrDefault();

        [FileServiceIgnore]
        public double HighestScore => HighestScoreStart?.Score ?? 0;

        [FileServiceIgnore]
        public SwimmingStyles HighestScoreStyle => HighestScoreStart?.Style ?? SwimmingStyles.Unknown;

        [FileServiceIgnore]
        public Competition HighestScoreCompetition => HighestScoreStart?.CompetitionObj;

        [FileServiceIgnore]
        public bool IsActive
        {
            get => Starts?.Values?.Where(s => s != null)?.Any(s => s.IsActive) ?? false;
            set
            {
                if (Starts == null) { return; }
                Starts?.Values?.Where(s => s != null)?.ToList()?.ForEach(s => s.IsActive = value);
                OnPropertyChanged(nameof(IsActive));
            }
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Other properties
 
        private bool _hasDuplicates = false;
        [FileServiceIgnore]
        public bool HasDuplicates
        {
            get => _hasDuplicates;
            set => SetProperty(ref _hasDuplicates, value);
        }
 
        private int _resultListPlace = 0;
        [FileServiceIgnore]
        public int ResultListPlace
        {
            get => _resultListPlace;
            set => SetProperty(ref _resultListPlace, value);
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region PersonStart PropertyChanged event handler
 
        private void PersonStart_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            OnPropertyChanged(nameof(Starts));
            OnPropertyChanged(nameof(HighestScore));
            OnPropertyChanged(nameof(HighestScoreStyle));
            OnPropertyChanged(nameof(HighestScoreCompetition));
            switch(e.PropertyName)
            {
                case nameof(PersonStart.IsActive):
                    OnPropertyChanged(nameof(IsActive));
                    break;
                default: break;
            }
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Style Properties for faster access and file saving

        [FileServiceOrder]
        public bool Breaststroke
        {
            get => GetStartByStyle(SwimmingStyles.Breaststroke) != null;
            set { SetStartAvailable(SwimmingStyles.Breaststroke, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public bool Freestyle
        {
            get => GetStartByStyle(SwimmingStyles.Freestyle) != null;
            set { SetStartAvailable(SwimmingStyles.Freestyle, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public bool Backstroke
        {
            get => GetStartByStyle(SwimmingStyles.Backstroke) != null;
            set { SetStartAvailable(SwimmingStyles.Backstroke, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public bool Butterfly
        {
            get => GetStartByStyle(SwimmingStyles.Butterfly) != null;
            set { SetStartAvailable(SwimmingStyles.Butterfly, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public bool Medley
        {
            get => GetStartByStyle(SwimmingStyles.Medley) != null;
            set { SetStartAvailable(SwimmingStyles.Medley, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public bool WaterFlea
        {
            get => GetStartByStyle(SwimmingStyles.WaterFlea) != null;
            set { SetStartAvailable(SwimmingStyles.WaterFlea, value); OnPropertyChanged(); }
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Time Properties for faster access and file saving

        [FileServiceOrder]
        public TimeSpan BreaststrokeTime
        {
            get => GetStartByStyle(SwimmingStyles.Breaststroke)?.Time ?? new TimeSpan();
            set { SetStartTime(SwimmingStyles.Breaststroke, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public TimeSpan FreestyleTime
        {
            get => GetStartByStyle(SwimmingStyles.Freestyle)?.Time ?? new TimeSpan();
            set { SetStartTime(SwimmingStyles.Freestyle, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public TimeSpan BackstrokeTime
        {
            get => GetStartByStyle(SwimmingStyles.Backstroke)?.Time ?? new TimeSpan();
            set { SetStartTime(SwimmingStyles.Backstroke, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public TimeSpan ButterflyTime
        {
            get => GetStartByStyle(SwimmingStyles.Butterfly)?.Time ?? new TimeSpan();
            set { SetStartTime(SwimmingStyles.Butterfly, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public TimeSpan MedleyTime
        {
            get => GetStartByStyle(SwimmingStyles.Medley)?.Time ?? new TimeSpan();
            set { SetStartTime(SwimmingStyles.Medley, value); OnPropertyChanged(); }
        }

        [FileServiceOrder]
        public TimeSpan WaterFleaTime
        {
            get => GetStartByStyle(SwimmingStyles.WaterFlea)?.Time ?? new TimeSpan();
            set { SetStartTime(SwimmingStyles.WaterFlea, value); OnPropertyChanged(); }
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Friendship properties
 
        private ObservableCollection<int> _friendGroupIDs = new ObservableCollection<int>();
        [FileServiceOrder]
        public ObservableCollection<int> FriendGroupIDs
        {
            get => _friendGroupIDs;
            set
            {
                if (_friendGroupIDs != null) { _friendGroupIDs.CollectionChanged -= _friendGroupIDs_CollectionChanged; }
                if (SetProperty(ref _friendGroupIDs, value))
                {
                    if (_friendGroupIDs != null)
                    {
                        _friendGroupIDs.Sort((a, b) => a.CompareTo(b));
                        _friendGroupIDs.CollectionChanged += _friendGroupIDs_CollectionChanged;
                    }
                }
            }
        }
 
        private void _friendGroupIDs_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            OnPropertyChanged(nameof(FriendGroupIDs));
        }
 
        private List<Person> _friends = new List<Person>();
        [FileServiceIgnore]
        public List<Person> Friends
        {
            get => _friends;
            set => SetProperty(ref _friends, value);
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region SetPropertyFromString helper

        public const string START_INACTIVE_MARKER_STRING = "i";

        public static void SetPropertyFromString(Person dataObj, string propertyName, string value)
        {
            if(string.IsNullOrEmpty(value)) return;
 
            switch (propertyName)
            {
                case nameof(FirstName): dataObj.FirstName = value; break;
                case nameof(Name): dataObj.Name = value; break;
                case nameof(Gender): if (EnumCoreLocalizedStringHelper.TryParse(value, out Genders parsedGender)) { dataObj.Gender = parsedGender; } break;
                case nameof(BirthYear): dataObj.BirthYear = UInt16.Parse(value); break;
                case nameof(Breaststroke):
                    dataObj.Breaststroke = !string.IsNullOrEmpty(value);
                    if (dataObj.Starts[SwimmingStyles.Breaststroke] != null) { dataObj.Starts[SwimmingStyles.Breaststroke].IsActive = !value.Equals(START_INACTIVE_MARKER_STRING, StringComparison.OrdinalIgnoreCase); }
                    break;
                case nameof(Freestyle): 
                    dataObj.Freestyle = !string.IsNullOrEmpty(value);
                    if (dataObj.Starts[SwimmingStyles.Freestyle] != null) { dataObj.Starts[SwimmingStyles.Freestyle].IsActive = !value.Equals(START_INACTIVE_MARKER_STRING, StringComparison.OrdinalIgnoreCase); }
                    break;
                case nameof(Backstroke): 
                    dataObj.Backstroke = !string.IsNullOrEmpty(value);
                    if (dataObj.Starts[SwimmingStyles.Backstroke] != null) { dataObj.Starts[SwimmingStyles.Backstroke].IsActive = !value.Equals(START_INACTIVE_MARKER_STRING, StringComparison.OrdinalIgnoreCase); }
                    break;
                case nameof(Butterfly): 
                    dataObj.Butterfly = !string.IsNullOrEmpty(value);
                    if (dataObj.Starts[SwimmingStyles.Butterfly] != null) { dataObj.Starts[SwimmingStyles.Butterfly].IsActive = !value.Equals(START_INACTIVE_MARKER_STRING, StringComparison.OrdinalIgnoreCase); }
                    break;
                case nameof(Medley):
                    dataObj.Medley = !string.IsNullOrEmpty(value);
                    if (dataObj.Starts[SwimmingStyles.Medley] != null) { dataObj.Starts[SwimmingStyles.Medley].IsActive = !value.Equals(START_INACTIVE_MARKER_STRING, StringComparison.OrdinalIgnoreCase); }
                    break;
                case nameof(WaterFlea): 
                    dataObj.WaterFlea = !string.IsNullOrEmpty(value);
                    if (dataObj.Starts[SwimmingStyles.WaterFlea] != null) { dataObj.Starts[SwimmingStyles.WaterFlea].IsActive = !value.Equals(START_INACTIVE_MARKER_STRING, StringComparison.OrdinalIgnoreCase); }
                    break;
                case nameof(BreaststrokeTime): dataObj.BreaststrokeTime = TimeSpan.Parse(value); break;
                case nameof(FreestyleTime): dataObj.FreestyleTime = TimeSpan.Parse(value); break;
                case nameof(BackstrokeTime): dataObj.BackstrokeTime = TimeSpan.Parse(value); break;
                case nameof(ButterflyTime): dataObj.ButterflyTime = TimeSpan.Parse(value); break;
                case nameof(MedleyTime): dataObj.MedleyTime = TimeSpan.Parse(value); break;
                case nameof(WaterFleaTime): dataObj.WaterFleaTime = TimeSpan.Parse(value); break;
                case nameof(FriendGroupIDs): dataObj.FriendGroupIDs = new ObservableCollection<int>(value.Split(',').Select(s => int.Parse(s))); dataObj.FriendGroupIDs.Sort((a, b) => a.CompareTo(b)); break;
                default: break;
            }
        }
 
        #endregion
 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Equality, HashCode, ToString, Clone

        public override bool Equals(object obj)
            => obj is Person p && (p.Name.ToUpper(), p.FirstName.ToUpper(), p.Gender, p.BirthYear).Equals((Name.ToUpper(), FirstName.ToUpper(), Gender, BirthYear)) && p.FriendGroupIDs.SequenceEqual(FriendGroupIDs) && CompareDictionaries(Starts, p.Starts);
        
        public bool Equals(Person other)
            => Equals((object)other);

        public override int GetHashCode()
            => base.GetHashCode();
            //=> (Name.ToUpper(), FirstName.ToUpper(), Gender, BirthYear, FriendGroupIDs, Starts).GetHashCode();

        public override string ToString()
            => Name + ", " + FirstName + " (" + BirthYear.ToString() + ")";

        public object Clone()
            => new Person(this);

        private bool CompareDictionaries<TKey, TValue>(Dictionary<TKey, TValue> dict1, Dictionary<TKey, TValue> dict2)
        {
            if (dict1 == dict2) return true;
            if ((dict1 == null) || (dict2 == null)) return false;
            if (dict1.Count != dict2.Count) return false;
 
            EqualityComparer<TValue> valueComparer = EqualityComparer<TValue>.Default;
 
            foreach (KeyValuePair<TKey, TValue> kvp in dict1)
            {
                TValue value2;
                if (!dict2.TryGetValue(kvp.Key, out value2)) return false;
                if (!valueComparer.Equals(kvp.Value, value2)) return false;
            }
            return true;
        }
 
        #endregion
    }
}