// Copyright (c) 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 <node/mining_args.h>

#include <common/args.h>
#include <common/messages.h>
#include <consensus/amount.h>
#include <consensus/consensus.h>
#include <node/mining_types.h>
#include <policy/feerate.h>
#include <policy/policy.h>
#include <tinyformat.h>
#include <util/moneystr.h>
#include <util/result.h>
#include <util/translation.h>

#include <cstdint>
#include <optional>
#include <string>
#include <utility>

using common::AmountErrMsg;
using util::Error;
using util::Result;

namespace node {

Result<void> CheckMiningOptions(BlockCreateOptions options, bool use_argnames)
{
    options = FlattenMiningOptions(std::move(options));
    if (*options.block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
        return Error{Untranslated(strprintf("%s (%d) is lower than minimum safety value of (%d)",
                                            use_argnames ? "-blockreservedweight" : "block_reserved_weight",
                                            *options.block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT))};
    }
    if (*options.block_reserved_weight > MAX_BLOCK_WEIGHT) {
        return Error{Untranslated(strprintf("%s (%d) exceeds consensus maximum block weight (%d)",
                                            use_argnames ? "-blockreservedweight" : "block_reserved_weight",
                                            *options.block_reserved_weight, MAX_BLOCK_WEIGHT))};
    }
    if (*options.block_max_weight > MAX_BLOCK_WEIGHT) {
        return Error{Untranslated(strprintf("%s (%d) exceeds consensus maximum block weight (%d)",
                                            use_argnames ? "-blockmaxweight" : "block_max_weight",
                                            *options.block_max_weight, MAX_BLOCK_WEIGHT))};
    }
    if (*options.block_reserved_weight > *options.block_max_weight) {
        return Error{Untranslated(strprintf("%s (%d) exceeds %s (%d)",
                                            use_argnames ? "-blockreservedweight" : "block_reserved_weight",
                                            *options.block_reserved_weight,
                                            use_argnames ? "-blockmaxweight" : "block_max_weight",
                                            *options.block_max_weight))};
    }
    if (options.coinbase_output_max_additional_sigops > MAX_BLOCK_SIGOPS_COST) {
        return Error{Untranslated(strprintf("%s (%zu) exceeds consensus maximum block sigops cost (%d)",
                                            "coinbase_output_max_additional_sigops",
                                            options.coinbase_output_max_additional_sigops, MAX_BLOCK_SIGOPS_COST))};
    }
    return {};
}

Result<BlockCreateOptions> ReadMiningArgs(const ArgsManager& args)
{
    BlockCreateOptions options;
    if (const auto arg{args.GetArg("-blockmintxfee")}) {
        std::optional<CAmount> block_min_tx_fee{ParseMoney(*arg)};
        if (!block_min_tx_fee) return Error{AmountErrMsg("blockmintxfee", *arg)};
        options.block_min_fee_rate = CFeeRate{*block_min_tx_fee};
    }

    if (const auto arg{args.GetBoolArg("-printpriority")}) options.print_modified_fee = *arg;

    options.block_reserved_weight = args.GetArg<uint64_t>("-blockreservedweight");
    options.block_max_weight = args.GetArg<uint64_t>("-blockmaxweight");

    if (auto result{CheckMiningOptions(options, /*use_argnames=*/true)}; !result) return Error{util::ErrorString(result)};
    return options;
}

BlockCreateOptions FlattenMiningOptions(BlockCreateOptions options)
{
    if (!options.block_min_fee_rate) options.block_min_fee_rate = CFeeRate{DEFAULT_BLOCK_MIN_TX_FEE};
    if (!options.print_modified_fee) options.print_modified_fee = DEFAULT_PRINT_MODIFIED_FEE;
    if (!options.block_reserved_weight) options.block_reserved_weight = DEFAULT_BLOCK_RESERVED_WEIGHT;
    if (!options.block_max_weight) options.block_max_weight = DEFAULT_BLOCK_MAX_WEIGHT;
    return options;
}

BlockCreateOptions MergeMiningOptions(BlockCreateOptions x, const BlockCreateOptions& y)
{
    if (!x.block_min_fee_rate) x.block_min_fee_rate = y.block_min_fee_rate;
    if (!x.print_modified_fee) x.print_modified_fee = y.print_modified_fee;
    if (!x.block_reserved_weight) x.block_reserved_weight = y.block_reserved_weight;
    if (!x.block_max_weight) x.block_max_weight = y.block_max_weight;
    return x;
}

} // namespace node