#include "token.hpp"
#include <chrono>
#include <curl/curl.h>
#include <format>
#include <fstream>
#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

Token::Token(const std::string &iTokenFilePath) : mFilePath{iTokenFilePath}, mToken{generateToken()} {}

std::string Token::text() const { return mToken; }

const bool Token::hasTokenExpired() const {
    std::ifstream aTokenFile{mFilePath};
    json aCredentialsFile = json::parse(aTokenFile);
    if (not aCredentialsFile.contains("Token") or not aCredentialsFile["Token"].contains("ExpirationTime") or
        not aCredentialsFile["Token"].contains("Content") or aCredentialsFile["Token"]["Content"].empty()) {
        return false;
    }
    const std::uint64_t kExpirationTime{aCredentialsFile["Token"]["ExpirationTime"]};
    const std::uint64_t kCurrentTime{static_cast<std::uint64_t>(
        std::chrono::duration_cast<std::chrono::seconds>(std::chrono::high_resolution_clock::now().time_since_epoch())
            .count())};
    if (kCurrentTime >= kExpirationTime) {
        return true;
    }
    return false;
}

std::string Token::getTokenFromLocalFile() const {
    std::ifstream aTokenFile{mFilePath};
    return json::parse(aTokenFile)["Token"]["Content"];
}

std::string Token::generateToken() {
    if (hasTokenExpired()) {
        const std::string kTokenContent{getTokenWithApi()};
        writeNewTokenToLocalFile(kTokenContent);
    }
    return getTokenFromLocalFile();
}

void Token::writeNewTokenToLocalFile(const std::string &iTokenContent) const {
    std::ifstream aTokenFileInput{mFilePath};
    json aCredentialsFile = json::parse(aTokenFileInput);
    aCredentialsFile["Token"]["Content"] = iTokenContent;
    aCredentialsFile["Token"]["ExpirationTime"] =
        std::chrono::duration_cast<std::chrono::seconds>(getCurrentTime() + std::chrono::hours(24)).count();

    std::ofstream aTokenFileOutput{mFilePath};
    aTokenFileOutput << std::setw(4) << aCredentialsFile;
}

std::string Token::getTokenWithApi() const {
    std::ifstream aCredentialsFile{mFilePath};
    json aCredentials = json::parse(aCredentialsFile);
    if (not aCredentials.contains("Agent") or not aCredentials["Agent"].contains("Username") or
        not aCredentials["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 kAgentUsername{aCredentials["Agent"]["Username"]};
    const std::string kAgentPassword{aCredentials["Agent"]["Password"]};
    CURL *aCurl{curl_easy_init()};
    std::string aTokenInfo;
    if (aCurl and not kAgentUsername.empty() and not kAgentPassword.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("{}:{}", kAgentUsername, kAgentPassword).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" << std::endl;
            std::exit(EXIT_FAILURE);
        }
    }
    return json::parse(aTokenInfo)["access_token"];
}

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

size_t Token::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;
}