// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-present The Bitcoin Core developers

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

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

#include <protocol.h>

#include <common/system.h>

CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn, const char* msg_type, unsigned int nMessageSizeIn)

    : pchMessageStart{pchMessageStartIn}

{

    // Copy the message type name

    size_t i = 0;

    for (; i < MESSAGE_TYPE_SIZE && msg_type[i] != 0; ++i) m_msg_type[i] = msg_type[i];

    assert(msg_type[i] == 0); // Assert that the message type name passed in is not longer than MESSAGE_TYPE_SIZE

    nMessageSize = nMessageSizeIn;

}

std::string CMessageHeader::GetMessageType() const

{

    return std::string(m_msg_type, m_msg_type + strnlen(m_msg_type, MESSAGE_TYPE_SIZE));

}

bool CMessageHeader::IsMessageTypeValid() const

{

    // Check the message type string for errors

    for (const char* p1 = m_msg_type; p1 < m_msg_type + MESSAGE_TYPE_SIZE; ++p1) {

        if (*p1 == 0) {

            // Must be all zeros after the first zero

            for (; p1 < m_msg_type + MESSAGE_TYPE_SIZE; ++p1) {

                if (*p1 != 0) {

                    return false;

                }

            }

        } else if (*p1 < ' ' || *p1 > 0x7E) {

            return false;

        }

    }

    return true;

}

CInv::CInv()

{

    type = 0;

    hash.SetNull();

}

CInv::CInv(uint32_t typeIn, const uint256& hashIn) : type(typeIn), hash(hashIn) {}

bool operator<(const CInv& a, const CInv& b)

{

    return (a.type < b.type || (a.type == b.type && a.hash < b.hash));

}

std::string CInv::GetMessageType() const

{

    std::string cmd;

    if (type & MSG_WITNESS_FLAG)

        cmd.append("witness-");

    int masked = type & MSG_TYPE_MASK;

    switch (masked)

    {

    case MSG_TX:             return cmd.append(NetMsgType::TX);

    // WTX is not a message type, just an inv type

    case MSG_WTX:            return cmd.append("wtx");

    case MSG_BLOCK:          return cmd.append(NetMsgType::BLOCK);

    case MSG_FILTERED_BLOCK: return cmd.append(NetMsgType::MERKLEBLOCK);

    case MSG_CMPCT_BLOCK:    return cmd.append(NetMsgType::CMPCTBLOCK);

    default:

        throw std::out_of_range(strprintf("CInv::GetMessageType(): type=%d unknown type", type));

    }

}

std::string CInv::ToString() const

{

    try {

        return strprintf("%s %s", GetMessageType(), hash.ToString());

    } catch(const std::out_of_range &) {

        return strprintf("0x%08x %s", type, hash.ToString());

    }

}

/**

 * Convert a service flag (NODE_*) to a human readable string.

 * It supports unknown service flags which will be returned as "UNKNOWN[...]".

 * @param[in] bit the service flag is calculated as (1 << bit)

 */

static std::string serviceFlagToStr(size_t bit)

{

    const uint64_t service_flag = 1ULL << bit;

    switch ((ServiceFlags)service_flag) {

    case NODE_NONE: abort();  // impossible

    case NODE_NETWORK:         return "NETWORK";

    case NODE_BLOOM:           return "BLOOM";

    case NODE_WITNESS:         return "WITNESS";

    case NODE_COMPACT_FILTERS: return "COMPACT_FILTERS";

    case NODE_NETWORK_LIMITED: return "NETWORK_LIMITED";

    case NODE_P2P_V2:          return "P2P_V2";

    // Not using default, so we get warned when a case is missing

    }

    return strprintf("UNKNOWN[2^%u]", bit);

}

std::vector<std::string> serviceFlagsToStr(uint64_t flags)

{

    std::vector<std::string> str_flags;

    for (size_t i = 0; i < sizeof(flags) * 8; ++i) {

        if (flags & (1ULL << i)) {

            str_flags.emplace_back(serviceFlagToStr(i));

        }

    }

    return str_flags;

}

GenTxid ToGenTxid(const CInv& inv)

{

    assert(inv.IsGenTxMsg());

    return inv.IsMsgWtx() ? GenTxid{Wtxid::FromUint256(inv.hash)} : GenTxid{Txid::FromUint256(inv.hash)};

}