// Copyright 2014 BitPay Inc.

// Copyright 2015 Bitcoin Core Developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or https://opensource.org/licenses/mit-license.php.

#include <univalue.h>

#include <iomanip>

#include <map>

#include <memory>

#include <sstream>

#include <string>

#include <utility>

#include <vector>

const UniValue NullUniValue;

void UniValue::clear()

{

    typ = VNULL;

    val.clear();

    keys.clear();

    values.clear();

}

void UniValue::setNull()

{

    clear();

}

void UniValue::setBool(bool val_)

{

    clear();

    typ = VBOOL;

    if (val_)

  Branch (35:9): [True: 3.44M, False: 987k]

        val = "1";

}

static bool validNumStr(const std::string& s)

{

    std::string tokenVal;

    unsigned int consumed;

    enum jtokentype tt = getJsonToken(tokenVal, consumed, s.data(), s.data() + s.size());

    return (tt == JTOK_NUMBER);

}

void UniValue::setNumStr(std::string str)

{

    if (!validNumStr(str)) {

  Branch (49:9): [True: 0, False: 980k]

        throw std::runtime_error{"The string '" + str + "' is not a valid JSON number"};

    }

    clear();

    typ = VNUM;

    val = std::move(str);

}

void UniValue::setInt(uint64_t val_)

{

    std::ostringstream oss;

    oss << val_;

    return setNumStr(oss.str());

}

void UniValue::setInt(int64_t val_)

{

    std::ostringstream oss;

    oss << val_;

    return setNumStr(oss.str());

}

void UniValue::setFloat(double val_)

{

    std::ostringstream oss;

    oss << std::setprecision(16) << val_;

    return setNumStr(oss.str());

}

void UniValue::setStr(std::string str)

{

    clear();

    typ = VSTR;

    val = std::move(str);

}

void UniValue::setArray()

{

    clear();

    typ = VARR;

}

void UniValue::setObject()

{

    clear();

    typ = VOBJ;

}

void UniValue::push_back(UniValue val)

{

    checkType(VARR);

    values.push_back(std::move(val));

}

void UniValue::push_backV(const std::vector<UniValue>& vec)

{

    checkType(VARR);

    values.insert(values.end(), vec.begin(), vec.end());

}

void UniValue::pushKVEnd(std::string key, UniValue val)

{

    checkType(VOBJ);

    keys.push_back(std::move(key));

    values.push_back(std::move(val));

}

void UniValue::pushKV(std::string key, UniValue val)

{

    checkType(VOBJ);

    size_t idx;

    if (findKey(key, idx))

  Branch (131:9): [True: 0, False: 7.61M]

        values[idx] = std::move(val);

    else

        pushKVEnd(std::move(key), std::move(val));

}

void UniValue::pushKVs(UniValue obj)

{

    checkType(VOBJ);

    obj.checkType(VOBJ);

    for (size_t i = 0; i < obj.keys.size(); i++)

  Branch (142:24): [True: 0, False: 0]

        pushKVEnd(std::move(obj.keys.at(i)), std::move(obj.values.at(i)));

}

void UniValue::getObjMap(std::map<std::string,UniValue>& kv) const

{

    if (typ != VOBJ)

  Branch (148:9): [True: 0, False: 0]

        return;

    kv.clear();

    for (size_t i = 0; i < keys.size(); i++)

  Branch (152:24): [True: 0, False: 0]

        kv[keys[i]] = values[i];

}

bool UniValue::findKey(const std::string& key, size_t& retIdx) const

{

    for (size_t i = 0; i < keys.size(); i++) {

  Branch (158:24): [True: 15.6M, False: 7.61M]

        if (keys[i] == key) {

  Branch (159:13): [True: 2.35M, False: 13.2M]

            retIdx = i;

            return true;

        }

    }

    return false;

}

bool UniValue::checkObject(const std::map<std::string,UniValue::VType>& t) const

{

    if (typ != VOBJ) {

  Branch (170:9): [True: 0, False: 0]

        return false;

    }

    for (const auto& object: t) {

  Branch (174:28): [True: 0, False: 0]

        size_t idx = 0;

        if (!findKey(object.first, idx)) {

  Branch (176:13): [True: 0, False: 0]

            return false;

        }

        if (values.at(idx).getType() != object.second) {

  Branch (180:13): [True: 0, False: 0]

            return false;

        }

    }

    return true;

}

const UniValue& UniValue::operator[](const std::string& key) const

{

    if (typ != VOBJ)

  Branch (190:9): [True: 0, False: 0]

        return NullUniValue;

    size_t index = 0;

    if (!findKey(key, index))

  Branch (194:9): [True: 0, False: 0]

        return NullUniValue;

    return values.at(index);

}

const UniValue& UniValue::operator[](size_t index) const

{

    if (typ != VOBJ && typ != VARR)

  Branch (202:9): [True: 5.10M, False: 0]
  Branch (202:24): [True: 0, False: 5.10M]

        return NullUniValue;

    if (index >= values.size())

  Branch (204:9): [True: 288k, False: 4.81M]

        return NullUniValue;

    return values.at(index);

}

void UniValue::checkType(const VType& expected) const

{

    if (typ != expected) {

  Branch (212:9): [True: 0, False: 27.8M]

        throw type_error{"JSON value of type " + std::string{uvTypeName(typ)} + " is not of expected type " +

                                 std::string{uvTypeName(expected)}};

    }

}

const char *uvTypeName(UniValue::VType t)

{

    switch (t) {

  Branch (220:13): [True: 0, False: 0]

    case UniValue::VNULL: return "null";

  Branch (221:5): [True: 0, False: 0]

    case UniValue::VBOOL: return "bool";

  Branch (222:5): [True: 0, False: 0]

    case UniValue::VOBJ: return "object";

  Branch (223:5): [True: 0, False: 0]

    case UniValue::VARR: return "array";

  Branch (224:5): [True: 0, False: 0]

    case UniValue::VSTR: return "string";

  Branch (225:5): [True: 0, False: 0]

    case UniValue::VNUM: return "number";

  Branch (226:5): [True: 0, False: 0]

    }

    // not reached

    return nullptr;

}

const UniValue& UniValue::find_value(std::string_view key) const

{

    for (unsigned int i = 0; i < keys.size(); ++i) {

  Branch (235:30): [True: 23.5M, False: 0]

        if (keys[i] == key) {

  Branch (236:13): [True: 9.43M, False: 14.1M]

            return values.at(i);

        }

    }

    return NullUniValue;

}