#pragma once
#include "json.hpp"
#include "jsonable.h"

namespace feature {
    class Feature;
}
namespace item {
    class Item;
}
class Armor;
class Weapon;

typedef nlohmann::json json;

namespace creature {
    class dmgType : public Jsonable {
        public:
            dmgType(const json& data) : type(data["type"]), qualifiers(data["qualifiers"]) {}
            std::string type;
            std::vector<std::string> qualifiers;
            json toJson(void) const {
                return json({
                        {"type", type},
                        {"qualifiers", qualifiers}
                        });
            }

    };

    class Creature : public Jsonable {
        public:
            Creature(json data);
            virtual ~Creature();

            // Getters
            std::string getCreatureName(void) const;
            std::string getGivenName(void) const;
            std::string getType(void) const;
            std::string getSize(void) const;
            std::string getAlignment(void) const;
            double getCR(void) const;
            std::string getLanguages(void) const;
            int getHP(void) const;
            int getHPMax(void) const;
            std::vector<std::string> getSenses(void) const;
            std::string getSpeed(void) const;
            int getScore(const std::string& ability) const;
            int getSkillBonus(const std::string& skill) const;
            int getAbilitySaveBonus(const std::string& ability) const;
            int getProficiency(void) const;
            std::map<std::string, int> getSkills(void) const;
            std::map<std::string, int> getSaves(void) const;
            std::vector<std::shared_ptr<feature::Feature>> getFeatures(void) const;
            std::vector<std::shared_ptr<item::Item>> getInventory(void) const;

            // Inline getters
            int getBonus(const std::string& ability) const {
                return (int) (getScore(ability) - 10) / 2;
            }

            // Setters (mutators)
            void setGivenName(std::string);
            void applyDamage(int amount, const std::string& type, const std::vector<std::string>& qualifiers);
            //void setScore(const std::string& ability, int score);
            void addInventoryItem(std::shared_ptr<item::Item> item);
            void removeInventoryItem(const std::string& itemName);

            virtual json toJson(void) const;

        private:
            // Mutable variables
            std::string givenName;
            int hpMax;
            int hp;
            std::vector<std::shared_ptr<item::Item>> inventory;
            
            //Immutable variables
            const std::string creatureName;
            const std::string size;
            const std::string type;
            const std::string alignment;
            const int hdCount;
            const int hdSides;
            const std::string speed;
            const std::map<std::string, int> stats;
            const std::map<std::string, int> skills;
            const std::vector<std::string> saves;
            const std::vector<std::string> senses;
            const std::string langs;
            const double cr;
            const int proficiency;
            const std::vector<dmgType> dmgImmunities;
            const std::vector<dmgType> dmgResistances;
            const std::vector<dmgType> dmgVulnerabilities;
            const std::vector<dmgType> condImmunities;
            std::vector<std::shared_ptr<feature::Feature>> features;

    };

    // Convenience function to get any instances of T (subclass of Item) in the inventory
    template<typename T> std::vector<std::shared_ptr<T>> getItems(const Creature& c) {
        std::vector<std::shared_ptr<T>> Ts;
        for(auto item : c.getInventory()) {
            std::shared_ptr<T> t = dynamic_pointer_cast<T>(item);
            if(t) {
                Ts.push_back(t);
            }
        }
        return Ts;
    }

    // Convenience function to calculate AC
    const int getAC(const Creature& c);
}