#pragma once

#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/UintTypes.h>

#include <array>
#include <cstdint>
#include <functional>
#include <set>
#include <utility>

namespace xrpl {

class SeqProxy;
/**
 * Keylet computation functions.
 *
 * Entries in the ledger are located using 256-bit locators. The locators are
 * calculated using a wide range of parameters specific to the entry whose
 * locator we are calculating (e.g. an account's locator is derived from the
 * account's address, whereas the locator for an offer is derived from the
 * account and the offer sequence.)
 *
 * To enhance type safety during lookup and make the code more robust, we use
 * keylets, which contain not only the locator of the object but also the type
 * of the object being referenced.
 *
 * These functions each return a type-specific keylet.
 */
namespace keylet {

/**
 * AccountID root
 */
Keylet
account(AccountID const& id) noexcept;

/**
 * The index of the amendment table
 */
Keylet const&
amendments() noexcept;

/**
 * Any item that can be in an owner dir.
 */
Keylet
child(uint256 const& key) noexcept;

/**
 * The index of the "short" skip list
 *
 * The "short" skip list is a node (at a fixed index) that holds the hashes
 * of ledgers since the last flag ledger. It will contain, at most, 256 hashes.
 */
Keylet const&
skip() noexcept;

/**
 * The index of the long skip for a particular ledger range.
 *
 * The "long" skip list is a node that holds the hashes of (up to) 256 flag
 * ledgers.
 *
 * It can be used to efficiently skip back to any ledger using only two hops:
 * the first hop gets the "long" skip list for the ledger it wants to retrieve
 * and uses it to get the hash of the flag ledger whose short skip list will
 * contain the hash of the requested ledger.
 */
Keylet
skip(LedgerIndex ledger) noexcept;

/**
 * The (fixed) index of the object containing the ledger fees.
 */
Keylet const&
feeSettings() noexcept;

/**
 * The (fixed) index of the object containing the ledger negativeUNL.
 */
Keylet const&
negativeUNL() noexcept;

/**
 * The beginning of an order book
 */
Keylet
book(Book const& b);

/**
 * The index of a trust line for a given currency
 *
 * Note that a trustline is *shared* between two accounts (commonly referred
 * to as the issuer and the holder); if Alice sets up a trust line to Bob for
 * BTC, and Bob trusts Alice for BTC, here is only a single BTC trust line
 * between them.
 */
/** @{ */
Keylet
trustLine(AccountID const& id0, AccountID const& id1, Currency const& currency) noexcept;

inline Keylet
trustLine(AccountID const& id, Issue const& issue) noexcept
{
    return trustLine(id, issue.account, issue.currency);
}
/** @} */

/**
 * An offer from an account
 */
/** @{ */
Keylet
offer(AccountID const& id, std::uint32_t seq) noexcept;

inline Keylet
offer(uint256 const& key) noexcept
{
    return {ltOFFER, key};
}
/** @} */

/**
 * The initial directory page for a specific quality
 */
Keylet
quality(Keylet const& k, std::uint64_t q) noexcept;

/**
 * The directory for the next lower quality
 */
Keylet
next(Keylet const& k);

/**
 * A ticket belonging to an account
 */
/** @{ */
Keylet
ticket(AccountID const& id, std::uint32_t ticketSeq);

Keylet
ticket(AccountID const& id, SeqProxy ticketSeq);

inline Keylet
ticket(uint256 const& key)
{
    return {ltTICKET, key};
}
/** @} */

/**
 * A SignerList
 */
Keylet
signerList(AccountID const& account) noexcept;

/**
 * A Sponsorship
 */
Keylet
sponsorship(AccountID const& sponsor, AccountID const& sponsee) noexcept;

/**
 * A Check
 */
/** @{ */
Keylet
check(AccountID const& id, std::uint32_t seq) noexcept;

inline Keylet
check(uint256 const& key) noexcept
{
    return {ltCHECK, key};
}
/** @} */

/**
 * A DepositPreauth
 */
/** @{ */
Keylet
depositPreauth(AccountID const& owner, AccountID const& preauthorized) noexcept;

Keylet
depositPreauth(
    AccountID const& owner,
    std::set<std::pair<AccountID, Slice>> const& authCreds) noexcept;

inline Keylet
depositPreauth(uint256 const& key) noexcept
{
    return {ltDEPOSIT_PREAUTH, key};
}
/** @} */

//------------------------------------------------------------------------------

/**
 * Any ledger entry
 */
Keylet
unchecked(uint256 const& key) noexcept;

/**
 * The root page of an account's directory
 */
Keylet
ownerDir(AccountID const& id) noexcept;

/**
 * A page in a directory
 */
/** @{ */
Keylet
page(uint256 const& root, std::uint64_t index = 0) noexcept;

inline Keylet
page(Keylet const& root, std::uint64_t index = 0) noexcept
{
    XRPL_ASSERT(root.type == ltDIR_NODE, "xrpl::keylet::page : valid root type");
    return page(root.key, index);
}
/** @} */

/**
 * An escrow entry
 */
Keylet
escrow(AccountID const& src, std::uint32_t seq) noexcept;

/**
 * A PaymentChannel
 */
Keylet
payChannel(AccountID const& src, AccountID const& dst, std::uint32_t seq) noexcept;

/**
 * NFT page keylets
 *
 * Unlike objects whose ledger identifiers are produced by hashing data,
 * NFT page identifiers are composite identifiers, consisting of the owner's
 * 160-bit AccountID, followed by a 96-bit value that determines which NFT
 * tokens are candidates for that page.
 */
/** @{ */
/**
 * A keylet for the owner's first possible NFT page.
 */
Keylet
nftokenPageMin(AccountID const& owner);

/**
 * A keylet for the owner's last possible NFT page.
 */
Keylet
nftokenPageMax(AccountID const& owner);

Keylet
nftokenPage(Keylet const& k, uint256 const& token);
/** @} */

/**
 * An offer from an account to buy or sell an NFT
 */
Keylet
nftokenOffer(AccountID const& owner, std::uint32_t seq);

inline Keylet
nftokenOffer(uint256 const& offer)
{
    return {ltNFTOKEN_OFFER, offer};
}

/**
 * The directory of buy offers for the specified NFT
 */
Keylet
nftBuys(uint256 const& id) noexcept;

/**
 * The directory of sell offers for the specified NFT
 */
Keylet
nftSells(uint256 const& id) noexcept;

/**
 * AMM entry
 */
Keylet
amm(Asset const& issue1, Asset const& issue2) noexcept;

Keylet
amm(uint256 const& amm) noexcept;

/**
 * A keylet for Delegate object
 */
Keylet
delegate(AccountID const& account, AccountID const& authorizedAccount) noexcept;

Keylet
bridge(STXChainBridge const& bridge, STXChainBridge::ChainType chainType);

// `seq` is stored as `sfXChainClaimID` in the object
Keylet
xChainClaimID(STXChainBridge const& bridge, std::uint64_t seq);

// `seq` is stored as `sfXChainAccountCreateCount` in the object
Keylet
xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t seq);

Keylet
did(AccountID const& account) noexcept;

Keylet
oracle(AccountID const& account, std::uint32_t const& documentID) noexcept;

Keylet
credential(AccountID const& subject, AccountID const& issuer, Slice const& credType) noexcept;

inline Keylet
credential(uint256 const& key) noexcept
{
    return {ltCREDENTIAL, key};
}

Keylet
mptokenIssuance(std::uint32_t seq, AccountID const& issuer) noexcept;

Keylet
mptokenIssuance(MPTID const& issuanceID) noexcept;

inline Keylet
mptokenIssuance(uint256 const& issuanceKey)
{
    return {ltMPTOKEN_ISSUANCE, issuanceKey};
}

Keylet
mptoken(MPTID const& issuanceID, AccountID const& holder) noexcept;

inline Keylet
mptoken(uint256 const& mptokenKey)
{
    return {ltMPTOKEN, mptokenKey};
}

Keylet
mptoken(uint256 const& issuanceKey, AccountID const& holder) noexcept;

Keylet
vault(AccountID const& owner, std::uint32_t seq) noexcept;

inline Keylet
vault(uint256 const& vaultKey)
{
    return {ltVAULT, vaultKey};
}

Keylet
loanBroker(AccountID const& owner, std::uint32_t seq) noexcept;

inline Keylet
loanBroker(uint256 const& key)
{
    return {ltLOAN_BROKER, key};
}

Keylet
loan(uint256 const& loanBrokerID, std::uint32_t loanSeq) noexcept;

inline Keylet
loan(uint256 const& key)
{
    return {ltLOAN, key};
}

Keylet
permissionedDomain(AccountID const& account, std::uint32_t seq) noexcept;

Keylet
permissionedDomain(uint256 const& domainID) noexcept;
}  // namespace keylet

// Everything below is deprecated and should be removed in favor of keylets:

uint256
getBookBase(Book const& book);

uint256
getQualityNext(uint256 const& uBase);

// VFALCO This name could be better
std::uint64_t
getQuality(uint256 const& uBase);

uint256
getTicketIndex(AccountID const& account, std::uint32_t uSequence);

uint256
getTicketIndex(AccountID const& account, SeqProxy ticketSeq);

template <class... KeyletParams>
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
struct KeyletDesc
{
    std::function<Keylet(KeyletParams...)> function;
    json::StaticString expectedLEName;
    bool includeInTests{};
};

// This list should include all of the keylet functions that take a single AccountID parameter.
extern std::array<KeyletDesc<AccountID const&>, 6> const kDirectAccountKeylets;

MPTID
makeMptID(std::uint32_t sequence, AccountID const& account);

}  // namespace xrpl