//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012, 2013 Ripple Labs Inc.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.

    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================

#include <BeastConfig.h>

#include <ripple/basics/contract.h>
#include <ripple/basics/Log.h>
#include <ripple/protocol/JsonFields.h>
#include <ripple/crypto/CBigNum.h>
#include <ripple/protocol/SystemParameters.h>
#include <ripple/protocol/STAmount.h>
#include <ripple/protocol/UintTypes.h>
#include <beast/module/core/text/LexicalCast.h>
#include <boost/regex.hpp>
#include <boost/algorithm/string.hpp>
#include <iterator>
#include <memory>
#include <iostream>

namespace ripple {

static const std::uint64_t tenTo14 = 100000000000000ull;
static const std::uint64_t tenTo14m1 = tenTo14 - 1;
static const std::uint64_t tenTo17 = tenTo14 * 1000;

//------------------------------------------------------------------------------
static
std::int64_t
getSNValue (STAmount const& amount)
{
    if (!amount.native ())
        throw std::runtime_error ("amount is not native!");

    auto ret = static_cast<std::int64_t>(amount.mantissa ());

    assert (static_cast<std::uint64_t>(ret) == amount.mantissa ());

    if (amount.negative ())
        ret = -ret;

    return ret;
}

static
bool
areComparable (STAmount const& v1, STAmount const& v2)
{
    return v1.native() == v2.native() &&
        v1.issue().currency == v2.issue().currency;
}

STAmount::STAmount(SerialIter& sit, SField const& name)
    : STBase(name)
{
    std::uint64_t value = sit.get64 ();

    // native
    if ((value & cNotNative) == 0)
    {
        // positive
        if ((value & cPosNative) != 0)
        {
            mValue = value & ~cPosNative;
            mOffset = 0;
            mIsNative = true;
            mIsNegative = false;
            return;
        }

        // negative
        if (value == 0)
            throw std::runtime_error ("negative zero is not canonical");

        mValue = value;
        mOffset = 0;
        mIsNative = true;
        mIsNegative = true;
        return;
    }

    Issue issue;
    issue.currency.copyFrom (sit.get160 ());

    if (isXRP (issue.currency))
        throw std::runtime_error ("invalid native currency");

    issue.account.copyFrom (sit.get160 ());

    if (isXRP (issue.account))
        throw std::runtime_error ("invalid native account");

    // 10 bits for the offset, sign and "not native" flag
    int offset = static_cast<int>(value >> (64 - 10));

    value &= ~ (1023ull << (64 - 10));

    if (value)
    {
        bool isNegative = (offset & 256) == 0;
        offset = (offset & 255) - 97; // center the range

        if (value < cMinValue ||
            value > cMaxValue ||
            offset < cMinOffset ||
            offset > cMaxOffset)
        {
            throw std::runtime_error ("invalid currency value");
        }

        mIssue = issue;
        mValue = value;
        mOffset = offset;
        mIsNegative = isNegative;
        canonicalize();
        return;
    }

    if (offset != 512)
        throw std::runtime_error ("invalid currency value");

    mIssue = issue;
    mValue = 0;
    mOffset = 0;
    mIsNegative = false;
    canonicalize();
}

STAmount::STAmount (SField const& name, Issue const& issue,
        mantissa_type mantissa, exponent_type exponent,
            bool native, bool negative, unchecked)
    : STBase (name)
    , mIssue (issue)
    , mValue (mantissa)
    , mOffset (exponent)
    , mIsNative (native)
    , mIsNegative (negative)
{
}

STAmount::STAmount (Issue const& issue,
        mantissa_type mantissa, exponent_type exponent,
            bool native, bool negative, unchecked)
    : mIssue (issue)
    , mValue (mantissa)
    , mOffset (exponent)
    , mIsNative (native)
    , mIsNegative (negative)
{
}


STAmount::STAmount (SField const& name, Issue const& issue,
        mantissa_type mantissa, exponent_type exponent,
            bool native, bool negative)
    : STBase (name)
    , mIssue (issue)
    , mValue (mantissa)
    , mOffset (exponent)
    , mIsNative (native)
    , mIsNegative (negative)
{
    canonicalize();
}

STAmount::STAmount (SField const& name, std::int64_t mantissa)
    : STBase (name)
    , mOffset (0)
    , mIsNative (true)
{
    set (mantissa);
}

STAmount::STAmount (SField const& name,
        std::uint64_t mantissa, bool negative)
    : STBase (name)
    , mValue (mantissa)
    , mOffset (0)
    , mIsNative (true)
    , mIsNegative (negative)
{
}

STAmount::STAmount (SField const& name, Issue const& issue,
        std::uint64_t mantissa, int exponent, bool negative)
    : STBase (name)
    , mIssue (issue)
    , mValue (mantissa)
    , mOffset (exponent)
    , mIsNegative (negative)
{
    canonicalize ();
}

//------------------------------------------------------------------------------

STAmount::STAmount (std::uint64_t mantissa, bool negative)
    : mValue (mantissa)
    , mOffset (0)
    , mIsNative (true)
    , mIsNegative (mantissa != 0 && negative)
{
}

STAmount::STAmount (Issue const& issue,
    std::uint64_t mantissa, int exponent, bool negative)
    : mIssue (issue)
    , mValue (mantissa)
    , mOffset (exponent)
    , mIsNegative (negative)
{
    canonicalize ();
}

STAmount::STAmount (Issue const& issue,
        std::int64_t mantissa, int exponent)
    : mIssue (issue)
    , mOffset (exponent)
{
    set (mantissa);
    canonicalize ();
}

STAmount::STAmount (Issue const& issue,
        std::uint32_t mantissa, int exponent, bool negative)
    : STAmount (issue, static_cast<std::uint64_t>(mantissa), exponent, negative)
{
}

STAmount::STAmount (Issue const& issue,
        int mantissa, int exponent)
    : STAmount (issue, static_cast<std::int64_t>(mantissa), exponent)
{
}

// Legacy support for new-style amounts
STAmount::STAmount (IOUAmount const& amount, Issue const& issue)
    : mIssue (issue)
    , mOffset (amount.exponent ())
    , mIsNative (false)
    , mIsNegative (amount < zero)
{
    if (mIsNegative)
        mValue = static_cast<std::uint64_t> (-amount.mantissa ());
    else
        mValue = static_cast<std::uint64_t> (amount.mantissa ());

    canonicalize ();
}

STAmount::STAmount (XRPAmount const& amount)
    : mOffset (0)
    , mIsNative (true)
    , mIsNegative (amount < zero)
{
    if (mIsNegative)
        mValue = static_cast<std::uint64_t> (-amount.drops ());
    else
        mValue = static_cast<std::uint64_t> (amount.drops ());

    canonicalize ();
}

std::unique_ptr<STAmount>
STAmount::construct (SerialIter& sit, SField const& name)
{
    return std::make_unique<STAmount>(sit, name);
}

//------------------------------------------------------------------------------
//
// Conversion
//
//------------------------------------------------------------------------------
XRPAmount STAmount::xrp () const
{
    if (!mIsNative)
        throw std::logic_error ("Cannot return non-native STAmount as XRPAmount");

    auto drops = static_cast<std::int64_t> (mValue);

    if (mIsNegative)
        drops = -drops;

    return { drops };
}

IOUAmount STAmount::iou () const
{
    if (mIsNative)
        throw std::logic_error ("Cannot return native STAmount as IOUAmount");

    auto mantissa = static_cast<std::int64_t> (mValue);
    auto exponent = mOffset;

    if (mIsNegative)
        mantissa = -mantissa;

    return { mantissa, exponent };
}

//------------------------------------------------------------------------------
//
// Operators
//
//------------------------------------------------------------------------------

STAmount& STAmount::operator+= (STAmount const& a)
{
    *this = *this + a;
    return *this;
}

STAmount& STAmount::operator-= (STAmount const& a)
{
    *this = *this - a;
    return *this;
}

STAmount operator+ (STAmount const& v1, STAmount const& v2)
{
    if (!areComparable (v1, v2))
        throw std::runtime_error ("Can't add amounts that are't comparable!");

    if (v2 == zero)
        return v1;

    if (v1 == zero)
    {
        // Result must be in terms of v1 currency and issuer.
        return { v1.getFName (), v1.issue (),
            v2.mantissa (), v2.exponent (), v2.negative () };
    }

    if (v1.native ())
        return { v1.getFName (), getSNValue (v1) + getSNValue (v2) };

    int ov1 = v1.exponent (), ov2 = v2.exponent ();
    std::int64_t vv1 = static_cast<std::int64_t>(v1.mantissa ());
    std::int64_t vv2 = static_cast<std::int64_t>(v2.mantissa ());

    if (v1.negative ())
        vv1 = -vv1;

    if (v2.negative ())
        vv2 = -vv2;

    while (ov1 < ov2)
    {
        vv1 /= 10;
        ++ov1;
    }

    while (ov2 < ov1)
    {
        vv2 /= 10;
        ++ov2;
    }

    // This addition cannot overflow an std::int64_t. It can overflow an
    // STAmount and the constructor will throw.

    std::int64_t fv = vv1 + vv2;

    if ((fv >= -10) && (fv <= 10))
        return { v1.getFName (), v1.issue () };

    if (fv >= 0)
        return STAmount { v1.getFName (), v1.issue (),
            static_cast<std::uint64_t>(fv), ov1, false };

    return STAmount { v1.getFName (), v1.issue (),
        static_cast<std::uint64_t>(-fv), ov1, true };
}

STAmount operator- (STAmount const& v1, STAmount const& v2)
{
    return v1 + (-v2);
}

//------------------------------------------------------------------------------

std::uint64_t const STAmount::uRateOne = getRate (STAmount (1), STAmount (1));

STAmount const STAmount::saZero (noIssue (), 0u);
STAmount const STAmount::saOne (noIssue (), 1u);

void
STAmount::setIssue (Issue const& issue)
{
    mIssue = std::move(issue);
    mIsNative = isXRP (*this);
}

// Convert an offer into an index amount so they sort by rate.
// A taker will take the best, lowest, rate first.
// (e.g. a taker will prefer pay 1 get 3 over pay 1 get 2.
// --> offerOut: takerGets: How much the offerer is selling to the taker.
// -->  offerIn: takerPays: How much the offerer is receiving from the taker.
// <--    uRate: normalize(offerIn/offerOut)
//             A lower rate is better for the person taking the order.
//             The taker gets more for less with a lower rate.
// Zero is returned if the offer is worthless.
std::uint64_t
getRate (STAmount const& offerOut, STAmount const& offerIn)
{
    if (offerOut == zero)
        return 0;
    try
    {
        STAmount r = divide (offerIn, offerOut, noIssue());
        if (r == zero) // offer is too good
            return 0;
        assert ((r.exponent() >= -100) && (r.exponent() <= 155));
        std::uint64_t ret = r.exponent() + 100;
        return (ret << (64 - 8)) | r.mantissa();
    }
    catch (...)
    {
    }

    // overflow -- very bad offer
    return 0;
}

void STAmount::setJson (Json::Value& elem) const
{
    elem = Json::objectValue;

    if (!mIsNative)
    {
        // It is an error for currency or issuer not to be specified for valid
        // json.
        elem[jss::value]      = getText ();
        elem[jss::currency]   = to_string (mIssue.currency);
        elem[jss::issuer]     = to_string (mIssue.account);
    }
    else
    {
        elem = getText ();
    }
}

//------------------------------------------------------------------------------
//
// STBase
//
//------------------------------------------------------------------------------

std::string
STAmount::getFullText () const
{
    std::string ret;

    ret.reserve(64);
    ret = getText () + "/" + to_string (mIssue.currency);

    if (!mIsNative)
    {
        ret += "/";

        if (isXRP (*this))
            ret += "0";
        else if (mIssue.account == noAccount())
            ret += "1";
        else
            ret += to_string (mIssue.account);
    }

    return ret;
}

std::string
STAmount::getText () const
{
    // keep full internal accuracy, but make more human friendly if posible
    if (*this == zero)
        return "0";

    std::string const raw_value (std::to_string (mValue));
    std::string ret;

    if (mIsNegative)
        ret.append (1, '-');

    bool const scientific ((mOffset != 0) && ((mOffset < -25) || (mOffset > -5)));

    if (mIsNative || scientific)
    {
        ret.append (raw_value);

        if (scientific)
        {
            ret.append (1, 'e');
            ret.append (std::to_string (mOffset));
        }

        return ret;
    }

    assert (mOffset + 43 > 0);

    size_t const pad_prefix = 27;
    size_t const pad_suffix = 23;

    std::string val;
    val.reserve (raw_value.length () + pad_prefix + pad_suffix);
    val.append (pad_prefix, '0');
    val.append (raw_value);
    val.append (pad_suffix, '0');

    size_t const offset (mOffset + 43);

    auto pre_from (val.begin ());
    auto const pre_to (val.begin () + offset);

    auto const post_from (val.begin () + offset);
    auto post_to (val.end ());

    // Crop leading zeroes. Take advantage of the fact that there's always a
    // fixed amount of leading zeroes and skip them.
    if (std::distance (pre_from, pre_to) > pad_prefix)
        pre_from += pad_prefix;

    assert (post_to >= post_from);

    pre_from = std::find_if (pre_from, pre_to,
        [](char c)
        {
            return c != '0';
        });

    // Crop trailing zeroes. Take advantage of the fact that there's always a
    // fixed amount of trailing zeroes and skip them.
    if (std::distance (post_from, post_to) > pad_suffix)
        post_to -= pad_suffix;

    assert (post_to >= post_from);

    post_to = std::find_if(
        std::make_reverse_iterator (post_to),
        std::make_reverse_iterator (post_from),
        [](char c)
        {
            return c != '0';
        }).base();

    // Assemble the output:
    if (pre_from == pre_to)
        ret.append (1, '0');
    else
        ret.append(pre_from, pre_to);

    if (post_to != post_from)
    {
        ret.append (1, '.');
        ret.append (post_from, post_to);
    }

    return ret;
}

Json::Value
STAmount::getJson (int) const
{
    Json::Value elem;
    setJson (elem);
    return elem;
}

void
STAmount::add (Serializer& s) const
{
    if (mIsNative)
    {
        assert (mOffset == 0);

        if (!mIsNegative)
            s.add64 (mValue | cPosNative);
        else
            s.add64 (mValue);
    }
    else
    {
        if (*this == zero)
            s.add64 (cNotNative);
        else if (mIsNegative) // 512 = not native
            s.add64 (mValue | (static_cast<std::uint64_t>(mOffset + 512 + 97) << (64 - 10)));
        else // 256 = positive
            s.add64 (mValue | (static_cast<std::uint64_t>(mOffset + 512 + 256 + 97) << (64 - 10)));

        s.add160 (mIssue.currency);
        s.add160 (mIssue.account);
    }
}

bool
STAmount::isEquivalent (const STBase& t) const
{
    const STAmount* v = dynamic_cast<const STAmount*> (&t);
    return v && (*v == *this);
}

//------------------------------------------------------------------------------

// amount = value * [10 ^ offset]
// Representation range is 10^80 - 10^(-80).
// On the wire, high 8 bits are (offset+142), low 56 bits are value.
//
// Value is zero if amount is zero, otherwise value is 10^15 to (10^16 - 1)
// inclusive.
void STAmount::canonicalize ()
{
    if (isXRP (*this))
    {
        // native currency amounts should always have an offset of zero
        mIsNative = true;

        if (mValue == 0)
        {
            mOffset = 0;
            mIsNegative = false;
            return;
        }

        while (mOffset < 0)
        {
            mValue /= 10;
            ++mOffset;
        }

        while (mOffset > 0)
        {
            mValue *= 10;
            --mOffset;
        }

        if (mValue > cMaxNativeN)
            throw std::runtime_error ("Native currency amount out of range");

        return;
    }

    mIsNative = false;

    if (mValue == 0)
    {
        mOffset = -100;
        mIsNegative = false;
        return;
    }

    while ((mValue < cMinValue) && (mOffset > cMinOffset))
    {
        mValue *= 10;
        --mOffset;
    }

    while (mValue > cMaxValue)
    {
        if (mOffset >= cMaxOffset)
            throw std::runtime_error ("value overflow");

        mValue /= 10;
        ++mOffset;
    }

    if ((mOffset < cMinOffset) || (mValue < cMinValue))
    {
        mValue = 0;
        mIsNegative = false;
        mOffset = -100;
        return;
    }

    if (mOffset > cMaxOffset)
        throw std::runtime_error ("value overflow");

    assert ((mValue == 0) || ((mValue >= cMinValue) && (mValue <= cMaxValue)));
    assert ((mValue == 0) || ((mOffset >= cMinOffset) && (mOffset <= cMaxOffset)));
    assert ((mValue != 0) || (mOffset != -100));
}

void STAmount::set (std::int64_t v)
{
    if (v < 0)
    {
        mIsNegative = true;
        mValue = static_cast<std::uint64_t>(-v);
    }
    else
    {
        mIsNegative = false;
        mValue = static_cast<std::uint64_t>(v);
    }
}

//------------------------------------------------------------------------------

STAmount
amountFromRate (std::uint64_t uRate)
{
    return { noIssue(), uRate, -9, false };
}

STAmount
amountFromQuality (std::uint64_t rate)
{
    if (rate == 0)
        return STAmount (noIssue());

    std::uint64_t mantissa = rate & ~ (255ull << (64 - 8));
    int exponent = static_cast<int>(rate >> (64 - 8)) - 100;

    return STAmount (noIssue(), mantissa, exponent);
}

STAmount
amountFromString (Issue const& issue, std::string const& amount)
{
    static boost::regex const reNumber (
        "^"                       // the beginning of the string
        "([-+]?)"                 // (optional) + or - character
        "(0|[1-9][0-9]*)"         // a number (no leading zeroes, unless 0)
        "(\\.([0-9]+))?"          // (optional) period followed by any number
        "([eE]([+-]?)([0-9]+))?"  // (optional) E, optional + or -, any number
        "$",
        boost::regex_constants::optimize);

    boost::smatch match;

    if (!boost::regex_match (amount, match, reNumber))
        throw std::runtime_error ("Number '" + amount + "' is not valid");

    // Match fields:
    //   0 = whole input
    //   1 = sign
    //   2 = integer portion
    //   3 = whole fraction (with '.')
    //   4 = fraction (without '.')
    //   5 = whole exponent (with 'e')
    //   6 = exponent sign
    //   7 = exponent number

    // CHECKME: Why 32? Shouldn't this be 16?
    if ((match[2].length () + match[4].length ()) > 32)
        throw std::runtime_error ("Number '" + amount + "' is overlong");

    bool negative = (match[1].matched && (match[1] == "-"));

    // Can't specify XRP using fractional representation
    if (isXRP(issue) && match[3].matched)
        throw std::runtime_error ("XRP must be specified in integral drops.");

    std::uint64_t mantissa;
    int exponent;

    if (!match[4].matched) // integer only
    {
        mantissa = beast::lexicalCastThrow <std::uint64_t> (std::string (match[2]));
        exponent = 0;
    }
    else
    {
        // integer and fraction
        mantissa = beast::lexicalCastThrow <std::uint64_t> (match[2] + match[4]);
        exponent = -(match[4].length ());
    }

    if (match[5].matched)
    {
        // we have an exponent
        if (match[6].matched && (match[6] == "-"))
            exponent -= beast::lexicalCastThrow <int> (std::string (match[7]));
        else
            exponent += beast::lexicalCastThrow <int> (std::string (match[7]));
    }

    return { issue, mantissa, exponent, negative };
}

STAmount
amountFromJson (SField const& name, Json::Value const& v)
{
    STAmount::mantissa_type mantissa = 0;
    STAmount::exponent_type exponent = 0;
    bool negative = false;
    Issue issue;

    Json::Value value;
    Json::Value currency;
    Json::Value issuer;

    if (v.isObject ())
    {
        WriteLog (lsTRACE, STAmount) <<
            "value='" << v[jss::value].asString () <<
            "', currency='" << v["currency"].asString () <<
            "', issuer='" << v["issuer"].asString () <<
            "')";

        value       = v[jss::value];
        currency    = v[jss::currency];
        issuer      = v[jss::issuer];
    }
    else if (v.isArray ())
    {
        value = v.get (Json::UInt (0), 0);
        currency = v.get (Json::UInt (1), Json::nullValue);
        issuer = v.get (Json::UInt (2), Json::nullValue);
    }
    else if (v.isString ())
    {
        std::string val = v.asString ();
        std::vector<std::string> elements;
        boost::split (elements, val, boost::is_any_of ("\t\n\r ,/"));

        if (elements.size () > 3)
            throw std::runtime_error ("invalid amount string");

        value = elements[0];

        if (elements.size () > 1)
            currency = elements[1];

        if (elements.size () > 2)
            issuer = elements[2];
    }
    else
    {
        value = v;
    }

    bool const native = ! currency.isString () ||
        currency.asString ().empty () ||
        (currency.asString () == systemCurrencyCode());

    if (native)
    {
        if (v.isObject ())
            throw std::runtime_error ("XRP may not be specified as an object");
        issue = xrpIssue ();
    }
    else
    {
        // non-XRP
        if (! to_currency (issue.currency, currency.asString ()))
            throw std::runtime_error ("invalid currency");

        if (! issuer.isString ()
                || !to_issuer (issue.account, issuer.asString ()))
            throw std::runtime_error ("invalid issuer");

        if (isXRP (issue.currency))
            throw std::runtime_error ("invalid issuer");
    }

    if (value.isInt ())
    {
        if (value.asInt () >= 0)
        {
            mantissa = value.asInt ();
        }
        else
        {
            mantissa = -value.asInt ();
            negative = true;
        }
    }
    else if (value.isUInt ())
    {
        mantissa = v.asUInt ();
    }
    else if (value.isString ())
    {
        auto const ret = amountFromString (issue, value.asString ());

        mantissa = ret.mantissa ();
        exponent = ret.exponent ();
        negative = ret.negative ();
    }
    else
    {
        throw std::runtime_error ("invalid amount type");
    }

    return { name, issue, mantissa, exponent, native, negative };
}

bool
amountFromJsonNoThrow (STAmount& result, Json::Value const& jvSource)
{
    try
    {
        result = amountFromJson (sfGeneric, jvSource);
        return true;
    }
    catch (const std::exception& e)
    {
        WriteLog (lsDEBUG, STAmount) <<
            "amountFromJsonNoThrow: caught: " << e.what ();
    }
    return false;
}

//------------------------------------------------------------------------------
//
// Operators
//
//------------------------------------------------------------------------------

bool
operator== (STAmount const& lhs, STAmount const& rhs)
{
    return areComparable (lhs, rhs) &&
        lhs.negative() == rhs.negative() &&
        lhs.exponent() == rhs.exponent() &&
        lhs.mantissa() == rhs.mantissa();
}

bool
operator< (STAmount const& lhs, STAmount const& rhs)
{
    if (!areComparable (lhs, rhs))
        throw std::runtime_error ("Can't compare amounts that are't comparable!");

    if (lhs.negative() != rhs.negative())
        return lhs.negative();

    if (lhs.mantissa() == 0)
    {
        if (rhs.negative())
            return false;
        return rhs.mantissa() != 0;
    }

    // We know that lhs is non-zero and both sides have the same sign. Since
    // rhs is zero (and thus not negative), lhs must, therefore, be strictly
    // greater than zero. So if rhs is zero, the comparison must be false.
    if (rhs.mantissa() == 0) return false;

    if (lhs.exponent() > rhs.exponent()) return lhs.negative();
    if (lhs.exponent() < rhs.exponent()) return ! lhs.negative();
    if (lhs.mantissa() > rhs.mantissa()) return lhs.negative();
    if (lhs.mantissa() < rhs.mantissa()) return ! lhs.negative();

    return false;
}

STAmount
operator- (STAmount const& value)
{
    if (value.mantissa() == 0)
        return value;
    return STAmount (value.getFName (),
        value.issue(), value.mantissa(), value.exponent(),
            value.native(), ! value.negative(), STAmount::unchecked{});
}

//------------------------------------------------------------------------------
//
// Arithmetic
//
//------------------------------------------------------------------------------
STAmount
divide (STAmount const& num, STAmount const& den, Issue const& issue)
{
    if (den == zero)
        throw std::runtime_error ("division by zero");

    if (num == zero)
        return {issue};

    std::uint64_t numVal = num.mantissa();
    std::uint64_t denVal = den.mantissa();
    int numOffset = num.exponent();
    int denOffset = den.exponent();

    if (num.native())
    {
        while (numVal < STAmount::cMinValue)
        {
            // Need to bring into range
            numVal *= 10;
            --numOffset;
        }
    }

    if (den.native())
    {
        while (denVal < STAmount::cMinValue)
        {
            denVal *= 10;
            --denOffset;
        }
    }

    // Compute (numerator * 10^17) / denominator
    CBigNum v;

    if ((BN_add_word64 (&v, numVal) != 1) ||
            (BN_mul_word64 (&v, tenTo17) != 1) ||
            (BN_div_word64 (&v, denVal) == ((std::uint64_t) - 1)))
    {
        throw std::runtime_error ("internal bn error");
    }

    // 10^16 <= quotient <= 10^18
    assert (BN_num_bytes (&v) <= 64);

    // TODO(tom): where do 5 and 17 come from?
    return STAmount (issue, v.getuint64 () + 5,
                     numOffset - denOffset - 17,
                     num.negative() != den.negative());
}

STAmount
multiply (STAmount const& v1, STAmount const& v2, Issue const& issue)
{
    if (v1 == zero || v2 == zero)
        return STAmount (issue);

    if (v1.native() && v2.native() && isXRP (issue))
    {
        std::uint64_t const minV = getSNValue (v1) < getSNValue (v2)
                ? getSNValue (v1) : getSNValue (v2);
        std::uint64_t const maxV = getSNValue (v1) < getSNValue (v2)
                ? getSNValue (v2) : getSNValue (v1);

        if (minV > 3000000000ull) // sqrt(cMaxNative)
            throw std::runtime_error ("Native value overflow");

        if (((maxV >> 32) * minV) > 2095475792ull) // cMaxNative / 2^32
            throw std::runtime_error ("Native value overflow");

        return STAmount (v1.getFName (), minV * maxV);
    }

    std::uint64_t value1 = v1.mantissa();
    std::uint64_t value2 = v2.mantissa();
    int offset1 = v1.exponent();
    int offset2 = v2.exponent();

    if (v1.native())
    {
        while (value1 < STAmount::cMinValue)
        {
            value1 *= 10;
            --offset1;
        }
    }

    if (v2.native())
    {
        while (value2 < STAmount::cMinValue)
        {
            value2 *= 10;
            --offset2;
        }
    }

    // Compute (numerator * denominator) / 10^14 with rounding
    // 10^16 <= result <= 10^18
    CBigNum v;

    if ((BN_add_word64 (&v, value1) != 1) ||
            (BN_mul_word64 (&v, value2) != 1) ||
            (BN_div_word64 (&v, tenTo14) == ((std::uint64_t) - 1)))
    {
        throw std::runtime_error ("internal bn error");
    }

    // 10^16 <= product <= 10^18
    assert (BN_num_bytes (&v) <= 64);

    // TODO(tom): where do 7 and 14 come from?
    return STAmount (issue, v.getuint64 () + 7,
        offset1 + offset2 + 14, v1.negative() != v2.negative());
}

static
void
canonicalizeRound (bool native, std::uint64_t& value, int& offset, bool roundUp)
{
    if (!roundUp) // canonicalize already rounds down
        return;

    WriteLog (lsTRACE, STAmount)
        << "canonicalizeRound< " << value << ":" << offset;

    if (native)
    {
        if (offset < 0)
        {
            int loops = 0;

            while (offset < -1)
            {
                value /= 10;
                ++offset;
                ++loops;
            }

            value += (loops >= 2) ? 9 : 10; // add before last divide
            value /= 10;
            ++offset;
        }
    }
    else if (value > STAmount::cMaxValue)
    {
        while (value > (10 * STAmount::cMaxValue))
        {
            value /= 10;
            ++offset;
        }

        value += 9;     // add before last divide
        value /= 10;
        ++offset;
    }

    WriteLog (lsTRACE, STAmount)
        << "canonicalizeRound> " << value << ":" << offset;
}

STAmount
mulRound (STAmount const& v1, STAmount const& v2,
    Issue const& issue, bool roundUp)
{
    if (v1 == zero || v2 == zero)
        return {issue};

    if (v1.native() && v2.native() && isXRP (issue))
    {
        std::uint64_t minV = (getSNValue (v1) < getSNValue (v2)) ?
                getSNValue (v1) : getSNValue (v2);
        std::uint64_t maxV = (getSNValue (v1) < getSNValue (v2)) ?
                getSNValue (v2) : getSNValue (v1);

        if (minV > 3000000000ull) // sqrt(cMaxNative)
            throw std::runtime_error ("Native value overflow");

        if (((maxV >> 32) * minV) > 2095475792ull) // cMaxNative / 2^32
            throw std::runtime_error ("Native value overflow");

        return STAmount (v1.getFName (), minV * maxV);
    }

    std::uint64_t value1 = v1.mantissa(), value2 = v2.mantissa();
    int offset1 = v1.exponent(), offset2 = v2.exponent();

    if (v1.native())
    {
        while (value1 < STAmount::cMinValue)
        {
            value1 *= 10;
            --offset1;
        }
    }

    if (v2.native())
    {
        while (value2 < STAmount::cMinValue)
        {
            value2 *= 10;
            --offset2;
        }
    }

    bool resultNegative = v1.negative() != v2.negative();
    // Compute (numerator * denominator) / 10^14 with rounding
    // 10^16 <= result <= 10^18
    CBigNum v;

    if ((BN_add_word64 (&v, value1) != 1) || (BN_mul_word64 (&v, value2) != 1))
        throw std::runtime_error ("internal bn error");

    if (resultNegative != roundUp) // rounding down is automatic when we divide
        BN_add_word64 (&v, tenTo14m1);

    if  (BN_div_word64 (&v, tenTo14) == ((std::uint64_t) - 1))
        throw std::runtime_error ("internal bn error");

    // 10^16 <= product <= 10^18
    assert (BN_num_bytes (&v) <= 64);

    std::uint64_t amount = v.getuint64 ();
    int offset = offset1 + offset2 + 14;
    canonicalizeRound (
        isXRP (issue), amount, offset, resultNegative != roundUp);
    return STAmount (issue, amount, offset, resultNegative);
}

STAmount
divRound (STAmount const& num, STAmount const& den,
    Issue const& issue, bool roundUp)
{
    if (den == zero)
        throw std::runtime_error ("division by zero");

    if (num == zero)
        return {issue};

    std::uint64_t numVal = num.mantissa(), denVal = den.mantissa();
    int numOffset = num.exponent(), denOffset = den.exponent();

    if (num.native())
        while (numVal < STAmount::cMinValue)
        {
            // Need to bring into range
            numVal *= 10;
            --numOffset;
        }

    if (den.native())
        while (denVal < STAmount::cMinValue)
        {
            denVal *= 10;
            --denOffset;
        }

    bool resultNegative = num.negative() != den.negative();
    // Compute (numerator * 10^17) / denominator
    CBigNum v;

    if ((BN_add_word64 (&v, numVal) != 1) || (BN_mul_word64 (&v, tenTo17) != 1))
        throw std::runtime_error ("internal bn error");

    if (resultNegative != roundUp) // Rounding down is automatic when we divide
        BN_add_word64 (&v, denVal - 1);

    if (BN_div_word64 (&v, denVal) == ((std::uint64_t) - 1))
        throw std::runtime_error ("internal bn error");

    // 10^16 <= quotient <= 10^18
    assert (BN_num_bytes (&v) <= 64);

    std::uint64_t amount = v.getuint64 ();
    int offset = numOffset - denOffset - 17;
    canonicalizeRound (
        isXRP (issue), amount, offset, resultNegative != roundUp);
    return STAmount (issue, amount, offset, resultNegative);
}

// compute (value)*(mul)/(div) - avoid overflow but keep precision
std::uint64_t
mulDiv(std::uint64_t value, std::uint64_t mul, std::uint64_t div)
{
    lowestTerms(value, div);
    lowestTerms(mul, div);

    if (value < mul)
        std::swap(value, mul);
    const auto max = std::numeric_limits<std::uint64_t>::max();
    if (value > max / mul)
    {
        value /= div;
        if (value > max / mul)
            throw std::overflow_error("mulDiv");
        return value * mul;
    }
    return value * mul / div;
}

} // ripple