#pragma once

#include <xrpl/beast/utility/instrumentation.h>

#include <chrono>
#include <cstddef>
#include <functional>
#include <map>
#include <optional>

namespace xrpl {

/** Consensus algorithm parameters

    Parameters which control the consensus algorithm.  This are not
    meant to be changed arbitrarily.
*/
struct ConsensusParms
{
    explicit ConsensusParms() = default;

    //-------------------------------------------------------------------------
    // Validation and proposal durations are relative to NetClock times, so use
    // second resolution
    /** The duration a validation remains current after its ledger's
       close time.

        This is a safety to protect against very old validations and the time
        it takes to adjust the close time accuracy window.
    */
    std::chrono::seconds const validationValidWall = std::chrono::minutes{5};

    /** Duration a validation remains current after first observed.

       The duration a validation remains current after the time we
       first saw it. This provides faster recovery in very rare cases where the
       number of validations produced by the network is lower than normal
    */
    std::chrono::seconds const validationValidLocal = std::chrono::minutes{3};

    /**  Duration pre-close in which validations are acceptable.

        The number of seconds before a close time that we consider a validation
        acceptable. This protects against extreme clock errors
    */
    std::chrono::seconds const validationValidEarly = std::chrono::minutes{3};

    //! How long we consider a proposal fresh
    std::chrono::seconds const proposeFRESHNESS = std::chrono::seconds{20};

    //! How often we force generating a new proposal to keep ours fresh
    std::chrono::seconds const proposeINTERVAL = std::chrono::seconds{12};

    //-------------------------------------------------------------------------
    // Consensus durations are relative to the internal Consensus clock and use
    // millisecond resolution.

    //! The percentage threshold above which we can declare consensus.
    std::size_t const minConsensusPct = 80;

    //! The duration a ledger may remain idle before closing
    std::chrono::milliseconds const ledgerIdleInterval = std::chrono::seconds{15};

    //! The number of seconds we wait minimum to ensure participation
    std::chrono::milliseconds const ledgerMinConsensus = std::chrono::milliseconds{1950};

    /** The maximum amount of time to spend pausing for laggards.
     *
     *  This should be sufficiently less than validationFRESHNESS so that
     *  validators don't appear to be offline that are merely waiting for
     *  laggards.
     */
    std::chrono::milliseconds const ledgerMaxConsensus = std::chrono::seconds{15};

    //! Minimum number of seconds to wait to ensure others have computed the LCL
    std::chrono::milliseconds const ledgerMinClose = std::chrono::seconds{2};

    //! How often we check state or change positions
    std::chrono::milliseconds const ledgerGRANULARITY = std::chrono::seconds{1};

    //! How long to wait before completely abandoning consensus
    std::size_t const ledgerAbandonConsensusFactor = 10;

    /**
     * Maximum amount of time to give a consensus round
     *
     * Does not include the time to build the LCL, so there is no reason for a
     * round to go this long, regardless of how big the ledger is.
     */
    std::chrono::milliseconds const ledgerAbandonConsensus = std::chrono::seconds{120};

    /** The minimum amount of time to consider the previous round
        to have taken.

        The minimum amount of time to consider the previous round
        to have taken. This ensures that there is an opportunity
        for a round at each avalanche threshold even if the
        previous consensus was very fast. This should be at least
        twice the interval between proposals (0.7s) divided by
        the interval between mid and late consensus ([85-50]/100).
    */
    std::chrono::milliseconds const avMinConsensusTime = std::chrono::seconds{5};

    //------------------------------------------------------------------------------
    // Avalanche tuning
    // As a function of the percent this round's duration is of the prior round,
    // we increase the threshold for yes votes to add a transaction to our
    // position.
    enum class AvalancheState { Init, Mid, Late, Stuck };
    struct AvalancheCutoff
    {
        int const consensusTime;
        std::size_t const consensusPct;
        AvalancheState const next;
    };
    //! Map the consensus requirement avalanche state to the amount of time that
    //! must pass before moving to that state, the agreement percentage required
    //! at that state, and the next state. "stuck" loops back on itself because
    //! once we're stuck, we're stuck.
    //! This structure allows for "looping" of states if needed.
    std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
        // {state, {time, percent, nextState}},
        // Initial state: 50% of nodes must vote yes
        {AvalancheState::Init,
         {.consensusTime = 0, .consensusPct = 50, .next = AvalancheState::Mid}},
        // mid-consensus starts after 50% of the previous round time, and
        // requires 65% yes
        {AvalancheState::Mid,
         {.consensusTime = 50, .consensusPct = 65, .next = AvalancheState::Late}},
        // late consensus starts after 85% time, and requires 70% yes
        {AvalancheState::Late,
         {.consensusTime = 85, .consensusPct = 70, .next = AvalancheState::Stuck}},
        // we're stuck after 2x time, requires 95% yes votes
        {AvalancheState::Stuck,
         {.consensusTime = 200, .consensusPct = 95, .next = AvalancheState::Stuck}},
    };

    //! Percentage of nodes required to reach agreement on ledger close time
    std::size_t const avCtConsensusPct = 75;

    //! Number of rounds before certain actions can happen.
    // (Moving to the next avalanche level, considering that votes are stalled
    // without consensus.)
    std::size_t const avMinRounds = 2;

    //! Number of rounds before a stuck vote is considered unlikely to change
    //! because voting stalled
    std::size_t const avStalledRounds = 4;
};

inline std::pair<std::size_t, std::optional<ConsensusParms::AvalancheState>>
getNeededWeight(
    ConsensusParms const& p,
    ConsensusParms::AvalancheState currentState,
    int percentTime,
    std::size_t currentRounds,
    std::size_t minimumRounds)
{
    // at() can throw, but the map is built by hand to ensure all valid
    // values are available.
    auto const& currentCutoff = p.avalancheCutoffs.at(currentState);
    // Should we consider moving to the next state?
    if (currentCutoff.next != currentState && currentRounds >= minimumRounds)
    {
        // at() can throw, but the map is built by hand to ensure all
        // valid values are available.
        auto const& nextCutoff = p.avalancheCutoffs.at(currentCutoff.next);
        // See if enough time has passed to move on to the next.
        XRPL_ASSERT(
            nextCutoff.consensusTime >= currentCutoff.consensusTime,
            "xrpl::getNeededWeight : next state valid");
        if (percentTime >= nextCutoff.consensusTime)
        {
            return {nextCutoff.consensusPct, currentCutoff.next};
        }
    }
    return {currentCutoff.consensusPct, {}};
}

}  // namespace xrpl