#pragma once
#include "jsonable.h"
#include <vector>
#include <map>
#include <string>
#include <iostream>
#include <algorithm>
#include <stdexcept>

namespace rules {

    class Ability : public Jsonable {
        public:
            std::string getFull() const {return abilities.at(getAbbrev());}
            std::string getAbbrev() const {return abbrev;}
            operator std::string() const {return getAbbrev();}
            virtual nlohmann::json toJson(void) const {
                return getAbbrev();
            }
            bool operator<(const Ability& rhs) const {return getAbbrev() < rhs.getAbbrev();}
            bool operator==(const Ability& rhs) const {return getAbbrev() == rhs.getAbbrev();}

            Ability() {}
            explicit Ability(const nlohmann::json& data) : abbrev(data) {}

            virtual ~Ability() {}

            static Ability Str() {return Ability("str");}
            static Ability Dex() {return Ability("dex");}
            static Ability Con() {return Ability("con");}
            static Ability Int() {return Ability("int");}
            static Ability Wis() {return Ability("wis");}
            static Ability Cha() {return Ability("cha");}

            static Ability string2ability(std::string s) {
                transform(s.begin(), s.end(), s.begin(), ::tolower);
                for(auto [abbrev, full] : abilities) {
                    transform(full.begin(), full.end(), full.begin(), ::tolower);
                    if(s == abbrev || s == full) {
                        return Ability(abbrev);
                    }
                }
                throw std::invalid_argument("Cannot find an ability for input: \"" + s + "\"");
            }

        private:
            const std::string abbrev;

            static const std::map<std::string, std::string> abilities;
    };

    class Skill : public Jsonable {
        public:
            std::string getName() const {return name;}
            Ability getAbility() const {return Ability(skill2ability.at(getName()));}
            operator std::string() const {return getName();}
            virtual nlohmann::json toJson(void) const {
                return getName();
            }
            bool operator<(const Skill& rhs) const {return getName() < rhs.getName();}
            bool operator==(const Skill& rhs) const {return getName() == rhs.getName();}

            virtual ~Skill() {}

            static Skill Athletics() {return Skill("Athletics");}
            static Skill Acrobatics() {return Skill("Acrobatics");}
            static Skill SleightOfHand() {return Skill("Sleight of Hand");}
            static Skill Stealth() {return Skill("Stealth");}
            static Skill Arcana() {return Skill("Arcana");}
            static Skill History() {return Skill("History");}
            static Skill Investigation() {return Skill("Investigation");}
            static Skill Nature() {return Skill("Nature");}
            static Skill Religion() {return Skill("Religion");}
            static Skill AnimalHandling() {return Skill("Animal Handling");}
            static Skill Insight() {return Skill("Insight");}
            static Skill Medicine() {return Skill("Medicine");}
            static Skill Perception() {return Skill("Perception");}
            static Skill Survival() {return Skill("Survival");}
            static Skill Deception() {return Skill("Deception");}
            static Skill Intimidation() {return Skill("Intimidation");}
            static Skill Performance() {return Skill("Performance");}
            static Skill Persuasion() {return Skill("Persuasion");}

            explicit Skill(const nlohmann::json& data) : name(data) {}

            static Skill string2skill(std::string s) {
                transform(s.begin(), s.end(), s.begin(), ::tolower);
                for(auto& [name, _] : skill2ability) {
                    std::string n = name;
                    transform(n.begin(), n.end(), n.begin(), ::tolower);
                    if(s == n) {
                        return Skill(name);
                    }
                }
                throw std::invalid_argument("Cannot find a skill for input: \"" + s + "\"");
            }

        private:
            const std::string name;

            static const std::map<std::string, std::string> skill2ability;
    };
}