/**
* \ file main.cpp
* \ author Nom de l'equipier 1 - Matricule
* \ brief Ce fichier contient un programme de calcul d'attaque pour le jeu Donjons et Dragons
*/

#include <algorithm> // Permet d'utiliser les fonctions min et max
#include <iostream> // Permet de faire les entrees/sorties
#include <random>  // Permet d'utiliser les fonctions de génération de nombres aléatoires


using namespace std;

//Module
int GenereDe(int face);
int CalculerPointVie(int, int, int, int);
int CalculerDommageArme(int, int);
int CalculerDommageReel(int, int);
int CalculerAttaque(int, int);

int main()
{


    //Joueur Stats
    int pointVieJoueur = 0,
        nbDeAttaqueJoueur = 0,
        faceAttaqueJoueur = 0,
        faceArmureJoueur = 0,
        pointVieInitJoueur = 0;
    //Ennemi Stats
    int pointVieEnnemi = 0,
        nbDeAttaqueEnnemi = 0,
        faceAttaqueEnnemi = 0,
        faceArmureEnnemi = 0,
        pointVieInitEnnemi = 0;



    // 1. Lecture des entrees
    // 1.1 Lecture des points de vie du joueur
    cout << "Entrez le nombre de point de vie du joueur : ";
    cin >> pointVieJoueur;

    // 1.2 Lecture du nombre de DE d'attaque du joueur
    cout << "Entrez le nombre de DE pour calculer l'attaque du joueur : ";
    cin >> nbDeAttaqueJoueur;

    // 1.3 Lecture du nombre de face du DE d'attaque du joueur
    cout << "Entrez le nombre de face des DES d'attaque du joueur : ";
    cin >> faceAttaqueJoueur;

    // 1.4 Lecture du nombre de face du DE d'armure du joueur
    cout << "Entrez le nombre de face du DE d'armure du joueur : ";
    cin >> faceArmureJoueur;

    // 1.5 Lecture des points de vie de l'ennemi
    cout << "Entrez le nombre de point de vie de l'ennemi : ";
    cin >> pointVieEnnemi;

    // 1.6 Lecture du nombre de DE d'attaque de l'ennemi
    cout << "Entrez le nombre de DE pour calculer l'attaque de l'ennemi : ";
    cin >> nbDeAttaqueEnnemi;

    // 1.7 Lecture du nombre de face du DE d'attaque de l'ennemi
    cout << "Entrez le nombre de face des DES d'attaque de l'ennemi : ";
    cin >> faceAttaqueEnnemi;

    // 1.8 Lecture du nombre de face du DE d'armure de l'ennemi
    cout << "Entrez le nombre de face du DE d'armure de l'ennemi : ";
    cin >> faceArmureEnnemi;

    // Completez le code du module principal ici



    //2. Calculer le nombre de points de vie restant du joueur(Module CalculerPointVie)
    pointVieJoueur = CalculerPointVie(pointVieInitJoueur, nbDeAttaqueEnnemi, faceAttaqueEnnemi,faceArmureJoueur);
    //3. Calculer le nombre de points de vie restant de l'adversaire
    pointVieEnnemi = CalculerPointVie(pointVieInitEnnemi, nbDeAttaqueJoueur, faceAttaqueJoueur, faceArmureEnnemi);

    // 4. Affichage des sorties
    // 4.1 Affichage des points de vie du joueur
    cout << "Point de vie du joueur apres l'attaque : " << pointVieJoueur << endl;

    // 4.2 Affichage des points de vie de l'ennemi
    cout << "Point de vie de l'ennemi apres l'attaque : " << pointVieEnnemi << endl;
    return 0;
}

// **************************************************************************
// Ce module calcule le nombre de point de vie d'un personnage après une attaque.
int CalculerPointVie(int pointVieInit, int nbDeAttck, int nbFaceDeAttck, int nbFaceDeArmure)
{
    //1. Calculer les dommages de l'arme (Modules CalculerDommageArme)
    int dommageArme = CalculerDommageArme(nbDeAttck,nbFaceDeAttck);
    //2. Calculer la résistance de l'armure (Module GenereDe)
    int armure = GenereDe(nbFaceDeArmure);
    //3. Calculer les dommages réels effectués (Module CalculDommageReel)
    int dommageReel = CalculerDommageReel(dommageArme,armure);
    //4. Calculer le résultat de l'attaque (Module CalculerAttaque)
    int pointsVieFinaux = CalculerAttaque(pointVieInit,dommageReel);
    //5. retourner le resultat d'attaque
    return pointsVieFinaux;
};
//
//Ce module calcule les dommages effectués par une arme donnée.
int CalculerDommageArme(int nbDeDommage, int nbFaceDesDommage)
{
    //1. Genere un lancer de dé (Module GenereDe)
    int valeurDe = GenereDe(nbFaceDesDommage);
    //2. Calculer le résultat des dégâts
    int dommageArme = nbDeDommage*valeurDe;
    //3. Retourner le résultat
    return dommageArme;
};

int CalculerResArmure(int nbDeArmure, int nbFaceDesArmure) {
    //1. Genere un lancer de dé (Module GenereDe)
    int valeurDe = GenereDe(nbDeArmure);
    //2. Calculer le résultat des armures
    int armure = nbDeArmure*valeurDe;
    //3. Retourner le résultat
    return armure;
}
//
//Ce module calcule les dommages réels effectués apr une arme donnée après absorption par une armure.
int CalculerDommageReel(int dommageArme, int valResArmure)
{
    //1. Calculer les dommages infligées
    int dommageInflige = dommageArme - valResArmure;
    //2. S'assurer ques les dommages ne sont pas négatif(module max)
    int dommageEffectue = max(0,dommageInflige);
    //3. Retourner le résultat
    return dommageEffectue;
};
//
// Ce module calcule le résultat d'une attaque contre un joueur
int CalculerAttaque(int pointVieInit, int dommageReelEffectue)
{
    int pointVieFinaux;
    int pointVieReel;
    //1. Calculer les points de vie finaux prévus
    pointVieFinaux = pointVieInit - dommageReelEffectue;
    //2. S'assurer que les points de vie ne sont pas négatif(module Max)
    pointVieReel = max(0,pointVieFinaux);
    //3. Retourner le résultat
    pointVieFinaux = pointVieReel;
    return pointVieFinaux;

};

// **************************************************************************



/**
* \ brief Genere un lancer de de d'un nombre de face donne.
* \ param [in] Nombre de face du de
* \ return Valeur du de
*/
int GenereDe(int face)
{
    // 0. Creation du generateur de nombre aleatoire, avec une racine a 0 (une seule fois)
    static mt19937 generateur(0);
    // 1. Creation d'une distribution uniforme pour l'intervalle specifiee
    uniform_int_distribution<> distribution(1, face);
    // 2. Generation d'un nombre aleatoire selon la distribution uniforme
    return distribution(generateur);
}