#include "enum.h"
#include "type.h"
#include "string_helper.h"
#include "exception.h"

const Type* Enum::GetEnum(const std::string& enumTypeName, bool throwIfNotFound){
 const Type* enumType = Type::GetType(enumTypeName);

 if (throwIfNotFound){
 if (enumType == nullptr){
 THROW_EXCEPTION(EnumNotFound, "enum '" + enumTypeName + "' not found");
 }
 else if (!enumType->IsEnum()){
 THROW_EXCEPTION(NotAnEnum, "'" + enumTypeName + "' is not an enum type");
 }
 }
 
 if (enumType != nullptr && !enumType->IsEnum()){
 return nullptr;
 }

 return enumType;
}

int64_t Enum::GetValue(const Type* enumType, const std::string& enumName){
 if (!enumType->IsEnum())
 THROW_EXCEPTION(NotAnEnum, "'" + enumType->GetName() + "' is not an enum type");

 auto& map = Enums()[enumType];
 if (map.find(enumName) == map.end())
 THROW_EXCEPTION(EnumNameNotFound, "enum '" + enumType->GetName() + "' has no member named '" + enumName + "'");

 return map[enumName];
}

std::string Enum::GetName(const Type* enumType, int64_t value){
 if (!enumType->IsEnum())
 THROW_EXCEPTION(NotAnEnum, "'" + enumType->GetName() + "' is not an enum type");

 auto& map = Enums2()[enumType];
 if (map.find(value) == map.end())
 THROW_EXCEPTION(EnumValueNotFound, "enum '" + enumType->GetName() + "' has no member valued '" + std::to_string(value) + "'");

 return map[value];
}

std::vector<int64_t> Enum::GetValues(const Type* enumType){
 if (!enumType->IsEnum())
 THROW_EXCEPTION(NotAnEnum, "'" + enumType->GetName() + "' is not an enum type");

 std::vector<int64_t> values;
 for (auto& i : Enums()[enumType]){
 values.push_back(i.second);
 }

 return values;
}

std::vector<std::string> Enum::GetNames(const Type* enumType){
 if (!enumType->IsEnum())
 THROW_EXCEPTION(NotAnEnum, "'" + enumType->GetName() + "' is not an enum type");

 std::vector<std::string> names;
 for (auto& i : Enums()[enumType]){
 names.push_back(i.first);
 }
 return names;
}

const Type* Enum::Register(const std::string& name, const std::string& values, const Type* underlyingType){
 auto items = StringHelper::Split(StringHelper::RemoveSpaces(values), ',');
 std::unordered_map<std::string, int64_t> map;
 const Type* type = Type::RegisterEnum(new Type, name, underlyingType);
 int num = 0;
 for (auto& i : items){
 if ((int)i.find('=') >= 0){
 auto kv = StringHelper::Split(i, '=');
 num = atoi(kv[1].c_str());
 map.insert(std::make_pair(kv[0], num));
 }
 else{
 map.insert(std::make_pair(i, num));
 }
 num++;
 }

 std::unordered_map<int64_t, std::string> map2;
 for (auto& i : map){
 map2.insert(std::make_pair(i.second, i.first));
 }
 Enums().insert(std::make_pair(type, map));
 Enums2().insert(std::make_pair(type, map2));

 return type;
}