#include "balance_tab_helpers.h"

#include "../../config/version.h"
#include "../../embedded/IconsMaterialDesign.h"
#include "../../util/i18n.h"
#include "../material/colors.h"
#include "../material/type.h"

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <ctime>

namespace dragonx {
namespace ui {

std::string TrId(const char* trKey, const char* id)
{
    std::string value = TR(trKey);
    value += "##";
    value += id;
    return value;
}

bool containsIgnoreCase(const std::string& value, const std::string& search)
{
    if (search.empty()) return true;
    std::string haystack = value;
    std::string needle = search;
    std::transform(haystack.begin(), haystack.end(), haystack.begin(), ::tolower);
    std::transform(needle.begin(), needle.end(), needle.begin(), ::tolower);
    return haystack.find(needle) != std::string::npos;
}

std::string timeAgo(int64_t timestamp)
{
    if (timestamp <= 0) return "";
    int64_t now = static_cast<int64_t>(std::time(nullptr));
    int64_t diff = now - timestamp;
    if (diff < 0) diff = 0;
    if (diff < 60)    return std::to_string(diff) + "s ago";
    if (diff < 3600)  return std::to_string(diff / 60) + "m ago";
    if (diff < 86400) return std::to_string(diff / 3600) + "h ago";
    return std::to_string(diff / 86400) + "d ago";
}

std::string truncateAddress(const std::string& address, int maxLen)
{
    if (address.length() <= static_cast<size_t>(maxLen)) return address;
    int half = (maxLen - 3) / 2;
    return address.substr(0, half) + "..." + address.substr(address.length() - half);
}

ImU32 recentTxIconColor(const std::string& type)
{
    using namespace material;
    if (type == "send") return Error();
    if (type == "receive") return Success();
    return Warning();
}

ImU32 recentTxAmountColor(const std::string& type)
{
    using namespace material;
    return type == "send" ? Error() : Success();
}

std::string formatRecentTxAmount(const std::string& type, double amount)
{
    char buffer[32];
    snprintf(buffer, sizeof(buffer), "%s%.4f %s",
             type == "send" ? "-" : "+",
             std::abs(amount), DRAGONX_TICKER);
    return std::string(buffer);
}

void DrawTxIcon(ImDrawList* drawList, const std::string& type,
                float centerX, float centerY, float, ImU32 color)
{
    using namespace material;
    ImFont* iconFont = Type().iconSmall();
    const char* icon = ICON_MD_CONSTRUCTION;
    if (type == "send") {
        icon = ICON_MD_CALL_MADE;
    } else if (type == "receive") {
        icon = ICON_MD_CALL_RECEIVED;
    }
    ImVec2 size = iconFont->CalcTextSizeA(iconFont->LegacySize, 1000.0f, 0.0f, icon);
    drawList->AddText(iconFont, iconFont->LegacySize,
        ImVec2(centerX - size.x * 0.5f, centerY - size.y * 0.5f), color, icon);
}

void DrawSparkline(ImDrawList* drawList, const ImVec2& min, const ImVec2& max,
                   const std::vector<double>& data, ImU32 color, float thickness)
{
    if (data.size() < 2) return;
    double low = *std::min_element(data.begin(), data.end());
    double high = *std::max_element(data.begin(), data.end());
    double range = high - low;
    if (range < 1e-12) range = 1.0;

    float width = max.x - min.x;
    float height = max.y - min.y;
    int count = static_cast<int>(data.size());

    std::vector<ImVec2> points;
    points.reserve(count);
    for (int i = 0; i < count; i++) {
        float x = min.x + static_cast<float>(i) / static_cast<float>(count - 1) * width;
        float y = max.y - static_cast<float>((data[i] - low) / range) * height;
        points.push_back(ImVec2(x, y));
    }
    drawList->AddPolyline(points.data(), count, color, ImDrawFlags_None, thickness);
}

} // namespace ui
} // namespace dragonx