// Copyright (c) 2019-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 <test/util/mining.h>

#include <addresstype.h>

#include <chain.h>

#include <chainparams.h>

#include <consensus/merkle.h>

#include <consensus/validation.h>

#include <interfaces/mining.h>

#include <key_io.h>

#include <node/context.h>

#include <pow.h>

#include <primitives/block.h>

#include <primitives/transaction.h>

#include <script/script.h>

#include <sync.h>

#include <test/util/script.h>

#include <uint256.h>

#include <util/check.h>

#include <validation.h>

#include <validationinterface.h>

#include <versionbits.h>

#include <cstdint>

#include <memory>

#include <optional>

#include <utility>

using node::NodeContext;

COutPoint generatetoaddress(const NodeContext& node, const std::string& address)

{

    const auto dest = DecodeDestination(address);

    assert(IsValidDestination(dest));

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

    return MineBlock(node, {

        .coinbase_output_script = GetScriptForDestination(dest),

    });

}

std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const CChainParams& params)

{

    std::vector<std::shared_ptr<CBlock>> ret{total_height};

    auto time{params.GenesisBlock().nTime};

    // NOTE: here `height` does not correspond to the block height but the block height - 1.

    for (size_t height{0}; height < total_height; ++height) {

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

        CBlock& block{*(ret.at(height) = std::make_shared<CBlock>())};

        CMutableTransaction coinbase_tx;

        coinbase_tx.nLockTime = static_cast<uint32_t>(height);

        coinbase_tx.vin.resize(1);

        coinbase_tx.vin[0].prevout.SetNull();

        coinbase_tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL; // Make sure timelock is enforced.

        coinbase_tx.vout.resize(1);

        coinbase_tx.vout[0].scriptPubKey = P2WSH_OP_TRUE;

        coinbase_tx.vout[0].nValue = GetBlockSubsidy(height + 1, params.GetConsensus());

        // Always include OP_0 as a dummy extraNonce.

        coinbase_tx.vin[0].scriptSig = CScript() << (height + 1) << OP_0;

        block.vtx = {MakeTransactionRef(std::move(coinbase_tx))};

        block.nVersion = VERSIONBITS_LAST_OLD_BLOCK_VERSION;

        block.hashPrevBlock = (height >= 1 ? *ret.at(height - 1) : params.GenesisBlock()).GetHash();

  Branch (64:32): [True: 0, False: 0]

        block.hashMerkleRoot = BlockMerkleRoot(block);

        block.nTime = ++time;

        block.nBits = params.GenesisBlock().nBits;

        block.nNonce = 0;

        while (!CheckProofOfWork(block.GetHash(), block.nBits, params.GetConsensus())) {

  Branch (70:16): [True: 0, False: 0]

            ++block.nNonce;

            assert(block.nNonce);

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

        }

    }

    return ret;

}

bool BuildChain(const NodeContext& node, const CBlockIndex* pindex,

    const CScript& coinbase_script_pub_key,

    size_t length,

    std::vector<std::shared_ptr<CBlock>>& chain)

{

    auto mining{interfaces::MakeMining(node)};

    const Consensus::Params& consensus{Assert(node.chainman)->GetConsensus()};

    chain.resize(length);

    for (auto& chain_block : chain) {

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

        auto block_template{mining->createNewBlock({

            .use_mempool = false,

            .coinbase_output_script = coinbase_script_pub_key,

        }, /*cooldown=*/false)};

        CBlock block{Assert(block_template)->getBlock()};

        // The template is built on the active tip, so repoint it at pindex and

        // redo the fields that depend on the predecessor.

        block.hashPrevBlock = pindex->GetBlockHash();

        block.nTime = pindex->nTime + 1;

        {

            CMutableTransaction tx_coinbase{*block.vtx.at(0)};

            tx_coinbase.nLockTime = static_cast<uint32_t>(pindex->nHeight);

            tx_coinbase.vin.at(0).scriptSig = CScript{} << pindex->nHeight + 1;

            block.vtx.at(0) = MakeTransactionRef(std::move(tx_coinbase));

            block.hashMerkleRoot = BlockMerkleRoot(block);

        }

        while (!CheckProofOfWork(block.GetHash(), block.nBits, consensus)) ++block.nNonce;

  Branch (106:16): [True: 0, False: 0]

        chain_block = std::make_shared<CBlock>(std::move(block));

        BlockValidationState state;

        if (!Assert(node.chainman)->ProcessNewBlockHeaders({{*chain_block}}, true, state, &pindex)) {

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

            return false;

        }

    }

    return true;

}

COutPoint MineBlock(const NodeContext& node, const node::BlockCreateOptions& assembler_options)

{

    auto block = PrepareBlock(node, assembler_options);

    auto valid = MineBlock(node, block);

    assert(!valid.IsNull());

  Branch (123:5): [True: 334k, False: 0]

    return valid;

}

struct BlockValidationStateCatcher : public CValidationInterface {

    const uint256 m_hash;

    std::optional<BlockValidationState> m_state;

    BlockValidationStateCatcher(const uint256& hash)

        : m_hash{hash},

          m_state{} {}

protected:

    void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& state) override

    {

        if (block->GetHash() != m_hash) return;

  Branch (138:13): [True: 0, False: 519k]

        m_state = state;

    }

};

COutPoint MineBlock(const NodeContext& node, std::shared_ptr<CBlock>& block)

{

    while (!CheckProofOfWork(block->GetHash(), block->nBits, Params().GetConsensus())) {

  Branch (145:12): [True: 457k, False: 519k]

        ++block->nNonce;

        assert(block->nNonce);

  Branch (147:9): [True: 457k, False: 0]

    }

    return ProcessBlock(node, block);

}

COutPoint ProcessBlock(const NodeContext& node, const std::shared_ptr<CBlock>& block)

{

    auto& chainman{*Assert(node.chainman)};

    const auto old_height = WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight());

    bool new_block;

    BlockValidationStateCatcher bvsc{block->GetHash()};

    node.validation_signals->RegisterValidationInterface(&bvsc);

    const bool processed{chainman.ProcessNewBlock(block, true, true, &new_block)};

    const bool duplicate{!new_block && processed};

  Branch (161:26): [True: 32.2k, False: 487k]
  Branch (161:40): [True: 0, False: 32.2k]

    assert(!duplicate);

  Branch (162:5): [True: 519k, False: 0]

    node.validation_signals->UnregisterValidationInterface(&bvsc);

    node.validation_signals->SyncWithValidationInterfaceQueue();

    const bool was_valid{bvsc.m_state && bvsc.m_state->IsValid()};

  Branch (165:26): [True: 519k, False: 0]
  Branch (165:42): [True: 474k, False: 45.6k]

    assert(old_height + was_valid == WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight()));

  Branch (166:5): [True: 519k, False: 0]

    if (was_valid) return {block->vtx[0]->GetHash(), 0};

  Branch (168:9): [True: 474k, False: 45.6k]

    return {};

}

std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node,

                                     const node::BlockCreateOptions& assembler_options)

{

    auto mining = interfaces::MakeMining(node);

    auto block_template = mining->createNewBlock(assembler_options, /*cooldown=*/false);

    auto block = std::make_shared<CBlock>(Assert(block_template)->getBlock());

    LOCK(cs_main);

    block->nTime = Assert(node.chainman)->ActiveChain().Tip()->GetMedianTimePast() + 1;

    block->hashMerkleRoot = BlockMerkleRoot(*block);

    return block;

}