mastermind/Sources/MauiSpark/Pages/ClassementPage.xaml.cs

using CoreLibrary.Joueurs;
using CoreLibrary.Statistiques;
using CoreLibrary.Regles;
using System.ComponentModel;
using System.Runtime.CompilerServices;

namespace MauiSpark.Pages
{
    /// <summary>
    /// Représente un joueur dans le classement.
    /// </summary>
    partial class Enfant
    {
        private readonly Classement classement;

        /// <summary>
        /// Obtient ou définit le joueur associé à cet enfant.
        /// </summary>
        public Joueur Joueur { get; set; }

        /// <summary>
        /// Obtient la place du joueur dans le classement.
        /// </summary>
        public int Place => classement.Enfants.ToList().IndexOf(this) + 1;

        /// <summary>
        /// Obtient les statistiques du joueur dans le classement.
        /// </summary>
        public IEnumerable<int> Statistiques => Enum.GetValues<Statistique>()
            .Select(statistique => Joueur.Statistique(classement.Regles, statistique));

        /// <summary>
        /// Obtient une liste des objets de cet enfant dans le classement (Son nom et sa place).
        /// </summary>
        public IEnumerable<string> Objets => new List<string>([$"{Place}", Joueur.Nom])
            .Concat(Statistiques.Select(statistique => $"{statistique}"));

        /// <summary>
        /// Initialise une nouvelle instance de la classe <see cref="Enfant"/>.
        /// </summary>
        /// <param name="joueur">Le joueur associé à cet enfant.</param>
        /// <param name="classement">Le classement auquel cet enfant appartient.</param>
        public Enfant(Joueur joueur, Classement classement)
        {
            this.classement = classement;
            Joueur = joueur;
        }

        /// <summary>
        /// Détermine si l'objet spécifié est égal à l'objet actuel.
        /// </summary>
        public override bool Equals(object? obj)
        {
            if (obj == null || obj is not Enfant)
                return false;

            return Joueur == ((Enfant)obj).Joueur;
        }

        /// <summary>
        /// Retourne le code de hachage de cet objet.
        /// </summary>
        public override int GetHashCode() => Joueur.GetHashCode();
    }

    /// <summary>
    /// Représente le classement des joueurs.
    /// </summary>
    partial class Classement : INotifyPropertyChanged
    {

        /// <summary>
        /// Se produit lorsque la valeur d'une propriété de l'objet change.
        /// </summary>
        public event PropertyChangedEventHandler? PropertyChanged;

        /// <summary>
        /// Déclenche l'événement <see cref="PropertyChanged"/> pour notifier les modifications de propriété.
        /// </summary>
        /// <param name="propriete">Le nom de la propriété qui a changé.</param>
        public void QuandProprieteChangee([CallerMemberName] string? propriete = null) => 
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propriete));

        private int indiceRegles = 0;

        /// <summary>
        /// Obtient les règles actuelles du classement.
        /// </summary>
        public IRegles Regles => ClassementPage.ToutesRegles.ElementAt(indiceRegles);

        private Statistique statistique = Enum.GetValues<Statistique>().First();

        /// <summary>
        /// Obtient ou définit la statistique utilisée pour classer les joueurs.
        /// </summary>
        public Statistique Statistique
        {
            get => statistique;
            set
            {
                statistique = value;
                QuandProprieteChangee(nameof(Enfants));
            }
        }

        private bool inverser = true;

        /// <summary>
        /// Obtient ou définit une valeur indiquant si le classement est inversé.
        /// </summary>
        public bool Inverser { 
            get => inverser; 
            set 
            {
                inverser = value;
                QuandProprieteChangee(nameof(Enfants));
            } 
        }

        /// <summary>
        /// Obtient les titres des colonnes du classement.
        /// </summary>
        public IEnumerable<string> Titres => new List<string>(["Place", "Nom"]).Concat(
            Enum.GetValues<Statistique>().Select(
                statistique => string.Concat((Enum.GetName(typeof(Statistique), statistique) ?? "").Select(
                    (lettre, indice) => indice > 0 && char.IsUpper(lettre) ? $" {lettre}" : $"{lettre}")
                )
            )
        );

        /// <summary>
        /// Obtient la liste des enfants (joueurs) dans le classement, triée en fonction de la statistique et des règles actuelles.
        /// </summary>
        public IEnumerable<Enfant> Enfants => Inverser ?
            MauiProgram.Manageur.Joueurs
                .OrderBy(joueur => joueur.Statistique(Regles, Statistique))
                .Select(joueur => new Enfant(joueur, this)).Reverse() :
            MauiProgram.Manageur.Joueurs
                .OrderBy(joueur => joueur.Statistique(Regles, Statistique))
                .Select(joueur => new Enfant(joueur, this));

        /// <summary>
        /// Incrémente l'indice des règles du classement selon une valeur spécifiée.
        /// </summary>
        /// <param name="valeur">La valeur à ajouter à l'indice des règles.</param>
        public void IncrementerRegles(int valeur)
        {
            if ((indiceRegles += valeur) < 0) 
                indiceRegles = ClassementPage.ToutesRegles.Count() - 1;
            else if (indiceRegles >= ClassementPage.ToutesRegles.Count()) 
                indiceRegles = 0;

            QuandProprieteChangee(nameof(Regles));
            QuandProprieteChangee(nameof(Enfants));
        }
    }

    /// <summary>
    /// Partie de la logique de l'interface utilisateur de la page de classement.
    /// Gère les calculs de classement, l'affichage des statistiques et le changement des règles de jeu.
    /// </summary>
    public partial class ClassementPage : ContentPage
    {
        /// <summary>
        /// Obtient toutes les règles de jeu disponibles.
        /// </summary>
        public static IEnumerable<IRegles> ToutesRegles => typeof(IRegles).Assembly.GetTypes()
            .Where(type => typeof(IRegles).IsAssignableFrom(type) && type.IsClass)
            .Select(type => (Activator.CreateInstance(type) as IRegles)!)
            .OrderBy(regles => regles.Indice);

        /// <summary>
        /// Constructeur de la page de classement des joueurs.
        /// Initialise les paramètres de navigation et les composants de la page.
        /// </summary>
        public ClassementPage()
        {
            InitializeComponent();

            NavigationPage.SetHasNavigationBar(this, false);

            BindingContext = new Classement();
        }

        /// <summary>
        /// Méthode appelée lorsqu'un bouton de changement de règles est pressé.
        /// Augmente ou diminue l'indice des règles selon le bouton pressé.
        /// </summary>
        public void ChangerReglesPresse(object sender, EventArgs e)
        {
            ((Classement)BindingContext).IncrementerRegles(sender == DiminuerRegles ? -1 : 1);
        }

        /// <summary>
        /// Méthode appelée lorsqu'un bouton statistique est pressée.
        /// Modifie la statistique de classement ou inverse l'ordre du classement si la même statistique est déjà sélectionnée.
        /// </summary>
        public void StatistiquePressee(object sender, EventArgs e)
        {
            if (sender is not Label || !Enum.IsDefined(typeof(Statistique), ((Label)sender).Text.Replace(" ", "")))
                return;

            Statistique statistique = Enum.Parse<Statistique>(((Label)sender).Text.Replace(" ", ""));
            Classement classement = (Classement)BindingContext;

            if (classement.Statistique == statistique)
            {
                classement.Inverser = !classement.Inverser;
                return;
            }

            classement.Inverser = true;
            classement.Statistique = statistique;
        }
    }
}