#ifndef BILLYSHEET_CHARACTERISTIC_HPP
#define BILLYSHEET_CHARACTERISTIC_HPP

#include <cstdint>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

namespace character {
    class BillyObjects;
}

namespace character::characteristic {
    enum class characType : std::uint8_t {
        Adresse = 0,
        Endurance = 1,
        Chance = 2,
        Habilete = 3
    };

    class Characteristic {
    protected:
        friend character::BillyObjects;
        using defaultValue = std::numeric_limits<std::int32_t>;
        mutable std::int32_t total{ defaultValue::max() };
        const std::uint32_t base{ 0 };
        std::uint32_t carac{ 0 };
        std::uint32_t materiel{ 0 };
        std::uint32_t additional{ 0 };

        static std::uint32_t get_base(const characType inType) noexcept {
            switch (inType) {
                case characType::Adresse:
                    return 1;
                case characType::Chance:
                    return 3;
                case characType::Endurance:
                case characType::Habilete:
                    return 2;
            }
        }

    public:
        const characType type{ characType::Adresse };

        Characteristic() noexcept = default;

        Characteristic(const characType inType,
                const std::uint32_t carac,
                const std::uint32_t materiel,
                const std::uint32_t additional) :
                base(get_base(inType)),
                carac(carac),
                materiel(materiel),
                additional(additional),
                type(inType) { (void) get_total(); }

        explicit Characteristic(const characType inType) : Characteristic(inType, 0, 0, 0) {}

        Characteristic(const Characteristic &charac) noexcept = default;

        Characteristic &operator=(const Characteristic &charac) noexcept {
            const_cast<std::uint32_t &>(base) = charac.base;
            const_cast<characType &>(type) = charac.type;
            carac = charac.carac;
            materiel = charac.materiel;
            additional = charac.additional;
            total = charac.get_total();
            return *this;
        }

        virtual ~Characteristic() noexcept = default;

        [[nodiscard]] std::uint32_t get_base() const { return base; }

        [[nodiscard]] std::uint32_t get_carac() const { return carac; }

        [[nodiscard]] std::uint32_t get_materiel() const { return materiel; }

        [[nodiscard]] std::uint32_t get_additional() const { return additional; }

        [[nodiscard]] std::size_t get_total() const noexcept {
            if (total == defaultValue::max()) {
                total = static_cast<std::int32_t>(base + carac + materiel + additional);
                if (total < 0) {
                    total = 0;
                }
            }
            return total;
        }

        friend void from_json(const json &j, Characteristic &charac) {
            const_cast<std::uint32_t &>(charac.base) = j.at("base").get<std::uint32_t>();
            const_cast<characType &>(charac.type) = static_cast<characType>(j.at("type").get<std::uint8_t>());
            charac.carac = j.at("carac").get<std::uint32_t>();
            charac.materiel = j.at("materiel").get<std::uint32_t>();
            charac.additional = j.at("additional").get<std::uint32_t>();
            charac.total = j.at("total").get<std::int32_t>();
        }
    };

    static void to_json(json &j, const Characteristic &charac) {
        j["base"] = charac.get_base();
        j["type"] = charac.type;
        j["carac"] = charac.get_carac();
        j["materiel"] = charac.get_materiel();
        j["additional"] = charac.get_additional();
        j["total"] = charac.get_total();
    }
}


#endif //BILLYSHEET_CHARACTERISTIC_HPP