// Copyright (c) 2011-2021 The Limenka developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <qt/limenkaunits.h>
#include <chainparams.h>
#include <consensus/params.h>
#include <qt/guiutil.h>
#include <qt/tonalutils.h>

#include <consensus/amount.h>

#include <QFont>
#include <QRegularExpression>
#include <QStringList>

#include <cassert>

static constexpr auto MAX_DIGITS_BTC = 16;
static constexpr auto MAX_DIGITS_TBC = 13;

LimenkaUnits::LimenkaUnits(QObject *parent):
        QAbstractListModel(parent),
        unitlist(availableUnits())
{
}

QList<LimenkaUnit> LimenkaUnits::availableUnits()
{
    static QList<LimenkaUnit> unitlist;
    if (!unitlist.isEmpty()) return unitlist;
    unitlist.append(Unit::BTC);
    unitlist.append(Unit::mBTC);
    unitlist.append(Unit::uBTC);
    unitlist.append(Unit::SAT);
    unitlist.append(Unit::TBC);
    // ATTO (attosats) is always listed; OptionsModel::setDisplayUnit rejects
    // selecting it before fork activation.
    unitlist.append(Unit::ATTO);
    
    return unitlist;
}

QString LimenkaUnits::longName(Unit unit)
{
    switch (unit) {
    case Unit::BTC: return QString::fromUtf8("\xce\xbb (lambda)");
    case Unit::mBTC: return QString("mBTC");
    case Unit::uBTC: return QString::fromUtf8("µBTC (bits)");
    case Unit::SAT: return QString("sats");
    case Unit::ATTO: return QString::fromUtf8("\xce\x9b (attosats)");
    case Unit::bTBC: return QString::fromUtf8("ᵇTBC");
    case Unit::sTBC: return QString::fromUtf8("ˢTBC");
    case Unit::TBC: return QString("TBC");
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}

QString LimenkaUnits::shortName(Unit unit)
{
    switch (unit) {
    case Unit::BTC: return QString::fromUtf8("\xce\xbb");
    case Unit::mBTC: return longName(unit);
    case Unit::uBTC: return QString("bits");
    case Unit::SAT: return QString("sats");
    case Unit::ATTO: return QString::fromUtf8("\xce\x9b");
    case Unit::bTBC: return QString::fromUtf8("ᵇTBC");
    case Unit::sTBC: return QString::fromUtf8("ˢTBC");
    case Unit::TBC: return QString("TBC");
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}

QString LimenkaUnits::description(Unit unit)
{
    switch (unit) {
    case Unit::BTC: return QString("Limenkas (decimal)");
    case Unit::mBTC: return QString("Milli-Limenkas (1 / 1" THIN_SP_UTF8 "000)");
    case Unit::uBTC: return QString("Micro-Limenkas (bits) (1 / 1" THIN_SP_UTF8 "000" THIN_SP_UTF8 "000)");
    case Unit::SAT: return QString("Satoshi (sat) (1 / 100" THIN_SP_UTF8 "000" THIN_SP_UTF8 "000)");
    case Unit::bTBC: return QString("Bong-Limenkas (1,0000 tonal)");
    case Unit::sTBC: return QString("San-Limenkas (100 tonal)");
    case Unit::TBC: return QString("Limenkas (tonal)");
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}

qint64 LimenkaUnits::factor(Unit unit)
{
    switch (unit) {
    case Unit::BTC: return 100'000'000;
    case Unit::mBTC: return 100'000;
    case Unit::uBTC: return 100;
    case Unit::SAT: return 1;
    case Unit::ATTO: return 1;  // Special: multiply by 10^10 in format
    case Unit::bTBC: return 0x100000000LL;
    case Unit::sTBC: return 0x1000000;
    case Unit::TBC:  return 0x10000;
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}

int LimenkaUnits::decimals(Unit unit)
{
    switch (unit) {
    case Unit::BTC: return 8;
    case Unit::mBTC: return 5;
    case Unit::uBTC: return 2;
    case Unit::SAT: return 0;
    case Unit::ATTO: return 0;  // Integer attosats
    case Unit::bTBC: return 8;
    case Unit::sTBC: return 6;
    case Unit::TBC: return 4;
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}

int LimenkaUnits::radix(Unit unit)
{
    switch (unit) {
    case Unit::bTBC:
    case Unit::sTBC:
    case Unit::TBC:
        return 0x10;
    default:
        return 10;
    }
}

LimenkaUnit LimenkaUnits::numsys(Unit unit)
{
    switch (unit) {
    case Unit::bTBC:
    case Unit::sTBC:
    case Unit::TBC:
        return Unit::TBC;
    default:
        return Unit::BTC;
    }
}

qint64 LimenkaUnits::max_digits(Unit unit)
{
    switch (numsys(unit)) {
    case Unit::TBC:
        return MAX_DIGITS_TBC;
    default:
        return MAX_DIGITS_BTC;
    }
}

qint64 LimenkaUnits::singlestep(Unit unit)
{
    switch (numsys(unit)) {
    case Unit::TBC:
        return 0x10000;
    default:
        return 100000;
    }
}

QString LimenkaUnits::format(Unit unit, const CAmount& nIn, bool fPlus, SeparatorStyle separators, bool justify)
{
    // Note: not using straight sprintf here because we do NOT want
    // localized number formatting.
    qint64 n = (qint64)nIn;
    
    // Special handling for ATTO: convert satoshis to attosats (1 sat = 10^10 attos)
    if (unit == Unit::ATTO) {
        // Multiply by 10^10 to get attosats
        // Note: this may overflow for very large amounts, but that's unlikely
        n = n * 10000000000LL;
    }
    
    qint64 coin = factor(unit);
    int num_decimals = decimals(unit);
    qint64 n_abs = (n > 0 ? n : -n);
    qint64 quotient = n_abs / coin;
    int uradix = radix(unit);
    QString quotient_str = QString::number(quotient, uradix);
    if (justify) {
        quotient_str = quotient_str.rightJustified(max_digits(unit) - num_decimals, ' ');
    }

    QString remainder_str;
    if (num_decimals > 0) {
        const qint64 remainder = n_abs % coin;
        remainder_str = QString::number(remainder, uradix).rightJustified(num_decimals, '0');
    }

    switch (numsys(unit)) {
    case Unit::BTC:
    {

    // Use SI-style thin space separators as these are locale independent and can't be
    // confused with the decimal marker.
    QChar thin_sp(THIN_SP_CP);
    int q_size = quotient_str.size();
    if (separators == SeparatorStyle::ALWAYS || (separators == SeparatorStyle::STANDARD && q_size > 4))
        for (int i = 3; i < q_size; i += 3)
            quotient_str.insert(q_size - i, thin_sp);

    break;
    }
    case Unit::TBC:
    {
        // Right-trim excess zeros after the decimal point
        static const QRegularExpression tail_zeros("0+$");
        remainder_str.remove(tail_zeros);
        TonalUtils::ConvertFromHex(quotient_str);
        TonalUtils::ConvertFromHex(remainder_str);
        break;
    }
    default: assert(false);
    }

    if (n < 0)
        quotient_str.insert(0, '-');
    else if (fPlus && n > 0)
        quotient_str.insert(0, '+');

    if (!remainder_str.isEmpty())
        quotient_str += QString(".") + remainder_str;
    return quotient_str;
}


// NOTE: Using formatWithUnit in an HTML context risks wrapping
// quantities at the thousands separator. More subtly, it also results
// in a standard space rather than a thin space, due to a bug in Qt's
// XML whitespace canonicalisation
//
// Please take care to use formatHtmlWithUnit instead, when
// appropriate.

QString LimenkaUnits::formatWithUnit(Unit unit, const CAmount& amount, bool plussign, SeparatorStyle separators)
{
    return format(unit, amount, plussign, separators) + QString(" ") + shortName(unit);
}

QString LimenkaUnits::formatHtmlWithUnit(const QFont& font, Unit unit, const CAmount& amount, bool plussign, SeparatorStyle separators)
{
    QString str(formatWithUnit(unit, amount, plussign, separators));
    str.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
    return QString("<span style='white-space:nowrap;%2'>%1</span>").arg(str).arg(GUIUtil::fontToCss(font));
}

QString LimenkaUnits::formatWithSubSatoshi(const QFont& font, Unit unit, const CAmount& amount, uint64_t subSatoshi, bool plussign, SeparatorStyle separators)
{
    // Format with sub-satoshi precision (dimmed trailing digits)
    // For λ mode: show 1.23456789 λ, with sub-satoshi digits dimmed
    // For sats mode: show 123456789 sats, with sub-satoshi digits dimmed
    // For Λ mode: show integer attosats
    
    QString mainStr = formatWithUnit(unit, amount, plussign, separators);
    mainStr.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
    
    // CSS for dimmed sub-satoshi digits
    QString dimmedStyle = "color: #888888; font-size: 0.85em;";
    QString normalStyle = GUIUtil::fontToCss(font);
    
    // If no sub-satoshi or in ATTO mode, just return main string
    if (subSatoshi == 0 || unit == Unit::ATTO) {
        return QString("<span style='white-space:nowrap;%2'>%1</span>").arg(mainStr).arg(normalStyle);
    }
    
    // For λ mode: append sub-satoshi digits dimmed
    // For sats mode: append sub-satoshi digits dimmed
    QString subStr = QString::number(subSatoshi).rightJustified(18, '0');
    // Remove trailing zeros
    while (subStr.endsWith('0') && subStr.size() > 1) {
        subStr.chop(1);
    }
    
    // Build HTML with dimmed sub-satoshi (space separator, not dot)
    return QString("<span style='white-space:nowrap;%3'>%1 <span style='%4'>%2</span></span>")
        .arg(mainStr)
        .arg(subStr)
        .arg(normalStyle)
        .arg(dimmedStyle);
}

QString LimenkaUnits::formatWithPrivacy(Unit unit, const CAmount& amount, SeparatorStyle separators, bool privacy)
{
    assert(amount >= 0);
    QString value;
    if (privacy) {
        value = format(unit, 0, false, separators, true).replace('0', '#');
    } else {
        value = format(unit, amount, false, separators, true);
    }
    value += QString(" ") + shortName(unit);
    value.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
    return QString("<span style='white-space: nowrap;'>%1</span>").arg(value);
}

bool LimenkaUnits::parse(Unit unit, const QString& value, CAmount* val_out)
{
    if (value.isEmpty()) {
        return false; // Refuse to parse invalid unit or empty string
    }
    int num_decimals = decimals(unit);

    // Ignore spaces and thin spaces when parsing
    QStringList parts = removeSpaces(value).split(".");

    if(parts.size() > 2)
    {
        return false; // More than one dot
    }
    const QString& whole = parts[0];
    QString decimals;

    if(parts.size() > 1)
    {
        decimals = parts[1];
    }
    if(decimals.size() > num_decimals)
    {
        return false; // Exceeds max precision
    }
    bool ok = false;
    QString str = whole + decimals.leftJustified(num_decimals, '0');

    Unit unumsys = numsys(unit);
    if (unumsys == Unit::TBC) {
        if (str.size() > 15)
            return false; // Longer numbers may exceed 63 bits
        TonalUtils::ConvertToHex(str);
    } else
    if(str.size() > 18)
    {
        return false; // Longer numbers will exceed 63 bits
    }

    CAmount retvalue(str.toLongLong(&ok, radix(unit)));
    if(val_out)
    {
        *val_out = retvalue;
    }
    return ok;
}

QString LimenkaUnits::getAmountColumnTitle(Unit unit)
{
    return QObject::tr("Amount") + " (" + shortName(unit) + ")";
}

int LimenkaUnits::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return unitlist.size();
}

QVariant LimenkaUnits::data(const QModelIndex &index, int role) const
{
    int row = index.row();
    if(row >= 0 && row < unitlist.size())
    {
        Unit unit = unitlist.at(row);
        switch(role)
        {
        case Qt::EditRole:
        case Qt::DisplayRole:
            return QVariant(longName(unit));
        case Qt::ToolTipRole:
            return QVariant(description(unit));
        case UnitRole:
            return QVariant::fromValue(unit);
        }
    }
    return QVariant();
}

CAmount LimenkaUnits::maxMoney()
{
    return MAX_MONEY;
}

std::variant<qint8, QString> LimenkaUnits::ToSetting(LimenkaUnit unit)
{
    switch (unit) {
    case LimenkaUnit::BTC:  return qint8{0};
    case LimenkaUnit::mBTC: return qint8{1};
    case LimenkaUnit::uBTC: return qint8{2};
    case LimenkaUnit::SAT:  return qint8{3};
    case LimenkaUnit::bTBC: return QString("bTBC");
    case LimenkaUnit::sTBC: return QString("sTBC");
    case LimenkaUnit::TBC:  return QString("TBC");
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}

namespace {
LimenkaUnit FromQint8(qint8 num)
{
    switch (num) {
    case 0: return LimenkaUnit::BTC;
    case 1: return LimenkaUnit::mBTC;
    case 2: return LimenkaUnit::uBTC;
    case 3: return LimenkaUnit::SAT;
    }
    return LimenkaUnit::BTC;
}
} // namespace

LimenkaUnit LimenkaUnits::FromSetting(const QString& s, LimenkaUnit def)
{
    if (s == "0") return LimenkaUnit::BTC;
    if (s == "1") return LimenkaUnit::mBTC;
    if (s == "2") return LimenkaUnit::uBTC;
    if (s == "3") return LimenkaUnit::SAT;
    if (s == "4") return LimenkaUnit::sTBC;
    if (s == "5") return LimenkaUnit::TBC;
    if (s == "bTBC") return LimenkaUnit::bTBC;
    if (s == "sTBC") return LimenkaUnit::sTBC;
    if (s == "TBC")  return LimenkaUnit::TBC;
    return def;
}

QDataStream& operator<<(QDataStream& out, const LimenkaUnit& unit)
{
    auto setting_val = LimenkaUnits::ToSetting(unit);
    if (const QString* setting_str = std::get_if<QString>(&setting_val)) {
        return out << qint8{0} << *setting_str;
    } else {
        return out << std::get<qint8>(setting_val);
    }
}

QDataStream& operator>>(QDataStream& in, LimenkaUnit& unit)
{
    qint8 input;
    in >> input;
    unit = FromQint8(input);
    if (!in.atEnd()) {
        QString setting_str;
        in >> setting_str;
        unit = LimenkaUnits::FromSetting(setting_str, unit);
    }
    return in;
}