#pragma once
#include "item.h"
#include "rules.h"
#include "json.hpp"
#include <set>

namespace creature {
    class Creature;
}

namespace entry {
    class Weapon;
    class Damage;

    std::string genText(const Weapon& w, const creature::Creature& c);
    std::vector<rules::Ability> getAbilityOptions(const Weapon& w);
    std::vector<Damage> rollDmg(const Weapon& w, bool versatile=false);
    std::string formatDmg(const Weapon& w, const creature::Creature& c);

    class Damage : public Jsonable {
        public:
            Damage(const nlohmann::json& data) : count(data["dmg_die_count"]), sides(data["dmg_die_sides"]), type(data["dmg_type"]), isOr(data["is_or"]) {}
            const int count;
            const int sides;
            const std::string type;
            const bool isOr;
            int rolled = 0;

            nlohmann::json toJson(void) const {
                return nlohmann::json({
                        {"dmg_die_count", count},
                        {"dmg_die_sides", sides},
                        {"dmg_type", type},
                        {"is_or", isOr}
                        });
            }
    };

    class Weapon : public Item, public Substantial {
        public:
            Weapon(const nlohmann::json& data, const nlohmann::json& base) : Item(base), damage(utils::json2vec<Damage>(data["damage"])), properties(data["properties"]), weaponType(data["weapon_type"]), range(data["range"][0], data["range"][1]), reach(data["reach"]), cost(data["cost"]), weight(data["weight"]) {}

            std::vector<Damage> getDamage(void) const {return damage;}
            std::set<std::string> getProperties(void) const {return properties;}
            std::string getWeaponType(void) const {return weaponType;}
            std::pair<int, int> getRange(void) const {return range;}
            int getReach(void) const {return reach;}
            int getCost(void) const {return cost;}
            double getWeight(void) const {return weight;}

            virtual std::string getText() const override;
            virtual std::string getText(const creature::Creature& c) const override {return genText(*this, c);}

            virtual nlohmann::json toJson(void) const {
                auto data = Item::toJson();
                data["damage"] = damage;
                data["properties"] = properties;
                data["weapon_type"] = weaponType;
                data["range"] = range;
                data["reach"] = reach;
                data["cost"] = cost;
                data["weight"] = weight;
                return data;
            }

        private:
            const std::vector<Damage> damage;
            const std::set<std::string> properties;
            const std::string weaponType;
            const std::pair<const int, const int> range;
            const int reach;
            const int cost;
            const double weight;
    };
}