#include <iostream>
#include <map>
#include <lua.hpp>

class Ability {
    std::string m_description;
    public :
        explicit Ability(const std::string& de) : m_description(de) {}
        const std::string& description() const {return m_description;}
};

class Classe {
    std::string m_name;
    unsigned int m_hitdice;
    std::map<std::string, Ability> m_abilities;

    public :
        bool loadFromFile(const std::string& str)
        {
            lua_State* L = luaL_newstate();
            bool result = luaL_dofile(L, str.c_str());
            if(result) std::cout << "Error : " << lua_tostring(L, -1) << std::endl;
            else
            {
                lua_getglobal(L, "class");
                int index = lua_gettop(L);

                lua_getfield(L, index, "name");
                if(lua_isstring(L, -1)) m_name = lua_tostring(L, -1);
                else m_name = "Pas de classe";

                lua_getfield(L, index, "hitdice");
                if(lua_isnumber(L, -1)) m_hitdice = lua_tonumber(L, -1);
                else m_hitdice = 8;

                lua_getfield(L, index, "abilities");
                m_abilities.clear();
                if(lua_istable(L, -1))
                {
                    int abilitiesIndex = lua_gettop(L);
                    lua_pushnil(L);
                    while(lua_next(L,abilitiesIndex))
                    {
                        if(lua_isstring(L, -2))
                        {
                            std::string desc = "Aucune information sur cette capacité";
                            if(lua_isstring(L, -1)) desc = lua_tostring(L, -1);
                            m_abilities.insert(std::make_pair(lua_tostring(L, -2), Ability(desc)));
                        }
                        lua_pop(L, 1);
                    }
                }
            }
            lua_close(L);
            return !result;
        }
        const std::string& name() const {return m_name;}
        unsigned int hitDice() const {return m_hitdice;}
        const std::map<std::string, Ability>& abilities() const {return m_abilities;}
};

class Personnage {
    std::string m_name;
    Classe m_class;
    public :
        Personnage(const std::string& name, const Classe& classe) : m_name(name), m_class(classe) {}
        const std::string& name() const {return m_name;}
        const std::string& className() const {return m_class.name();}
        unsigned int hitDice() const {return m_class.hitDice();}
        const std::map<std::string, Ability>& abilities() const {return m_class.abilities();}
};

void display(const Personnage& perso)
{
    std::cout << "Nom : " << perso.name() << std::endl;
    std::cout << "Classe : " << perso.className() << std::endl;
    std::cout << "Dés de vie : " << perso.hitDice() << std::endl;
    std::cout << "Capacités : " << std::endl;
    if(perso.abilities().empty()) std::cout << "\tAucune" << std::endl;
    else
        for(std::map<std::string, Ability>::const_iterator i = perso.abilities().begin();
            i != perso.abilities().end();
            ++i) std::cout << "\t" << i->first << " : " << i->second.description() << std::endl;
    std::cout << std::endl;
}

int main()
{
    Classe maClasse;
    maClasse.loadFromFile("guerrier");
    Personnage guerrier("Un guerrier lambda", maClasse);
    display(guerrier);
    maClasse.loadFromFile("magicien");
    Personnage magicien("Un magicien pas très courageux", maClasse);
    display(magicien);
    maClasse.loadFromFile("paysan");
    Personnage paysan("Un paysan robuste", maClasse);
    display(paysan);
}

class = { ["name"] = "Guerrier",
	  ["hitdice"] = 10,
	  ["abilities"] = {["Taper comme un sourd"] = "Frappe comme un bourrin.", 
	  		   ["Mourir en heros"]      = "Un dernier baroud d'honneur."
	  		  }
	}

class = { ["name"] = "Magicien",
	  ["hitdice"] = 4,
	  ["abilities"] = {["Lancer un super sort"] = "De la magie à gogo !", 
	  		   ["Mourir en lâche"]      = "Périr bêtement en voulant prendre ses jambes à son cou.",
	  		   ["Se planquer"]	    = "« Oh, je me demande ce qu'il y a derière ce rocher ! »"
	  		  }
	}

class = { ["name"] = "Paysan",
	  ["hitdice"] = 6,
	  ["abilities"] = {}
	}

Nom : Un guerrier lambda
Classe : Guerrier
Dés de vie : 10
Capacités : 
        Mourir en heros : Un dernier baroud d'honneur.
        Taper comme un sourd : Frappe comme un bourrin.

Nom : Un magicien pas très courageux
Classe : Magicien
Dés de vie : 4
Capacités : 
        Lancer un super sort : De la magie à gogo !
        Mourir en lâche : Périr bêtement en voulant prendre ses jambes à son cou.
        Se planquer : « Oh, je me demande ce qu'il y a derière ce rocher ! »

Nom : Un paysan robuste
Classe : Paysan
Dés de vie : 6
Capacités : 
        Aucune