mastermind/Sources/CoreLibrary/Manageurs/Manageur.cs

using CoreLibrary.Persistance;
using CoreLibrary.Joueurs;
using CoreLibrary.Regles;
using CoreLibrary.Statistiques;
using System.Text.RegularExpressions;

namespace CoreLibrary.Manageurs
{
    /// <summary>
    /// Classe représentant un manager.
    /// </summary>
    public class Manageur
    {
        /// <summary>
        /// Attribut privé pour la persistance.
        /// </summary>
        private readonly IPersistance persistance;

        /// <summary>
        /// Liste des joueurs enregistrés.
        /// </summary>
        private readonly List<Joueur> joueurs;

        /// <summary>
        /// Liste des parties enregistrées.
        /// </summary>
        private readonly List<Partie> parties;

        /// <summary>
        /// Obtient la liste des joueurs enregistrés.
        /// </summary>
        public IReadOnlyList<Joueur> Joueurs => joueurs;

        /// <summary>
        /// Obtient la liste des parties enregistrées terminés.
        /// </summary>
        public IReadOnlyList<Partie> Parties => parties;

        /// <summary>
        /// Obtient la liste des parties non terminées.
        /// </summary>
        public IReadOnlyList<Partie> PartiesNonTerminees => parties.Where(partie => !partie.Termine).Reverse().ToList();

        /// <summary>
        /// Constructeur de manager avec la persistance spécifiée.
        /// </summary>
        /// <param name="persistance">Persistance permettant le chargement des joueurs et parties.</param>
        public Manageur(IPersistance persistance)
        {
            this.persistance = persistance;

            joueurs = persistance.Charger<Joueur>().ToList();
            parties = persistance.Charger<Partie>().ToList();
        }

        /// <summary>
        /// Sauvegarde les joueurs et les parties.
        /// </summary>
        private void Sauvegarder()
        {
            persistance.Enregistrer(joueurs.ToArray());
            persistance.Enregistrer(parties.ToArray());
        }

        /// <summary>
        /// Charge une partie avec la partie à charger spécifiée.
        /// </summary>
        /// <param name="partie">La partie que l'on veut charger.</param>
        /// <returns>Renvoie la partie.</returns>
        public Partie ChargerPartie(Partie partie)
        {
            parties.Remove(partie);

            Partie nouvellePartie = new Partie(partie);
            parties.Add(nouvellePartie);

            EcouterPartie(nouvellePartie);

            return nouvellePartie;
        }

        /// <summary>
        /// Créer une nouvelle partie avec les règles spécifiée.
        /// </summary>
        /// <param name="regles">Regle permettant la création de la partie.</param>
        /// <returns>Renvoie la nouvelle partie créée.</returns>
        public Partie NouvellePartie(IRegles regles)
        {
            Partie partie = new Partie(regles);
            parties.Add(partie);

            EcouterPartie(partie);

            return partie;
        }

        /// <summary>
        /// Suivre le cour d'une partie avec la partie spécifiée.
        /// Sauvegarde quand certains événements sont appelés dans la partie.
        /// </summary>
        /// <param name="partie">La partie à écouter.</param>
        private void EcouterPartie(Partie partie)
        {
            partie.PartieDemanderJoueur += (sender, e) => Sauvegarder();
            partie.PartieDebutPartie += (sender, e) => Sauvegarder();
            partie.PartieNouveauTour += (sender, e) => Sauvegarder();

            partie.PartiePasserLaMain += (sender, e) =>
            {
                DemanderJoueur(e.Joueur).IncrementerStatistique(partie.Regles, Statistique.CoupJoue);
                Sauvegarder();
            };

            partie.PartiePartieTerminee += (sender, e) =>
            {
                if (e.Gagnants.Count == 1)
                {
                    DemanderJoueur(e.Gagnants[0]).IncrementerStatistique(partie.Regles, Statistique.PartieGagnee);
                }
                else
                {
                    foreach (string gagnant in e.Gagnants)
                        DemanderJoueur(gagnant).IncrementerStatistique(partie.Regles, Statistique.PartieEgalite);
                }

                foreach (string perdant in e.Perdants)
                {
                    DemanderJoueur(perdant).IncrementerStatistique(partie.Regles, Statistique.PartiePerdue);
                }

                Sauvegarder();
            };
        }

        /// <summary>
        /// Demande un joueur avec son nom spécifié.
        /// </summary>
        /// <param name="nom">Nom du joueur que l'on souhaite trouver.</param>
        /// <returns>Renvoie le joueur s'il a été trouvé. Sinon, crée un joueur avec le nom passé en paramètre.</returns>
        public Joueur DemanderJoueur(string nom)
        {
            foreach (Joueur joueur in joueurs)
            {
                if (joueur.Nom == nom)
                {
                    return joueur;
                }
            }

            Joueur nouveauJoueur = new Joueur(nom);

            joueurs.Add(nouveauJoueur);

            return nouveauJoueur;
        }
    }
}