#include <chrono>
#include <curl/curl.h>
#include <fstream>
#include <hearthstoneTokenBuilder.hpp>
#include <iostream>
#include <memory>

namespace bnet {
HearthstoneTokenBuilder::HearthstoneTokenBuilder(const std::span<std::string> &iJsonPaths) {
    _credentialJsonPaths.append_range(iJsonPaths);
}
HearthstoneTokenBuilder &HearthstoneTokenBuilder::buildToken() {
    for (const std::string &aCredentialJsonPath : _credentialJsonPaths) {
        std::ifstream aCredentialJsonFile{aCredentialJsonPath};
        json aCredentialJson = json::parse(aCredentialJsonFile);
        if (isTokenValid(aCredentialJson)) {
            _currentToken = std::make_shared<Token>();
            _currentToken->setText(aCredentialJson["Token"]["Content"]);
            _currentToken->setExpirationTime(
                std::chrono::seconds(aCredentialJson["Token"]["ExpirationTime"]));
            return *this;
        }
    }

    if (!_allowBattleNetApiCall) {
        return *this;
    }

    for (const std::string &aCredentialJsonPath : _credentialJsonPaths) {
        std::ifstream aCredentialJsonFile{aCredentialJsonPath};
        json aCredentialJson = json::parse(aCredentialJsonFile);
        _currentToken = std::make_shared<Token>(getTokenWithApi(aCredentialJson));
        if (_currentToken) {
            if (_allowUpdateSourceFile) {
                writeTokenToLocalFile(_currentToken, aCredentialJsonPath);
            }
            break;
        }
    }
    return *this;
}

std::shared_ptr<Token> HearthstoneTokenBuilder::getToken() { return _currentToken; }

HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowBattleNetApiCall() {
    _allowBattleNetApiCall = true;
    return *this;
}
HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowUpdateSourceFile() {
    _allowUpdateSourceFile = true;
    return *this;
}
HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowExpiredToken() {
    _allowExpiredToken = true;
    return *this;
}
bool HearthstoneTokenBuilder::isUpdateSourceFileAllowed() const { return _allowUpdateSourceFile; }

bool HearthstoneTokenBuilder::isTokenValid(const json &iTokenJson) const {
    if (not iTokenJson.contains("Token") or not iTokenJson["Token"].contains("ExpirationTime") or
        not iTokenJson["Token"].contains("Content")) {
        return false;
    }
    if (iTokenJson["Token"]["Content"].get<std::string>().length() < kTOKEN_CONTENT_MIN_LENGTH) {
        return false;
    }
    if (_allowExpiredToken) {
        return true;
    }
    const std::uint64_t kExpirationTime{iTokenJson["Token"]["ExpirationTime"]};
    const std::uint64_t kCurrentTime{
        static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
                                       std::chrono::system_clock::now().time_since_epoch())
                                       .count())};
    return kCurrentTime <= kExpirationTime;
}

std::chrono::seconds HearthstoneTokenBuilder::getCurrentTime() const {
    return std::chrono::duration_cast<std::chrono::seconds>(
        std::chrono::utc_clock::now().time_since_epoch());
}

Token HearthstoneTokenBuilder::getTokenWithApi(const std::string &iCredentialsJsonFilePath) const {
    std::ifstream aAgentJsonFile{iCredentialsJsonFilePath};
    json aCredentials = json::parse(aAgentJsonFile);
    return getTokenWithApi(aCredentials);
}

size_t HearthstoneTokenBuilder::curlCallbackStringOutput(void *iPtr, size_t iSize, size_t iNmemb,
                                                         std::string *iUserData) {
    size_t newLength{iSize * iNmemb};
    try {
        iUserData->append(static_cast<char *>(iPtr), newLength);
    } catch (std::bad_alloc &e) {
        // handle memory problem
        return 0;
    }
    return newLength;
}

Token HearthstoneTokenBuilder::getTokenWithApi(const json &iCredentials) const {
    if (not iCredentials.contains("Agent") or not iCredentials["Agent"].contains("Username") or
        not iCredentials["Agent"].contains("Password")) {
        std::cerr << "Please define Agent/Username and Agent/Password in the "
                     "JSON credentials file\n";
        std::exit(EXIT_FAILURE);
    }
    const std::string aAgentUsername{iCredentials["Agent"]["Username"]};
    const std::string aAgentPassword{iCredentials["Agent"]["Password"]};
    CURL *aCurl{curl_easy_init()};
    std::string aTokenInfo;
    if (aCurl and not aAgentUsername.empty() and not aAgentPassword.empty()) {
        curl_easy_setopt(aCurl, CURLOPT_URL, "https://oauth.battle.net/token");
        curl_easy_setopt(aCurl, CURLOPT_SSL_VERIFYPEER, 0L);
        curl_easy_setopt(aCurl, CURLOPT_SSL_VERIFYHOST, 0L);
        curl_easy_setopt(aCurl, CURLOPT_WRITEFUNCTION, curlCallbackStringOutput);
        curl_easy_setopt(aCurl, CURLOPT_WRITEDATA, &aTokenInfo);
        curl_easy_setopt(aCurl, CURLOPT_USERPWD,
                         std::format("{}:{}", aAgentUsername, aAgentPassword).data());
        curl_easy_setopt(aCurl, CURLOPT_POSTFIELDS, "grant_type=client_credentials");
        CURLcode result_code{curl_easy_perform(aCurl)};
        curl_easy_cleanup(aCurl);
        if (result_code != CURLE_OK) {
            std::cerr << "ERROR: token request failed\n";
            std::exit(EXIT_FAILURE);
        }
    }
    json aTokenJson = json::parse(aTokenInfo);
    return Token{}
        .setText(aTokenJson["access_token"])
        .setLifetime(std::chrono::seconds{aTokenJson["expires_in"]});
}

void HearthstoneTokenBuilder::writeTokenToLocalFile(std::shared_ptr<Token> &iToken,
                                                    const std::string &iTokenFileOutputPath) const {
    std::ifstream aTokenFile{iTokenFileOutputPath};
    json aCredentialsFile = json::parse(aTokenFile);
    aCredentialsFile["Token"]["Content"] = iToken->text();
    aCredentialsFile["Token"]["ExpirationTime"] = iToken->expirationTime()->count();
    std::ofstream aTokenFileOutput{iTokenFileOutputPath};
    aTokenFileOutput << std::setw(4) << aCredentialsFile;
}
} // namespace bnet