#include "utils.h"
#include <nlohmann/json.hpp>
#include "settings.h"
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <filesystem>
#include <stdexcept>
#include <map>
#include <algorithm>

namespace fs = std::filesystem;

nlohmann::json utils::loadJson(const fs::path& path) {
    std::ifstream f(path);
    nlohmann::json j;
    f >> j;
    return j;
}

nlohmann::json utils::loadJson(const std::string& type, const std::string& name) {
    for(auto data : utils::loadAllJson(settings::getString(type))) {
        if(data["name"] == name) {
            return data;
        }
    }
    throw std::invalid_argument("Unknown name: `" + name + "' for type `" + type + "'.");
}

nlohmann::json utils::findByName(const std::string& name) {
    for(auto type : settings::objectTypes) {
        try {
            return utils::loadJson(type, name);
        } catch(std::exception& e) {} // eat.
    }
    throw std::invalid_argument("Could not find data matching: " + name);
}

int utils::parseInt(const std::string& s) {
    try {
        return std::stoi(s);
    } catch(std::exception& e) {
        throw std::runtime_error("An integer was expected but " + s + " was given");
    }
}

void utils::saveJson(const nlohmann::json& data, const fs::path& path) {
    std::ofstream f(path);
    f << std::setw(4) << data << std::endl;
}

static std::map<std::string, std::vector<nlohmann::json>> cache;

std::vector<nlohmann::json> utils::loadAllJson(const std::string& directory) {
    if(cache.contains(directory)) {
        return cache[directory];
    }
    std::vector<nlohmann::json> ret;
    for(auto path : fs::recursive_directory_iterator(directory)) {
        if(path.path().extension() == ".json") {
            ret.push_back(utils::loadJson(path.path()));
        }
    }
    cache[directory] = ret;
    return ret;
}

// Accepts coins formatted "X Yp" where X is an integer and Y is any of c, s, e, g, p.
int utils::coins2copper(const std::string& coins) {
    int num = std::stoi(coins.substr(0, coins.find(" ")));
    std::string denomination(coins.substr(coins.find(" ") + 1));
    if(! cpValue.contains(denomination)) {
        throw std::invalid_argument("Unknown coin type: " + denomination);
    }
    return num * cpValue.at(denomination);
}

// Greedily selects highest coin values to minimize total number of coins
// Returns a vector of pairs mapping coin type to coint
std::vector<std::pair<std::string, int>> utils::copper2coins(int coppers) {
    std::vector<std::pair<std::string, int>> ret;
    while(coppers > 0) {
        // Find the largest denomination in cpValue under coppers
        std::pair<std::string, int> largest("", 0);
        for(auto pair : cpValue) {
            if(pair.second <= coppers && pair.second > largest.second) {
                largest = pair;
            }
        }
        std::pair<std::string, int> amnt(largest.first, coppers / largest.second);
        coppers -= amnt.second * largest.second;
        ret.push_back(amnt);
    }
    if(ret.empty()) {
        ret.push_back({"cp", 0});
    }
    return ret;
}

std::string utils::getCostString(int coppers) {
    std::vector<std::string> parts;
    for(auto pair : utils::copper2coins(coppers)) {
        parts.push_back(std::to_string(pair.second) + " " + pair.first);
    }
    return utils::join(parts, ", ");
}

std::string utils::toOrdinal(std::size_t number) {
    std::string suffix = "th";
    if (number % 100 < 11 || number % 100 > 13) {
        switch (number % 10) {
            case 1:
                suffix = "st";
                break;
            case 2:
                suffix = "nd";
                break;
            case 3:
                suffix = "rd";
                break;
        }
    }
    return std::to_string(number) + suffix;
}

std::string utils::lower(std::string& in) {
    std::transform(in.begin(), in.end(), in.begin(), ::tolower);
    return in;
}