#include "bf.util.h"

#include <iomanip>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <random>
#include <sstream>

std::shared_ptr<spdlog::logger> gLogger = nullptr;

void BF_Util::initLogger()
{
    if (!gLogger) {
        auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
        console_sink->set_pattern("%^[%Y-%m-%d %H:%M:%S.%e][%l]: %v%$");
        std::vector<spdlog::sink_ptr> sinks{console_sink};
        gLogger = std::make_shared<spdlog::logger>("baidu_fanyi", sinks.begin(), sinks.end());
        gLogger->set_level(spdlog::level::debug);
        spdlog::register_logger(gLogger);
    }
}

void BF_Util::setLogLevel(spdlog::level::level_enum level)
{
    if (gLogger) {
        gLogger->set_level(level);
    }
}

std::string BF_Util::MD5(const std::string& data)
{
    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
    if (!mdctx) {
        gLogger->error("EVP_MD_CTX_new failed");
        return std::string();
    }
    std::shared_ptr<void> d(nullptr, [mdctx](void*) { EVP_MD_CTX_free(mdctx); });
    auto ir = EVP_DigestInit_ex(mdctx, EVP_md5(), nullptr);
    if (!ir) {
        gLogger->error("EVP_DigestInit_ex failed");
        return std::string();
    }
    auto ur = EVP_DigestUpdate(mdctx, data.c_str(), data.length());
    if (!ur) {
        gLogger->error("EVP_DigestUpdate failed");
        return std::string();
    }
    unsigned char md_value[EVP_MAX_MD_SIZE];
    unsigned int md_len;
    auto fr = EVP_DigestFinal_ex(mdctx, md_value, &md_len);
    if (!fr) {
        gLogger->error("EVP_DigestFinal_ex failed");
        return std::string();
    }
    std::ostringstream os;
    for (unsigned int i = 0; i < md_len; i++) {
        os << std::setw(2) << std::setfill('0') << std::hex << (int)md_value[i];
    }
    return os.str();
}

std::string BF_Util::RandomStrNum()
{
    static std::random_device rd;
    static std::mt19937 gen(rd());
    static std::uniform_int_distribution<> dis(100000000, 999999999);
    long long num = dis(gen);
    return std::to_string(num);
}

std::string BF_Util::urlEncode(const std::string& data)
{
    std::ostringstream os;
    for (unsigned char c : data) {
        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
            os << c;
        } else {
            os << '%' << std::uppercase << std::setw(2) << std::setfill('0') << std::hex << (int)c;
        }
    }
    return os.str();
}

std::vector<std::string> BF_Util::split(const std::string& str, const std::string& delim)
{
    std::vector<std::string> ret;
    size_t start = 0;
    size_t end = str.find(delim);
    while (end != std::string::npos) {
        ret.push_back(str.substr(start, end - start));
        start = end + delim.length();
        end = str.find(delim, start);
    }
    ret.push_back(str.substr(start));
    return ret;
}

void BF_Util::trim(std::string& str)
{
    auto left = std::find_if_not(str.begin(), str.end(), [](unsigned char ch) { return std::isspace(ch); });
    str.erase(str.begin(), left);
    if (!str.empty()) {
        auto right = std::find_if_not(str.rbegin(), str.rend(), [](unsigned char ch) { return std::isspace(ch); }).base();
        str.erase(right, str.end());
    }
}