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

#include <chainparamsbase.h>

#include <common/args.h>

#include <consensus/params.h>

#include <deploymentinfo.h>

#include <tinyformat.h>

#include <util/chaintype.h>

#include <util/log.h>

#include <util/strencodings.h>

#include <util/string.h>

#include <cassert>

#include <cstdint>

#include <limits>

#include <stdexcept>

#include <vector>

using util::SplitString;

static void HandleDeploymentArgs(const ArgsManager& args, CChainParams::DeploymentOptions& options)

{

    for (const std::string& arg : args.GetArgs("-testactivationheight")) {

        const auto found{arg.find('@')};

        if (found == std::string::npos) {

            throw std::runtime_error(strprintf("Invalid format (%s) for -testactivationheight=name@height.", arg));

        }

        const auto value{arg.substr(found + 1)};

        const auto height{ToIntegral<int32_t>(value)};

        if (!height || *height < 0 || *height >= std::numeric_limits<int>::max()) {

            throw std::runtime_error(strprintf("Invalid height value (%s) for -testactivationheight=name@height.", arg));

        }

        const auto deployment_name{arg.substr(0, found)};

        if (const auto buried_deployment = GetBuriedDeployment(deployment_name)) {

            options.activation_heights[*buried_deployment] = *height;

        } else {

            throw std::runtime_error(strprintf("Invalid name (%s) for -testactivationheight=name@height.", arg));

        }

    }

    for (const std::string& strDeployment : args.GetArgs("-vbparams")) {

        std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');

        if (vDeploymentParams.size() < 3 || 4 < vDeploymentParams.size()) {

            throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height]");

        }

        CChainParams::VersionBitsParameters vbparams{};

        const auto start_time{ToIntegral<int64_t>(vDeploymentParams[1])};

        if (!start_time) {

            throw std::runtime_error(strprintf("Invalid nStartTime (%s)", vDeploymentParams[1]));

        }

        vbparams.start_time = *start_time;

        const auto timeout{ToIntegral<int64_t>(vDeploymentParams[2])};

        if (!timeout) {

            throw std::runtime_error(strprintf("Invalid nTimeout (%s)", vDeploymentParams[2]));

        }

        vbparams.timeout = *timeout;

        if (vDeploymentParams.size() >= 4) {

            const auto min_activation_height{ToIntegral<int64_t>(vDeploymentParams[3])};

            if (!min_activation_height) {

                throw std::runtime_error(strprintf("Invalid min_activation_height (%s)", vDeploymentParams[3]));

            }

            vbparams.min_activation_height = *min_activation_height;

        } else {

            vbparams.min_activation_height = 0;

        }

        bool found = false;

        for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {

            if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {

                options.version_bits_parameters[Consensus::DeploymentPos(j)] = vbparams;

                found = true;

                LogInfo("Setting version bits activation parameters for %s to start=%ld, timeout=%ld, min_activation_height=%d",

                        vDeploymentParams[0], vbparams.start_time, vbparams.timeout, vbparams.min_activation_height);

                break;

            }

        }

        if (!found) {

            throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));

        }

    }

}

void ReadMainNetArgs(const ArgsManager& args, CChainParams::MainNetOptions& options)

{

    HandleDeploymentArgs(args, options.dep_opts);

}

void ReadTestNetArgs(const ArgsManager& args, CChainParams::TestNetOptions& options)

{

    HandleDeploymentArgs(args, options.dep_opts);

}

void ReadSigNetArgs(const ArgsManager& args, CChainParams::SigNetOptions& options)

{

    if (!args.GetArgs("-signetseednode").empty()) {

        options.seeds.emplace(args.GetArgs("-signetseednode"));

    }

    if (!args.GetArgs("-signetchallenge").empty()) {

        const auto signet_challenge = args.GetArgs("-signetchallenge");

        if (signet_challenge.size() != 1) {

            throw std::runtime_error("-signetchallenge cannot be multiple values.");

        }

        const auto val{TryParseHex<uint8_t>(signet_challenge[0])};

        if (!val) {

            throw std::runtime_error(strprintf("-signetchallenge must be hex, not '%s'.", signet_challenge[0]));

        }

        options.challenge.emplace(*val);

    }

    HandleDeploymentArgs(args, options.dep_opts);

}

void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& options)

{

    if (auto value = args.GetBoolArg("-fastprune")) options.fastprune = *value;

    if (HasTestOption(args, "bip94")) options.enforce_bip94 = true;

    HandleDeploymentArgs(args, options.dep_opts);

}

static std::unique_ptr<const CChainParams> globalChainParams;

const CChainParams &Params() {

    assert(globalChainParams);

    return *globalChainParams;

}

std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain)

{

    switch (chain) {

    case ChainType::MAIN: {

        auto opts = CChainParams::MainNetOptions{};

        ReadMainNetArgs(args, opts);

        return CChainParams::Main(opts);

    }

    case ChainType::TESTNET: {

        auto opts = CChainParams::TestNetOptions{};

        ReadTestNetArgs(args, opts);

        return CChainParams::TestNet(opts);

    }

    case ChainType::TESTNET4: {

        auto opts = CChainParams::TestNetOptions{};

        ReadTestNetArgs(args, opts);

        return CChainParams::TestNet4(opts);

    }

    case ChainType::SIGNET: {

        auto opts = CChainParams::SigNetOptions{};

        ReadSigNetArgs(args, opts);

        return CChainParams::SigNet(opts);

    }

    case ChainType::REGTEST: {

        auto opts = CChainParams::RegTestOptions{};

        ReadRegTestArgs(args, opts);

        return CChainParams::RegTest(opts);

    }

    }

    assert(false);

}

void SelectParams(const ChainType chain)

{

    SelectBaseParams(chain);

    globalChainParams = CreateChainParams(gArgs, chain);

}