partie.h

#ifndef PARTIE_H
#define PARTIE_H

#include "mainwindow.h"
#include "types.h"
#include "joueur.h"
#include "action.h"
#include "ia_min_max.h"
#include <string>
#include <vector>

/**
 * @brief Classe Partie.
 * 
 * Gère la logique principale d'une partie, incluant les joueurs, le plateau, les actions,
 * et les règles de jeu comme le placement et le déplacement des insectes.
 */
class Partie
{
public:

    /**
     * @brief Constructeur de la classe Partie.
     *
     * Initialise une nouvelle partie avec deux joueurs et un plateau.
     *
     * @param joueur1_pseudo Nom du joueur 1.
     * @param joueur2_pseudo Nom du joueur 2.
     * @param nb_retours Nombre de retours en arrière autorisés pour chaque joueur (par défaut 0).
     * @param insectes les extensions + insectes de base
     * @param actions les actions déjà effectuées pour charger une partie
     */
    Partie(std::string joueur1_pseudo, std::string joueur2_pseudo, unsigned int nb_retours, std::vector<std::string> insectes, bool presence_ia=false);
    Partie(std::string joueur1_pseudo, std::string joueur2_pseudo, unsigned int nb_retours, std::vector<std::string> insectes, std::vector<Action> actions, bool presence_ia=false);

    /**
     * @brief Destructeur de la classe Partie.
     *
     * Libère les ressources allouées, notamment le plateau.
     */
    ~Partie();

    friend class GraphicsPartie;
    friend class NewGame;

    /**
     * @brief Retourne un pointeur vers le plateau de la partie.
     * 
     * @return Plateau* Pointeur vers le plateau.
     */
    class Plateau* get_plateau() const { return plateau; }
    const std::vector<Action>& get_actions() const { return actions; }

    /**
     * @brief Joue un tour à partir d'une commande en mode CLI.
     * 
     * @param cmd Commande utilisateur sous forme de chaîne.
     * @return std::string Résultat de la commande, incluant les erreurs ou l'état du plateau.
     */
    std::string jouer_tour_cli(std::string cmd);

    /**
     * @brief Joue un tour avec une action donnée.
     * 
     * Gère le placement ou le déplacement d'insectes.
     * 
     * @param action Action à effectuer (placement ou déplacement).
     * @return bool True si l'action est réussie, False sinon.
     */
    bool jouer_tour(Action action);

    /**
     * @brief Annule la dernière action effectuée par un joueur.
     * 
     * @param joueur Joueur demandant l'annulation.
     * @return bool True si l'annulation a été effectuée, False sinon.
     */
    bool annuler_action(Joueur *joueur, bool bypass=false);

    /**
     * @brief Retourne une référence au joueur 1.
     * 
     * @return Joueur& Référence au joueur 1.
     */
    Joueur& get_joueur1() { return joueur1; }

    /**
     * @brief Retourne une référence au joueur 2.
     * 
     * @return Joueur& Référence au joueur 2.
     */
    Joueur& get_joueur2() { return joueur2; }

    /**
     * @brief Retourne le nombre de tours joués.
     * 
     * @return unsigned int Nombre de tours.
     */
    unsigned int get_nb_tours() { return nb_tours; }

    /**
     * @brief Retourne le joueur dont c'est le tour.
     * 
     * @return Joueur* Pointeur vers le joueur actif.
     */
    Joueur* get_tour_joueur() const { return tour; }

    /**
     * @brief Retourne le joueur gagnant si la partie est terminée.
     * 
     * @return Joueur* Pointeur vers le joueur gagnant, ou nullptr si aucun gagnant.
     */
    Joueur* get_gagnant() const;

private:
    class Plateau* plateau; ///< Plateau de la partie.


    Joueur joueur1; ///< Joueur 1.
    Joueur joueur2; ///< Joueur 2.
    Joueur* tour = &joueur1; ///< Pointeur vers le joueur dont c'est le tour.

    unsigned int nb_tours = 0; ///< Nombre de tours joués.
    unsigned int nb_retours_possibles = 0; ///< Nombre de retours en arrière autorisés.

    /**
     * @brief Ajoute un insecte sur le plateau.
     * 
     * @param joueur Joueur propriétaire de l'insecte.
     * @param c Case où l'insecte doit être placé.
     * @param type Type de l'insecte.
     * @param bypass Ignorer certaines vérifications (par défaut false).
     * @return bool True si l'insecte a été ajouté avec succès, False sinon.
     */
    bool ajouter_insecte(Joueur* joueur, class Case* c, Type::Type type, bool bypass = false);

    /**
     * @brief Déplace un insecte d'une case à une autre.
     * 
     * @param joueur Joueur effectuant le déplacement.
     * @param depart Case de départ.
     * @param arrivee Case d'arrivée.
     * @param bypass Ignorer certaines vérifications (par défaut false).
     * @return bool True si le déplacement est réussi, False sinon.
     */
    bool deplacer_insecte(Joueur* joueur, Case* depart, Case* arrivee, bool bypass = false);

    /**
     * @brief Lit le prochain token (mot) dans une commande.
     * 
     * @param cmd Commande complète.
     * @param token Prochain token extrait.
     */
    void lire_prochain_token(std::string& cmd, std::string& token);

    /**
     * @brief Retourne une représentation textuelle du plateau.
     * 
     * @return std::string Représentation textuelle.
     */
    std::string get_display_plateau() const;

    /**
     * @brief Vérifie si l'abeille d'un joueur est placée.
     * 
     * @param joueur Joueur à vérifier.
     * @return bool True si l'abeille est placée, False sinon.
     */
    bool abeille_place(Joueur* joueur);

    std::vector<Action> actions; ///< Historique des actions effectuées.

    /**
     * @brief Configure une partie de test.
     * 
     * Ajoute des insectes pour tester les fonctionnalités.
     */
    void setup_test();

    bool presence_ia;
    class IA* ia=nullptr;

    bool partie_terminee = false; ///< Indique si la partie est terminée.

    /**
     * @brief Vérifie si un joueur a gagné.
     * 
     * @param joueur Joueur à vérifier.
     * @return bool True si le joueur a gagné, False sinon.
     */

    bool verifier_victoire_joueur(const Joueur* joueur) const;

    /**
     * @brief Vérifie si la partie est gagnée.
     * 
     * @return bool True 
     */
    bool verifier_victoire();

    class GraphicsPartie* graphics;
};

#endif // PARTIE_H