#ifndef BITCOIN_CLAIMTRIE_H
#define BITCOIN_CLAIMTRIE_H

#include "amount.h"
#include "serialize.h"
#include "uint256.h"
#include "util.h"
#include "dbwrapper.h"
#include "chainparams.h"
#include "primitives/transaction.h"

#include <string>
#include <vector>
#include <map>

// leveldb keys
#define HASH_BLOCK 'h'
#define CURRENT_HEIGHT 't'
#define TRIE_NODE 'n'
#define CLAIM_BY_ID 'i'
#define CLAIM_QUEUE_ROW 'r'
#define CLAIM_QUEUE_NAME_ROW 'm'
#define EXP_QUEUE_ROW 'e'
#define SUPPORT 's'
#define SUPPORT_QUEUE_ROW 'u'
#define SUPPORT_QUEUE_NAME_ROW 'p'
#define SUPPORT_EXP_QUEUE_ROW 'x'

uint256 getValueHash(COutPoint outPoint, int nHeightOfLastTakeover);

class CClaimValue
{
public:
    COutPoint outPoint;
    uint160 claimId;
    CAmount nAmount;
    CAmount nEffectiveAmount;
    int nHeight;
    int nValidAtHeight;

    CClaimValue() {};

    CClaimValue(COutPoint outPoint, uint160 claimId, CAmount nAmount, int nHeight,
                int nValidAtHeight)
                : outPoint(outPoint), claimId(claimId)
                , nAmount(nAmount), nEffectiveAmount(nAmount)
                , nHeight(nHeight), nValidAtHeight(nValidAtHeight)
    {}

    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
        READWRITE(outPoint);
        READWRITE(claimId);
        READWRITE(nAmount);
        READWRITE(nHeight);
        READWRITE(nValidAtHeight);
    }

    bool operator<(const CClaimValue& other) const
    {
        if (nEffectiveAmount < other.nEffectiveAmount)
            return true;
        else if (nEffectiveAmount == other.nEffectiveAmount)
        {
            if (nHeight > other.nHeight)
                return true;
            else if (nHeight == other.nHeight)
            {
                if (outPoint != other.outPoint && !(outPoint < other.outPoint))
                    return true;
            }
        }
        return false;
    }

    bool operator==(const CClaimValue& other) const
    {
        return outPoint == other.outPoint && claimId == other.claimId && nAmount == other.nAmount && nHeight == other.nHeight && nValidAtHeight == other.nValidAtHeight;
    }

    bool operator!=(const CClaimValue& other) const
    {
        return !(*this == other);
    }
};

class CSupportValue
{
public:
    COutPoint outPoint;
    uint160 supportedClaimId;
    CAmount nAmount;
    int nHeight;
    int nValidAtHeight;

    CSupportValue() {};
    CSupportValue(COutPoint outPoint, uint160 supportedClaimId,
                  CAmount nAmount, int nHeight, int nValidAtHeight)
                  : outPoint(outPoint), supportedClaimId(supportedClaimId)
                  , nAmount(nAmount), nHeight(nHeight)
                  , nValidAtHeight(nValidAtHeight)
    {}

    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
        READWRITE(outPoint);
        READWRITE(supportedClaimId);
        READWRITE(nAmount);
        READWRITE(nHeight);
        READWRITE(nValidAtHeight);
    }

    bool operator==(const CSupportValue& other) const
    {
        return outPoint == other.outPoint && supportedClaimId == other.supportedClaimId && nAmount == other.nAmount && nHeight == other.nHeight && nValidAtHeight == other.nValidAtHeight;
    }

    bool operator!=(const CSupportValue& other) const
    {
        return !(*this == other);
    }
};

class CClaimTrieNode;
class CClaimTrie;

typedef std::vector<CSupportValue> supportMapEntryType;

typedef std::map<unsigned char, CClaimTrieNode*> nodeMapType;

typedef std::pair<std::string, CClaimTrieNode> namedNodeType;

class CClaimTrieNode
{
public:
    CClaimTrieNode() : nHeightOfLastTakeover(0) {}
    CClaimTrieNode(uint256 hash) : hash(hash), nHeightOfLastTakeover(0) {}
    uint256 hash;
    nodeMapType children;
    int nHeightOfLastTakeover;
    std::vector<CClaimValue> claims;

    bool insertClaim(CClaimValue claim);
    bool removeClaim(const COutPoint& outPoint, CClaimValue& claim);
    bool getBestClaim(CClaimValue& claim) const;
    bool empty() const {return children.empty() && claims.empty();}
    bool haveClaim(const COutPoint& outPoint) const;
    void reorderClaims(supportMapEntryType& supports);

    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
        READWRITE(hash);
        READWRITE(claims);
        READWRITE(nHeightOfLastTakeover);
    }

    bool operator==(const CClaimTrieNode& other) const
    {
        return hash == other.hash && claims == other.claims;
    }

    bool operator!=(const CClaimTrieNode& other) const
    {
        return !(*this == other);
    }
};

struct nodenamecompare
{
    bool operator() (const std::string& i, const std::string& j) const
    {
        if (i.size() == j.size())
            return i < j;
        return i.size() < j.size();
    }
};

struct outPointHeightType
{
    COutPoint outPoint;
    int nHeight;

    outPointHeightType() {}

    outPointHeightType(COutPoint outPoint, int nHeight)
    : outPoint(outPoint), nHeight(nHeight) {}

    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(outPoint);
        READWRITE(nHeight);
    }

};

struct nameOutPointHeightType
{
    std::string name;
    COutPoint outPoint;
    int nHeight;

    nameOutPointHeightType() {}

    nameOutPointHeightType(std::string name, COutPoint outPoint, int nHeight)
    : name(name), outPoint(outPoint), nHeight(nHeight) {}
   
    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(name);
        READWRITE(outPoint);
        READWRITE(nHeight);
    }
};

struct nameOutPointType
{
    std::string name;
    COutPoint outPoint;

    nameOutPointType() {}

    nameOutPointType(std::string name, COutPoint outPoint)
    : name(name), outPoint(outPoint) {}

    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(name);
        READWRITE(outPoint);
    }
};

class CClaimIndexElement
{
  public:
    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
        READWRITE(name);
        READWRITE(claim);
    }

    std::string name;
    CClaimValue claim;
};

typedef std::pair<std::string, CClaimValue> claimQueueEntryType;

typedef std::pair<std::string, CSupportValue> supportQueueEntryType;

typedef std::map<std::string, supportMapEntryType> supportMapType;

typedef std::vector<outPointHeightType> queueNameRowType;
typedef std::map<std::string, queueNameRowType> queueNameType;

typedef std::vector<nameOutPointHeightType> insertUndoType;

typedef std::vector<nameOutPointType> expirationQueueRowType;
typedef std::map<int, expirationQueueRowType> expirationQueueType;

typedef std::vector<claimQueueEntryType> claimQueueRowType;
typedef std::map<int, claimQueueRowType> claimQueueType;

typedef std::vector<supportQueueEntryType> supportQueueRowType;
typedef std::map<int, supportQueueRowType> supportQueueType;

typedef std::map<std::string, CClaimTrieNode*, nodenamecompare> nodeCacheType;

typedef std::map<std::string, uint256> hashMapType;

struct claimsForNameType
{
    std::vector<CClaimValue> claims;
    std::vector<CSupportValue> supports;
    int nLastTakeoverHeight;

    claimsForNameType(std::vector<CClaimValue> claims, std::vector<CSupportValue> supports, int nLastTakeoverHeight)
    : claims(claims), supports(supports), nLastTakeoverHeight(nLastTakeoverHeight) {}
};

class CClaimTrieCache;

class CClaimTrie
{
public:
    CClaimTrie(bool fMemory = false, bool fWipe = false, int nProportionalDelayFactor = 32)
               : db(GetDataDir() / "claimtrie", 100, fMemory, fWipe, false)
               , nCurrentHeight(0), nExpirationTime(Params().GetConsensus().nOriginalClaimExpirationTime)
               , nProportionalDelayFactor(nProportionalDelayFactor)
               , root(uint256S("0000000000000000000000000000000000000000000000000000000000000001"))
    {}

    uint256 getMerkleHash();

    bool empty() const;
    void clear();

    bool checkConsistency() const;

    bool WriteToDisk();
    bool ReadFromDisk(bool check = false);

    std::vector<namedNodeType> flattenTrie() const;
    bool getInfoForName(const std::string& name, CClaimValue& claim) const;
    bool getLastTakeoverForName(const std::string& name, int& lastTakeoverHeight) const;

    claimsForNameType getClaimsForName(const std::string& name) const;
    CAmount getEffectiveAmountForClaim(const std::string& name, uint160 claimId) const;   
    CAmount getEffectiveAmountForClaimWithSupports(const std::string& name, uint160 claimId,
                                                   std::vector<CSupportValue>& supports) const;

    bool queueEmpty() const;
    bool supportEmpty() const;
    bool supportQueueEmpty() const;
    bool expirationQueueEmpty() const;
    bool supportExpirationQueueEmpty() const;

    void setExpirationTime(int t);

    void addToClaimIndex(const std::string& name, const CClaimValue& claim);
    void removeFromClaimIndex(const CClaimValue& claim);

    bool getClaimById(const uint160 claimId, std::string& name, CClaimValue& claim) const;
    bool getQueueRow(int nHeight, claimQueueRowType& row) const;
    bool getQueueNameRow(const std::string& name, queueNameRowType& row) const;
    bool getExpirationQueueRow(int nHeight, expirationQueueRowType& row) const;
    bool getSupportNode(std::string name, supportMapEntryType& node) const;
    bool getSupportQueueRow(int nHeight, supportQueueRowType& row) const;
    bool getSupportQueueNameRow(const std::string& name, queueNameRowType& row) const;
    bool getSupportExpirationQueueRow(int nHeight, expirationQueueRowType& row) const;


    bool haveClaim(const std::string& name, const COutPoint& outPoint) const;
    bool haveClaimInQueue(const std::string& name, const COutPoint& outPoint,
                          int& nValidAtHeight) const;

    bool haveSupport(const std::string& name, const COutPoint& outPoint) const;
    bool haveSupportInQueue(const std::string& name, const COutPoint& outPoint,
                            int& nValidAtHeight) const;

    unsigned int getTotalNamesInTrie() const;
    unsigned int getTotalClaimsInTrie() const;
    CAmount getTotalValueOfClaimsInTrie(bool fControllingOnly) const;

    friend class CClaimTrieCache;

    CDBWrapper db;
    int nCurrentHeight;
    int nExpirationTime;
    int nProportionalDelayFactor;
private:
    void clear(CClaimTrieNode* current);

    const CClaimTrieNode* getNodeForName(const std::string& name) const;

    bool update(nodeCacheType& cache, hashMapType& hashes,
                std::map<std::string, int>& takeoverHeights,
                const uint256& hashBlock, claimQueueType& queueCache,
                queueNameType& queueNameCache,
                expirationQueueType& expirationQueueCache, int nNewHeight,
                supportMapType& supportCache,
                supportQueueType& supportQueueCache,
                queueNameType& supportQueueNameCache,
                expirationQueueType& supportExpirationQueueCache);
    bool updateName(const std::string& name, CClaimTrieNode* updatedNode);
    bool updateHash(const std::string& name, uint256& hash);
    bool updateTakeoverHeight(const std::string& name, int nTakeoverHeight);
    bool recursiveNullify(CClaimTrieNode* node, std::string& name);

    bool recursiveCheckConsistency(const CClaimTrieNode* node) const;

    bool InsertFromDisk(const std::string& name, CClaimTrieNode* node);

    unsigned int getTotalNamesRecursive(const CClaimTrieNode* current) const;
    unsigned int getTotalClaimsRecursive(const CClaimTrieNode* current) const;
    CAmount getTotalValueOfClaimsRecursive(const CClaimTrieNode* current,
                                           bool fControllingOnly) const;
    bool recursiveFlattenTrie(const std::string& name,
                              const CClaimTrieNode* current,
                              std::vector<namedNodeType>& nodes) const;

    void markNodeDirty(const std::string& name, CClaimTrieNode* node);
    void updateQueueRow(int nHeight, claimQueueRowType& row);
    void updateQueueNameRow(const std::string& name,
                            queueNameRowType& row);
    void updateExpirationRow(int nHeight, expirationQueueRowType& row);
    void updateSupportMap(const std::string& name, supportMapEntryType& node);
    void updateSupportQueue(int nHeight, supportQueueRowType& row);
    void updateSupportNameQueue(const std::string& name,
                                queueNameRowType& row);
    void updateSupportExpirationQueue(int nHeight, expirationQueueRowType& row);

    void BatchWriteNode(CDBBatch& batch, const std::string& name,
                        const CClaimTrieNode* pNode) const;
    void BatchEraseNode(CDBBatch& batch, const std::string& nome) const;
    void BatchWriteClaimIndex(CDBBatch& batch) const;
    void BatchWriteQueueRows(CDBBatch& batch);
    void BatchWriteQueueNameRows(CDBBatch& batch);
    void BatchWriteExpirationQueueRows(CDBBatch& batch);
    void BatchWriteSupportNodes(CDBBatch& batch);
    void BatchWriteSupportQueueRows(CDBBatch& batch);
    void BatchWriteSupportQueueNameRows(CDBBatch& batch);
    void BatchWriteSupportExpirationQueueRows(CDBBatch& batch);
    template<typename K> bool keyTypeEmpty(char key, K& dummy) const;

    CClaimTrieNode root;
    uint256 hashBlock;

    claimQueueType dirtyQueueRows;
    queueNameType dirtyQueueNameRows;
    expirationQueueType dirtyExpirationQueueRows;

    supportQueueType dirtySupportQueueRows;
    queueNameType dirtySupportQueueNameRows;
    expirationQueueType dirtySupportExpirationQueueRows;

    nodeCacheType dirtyNodes;
    supportMapType dirtySupportNodes;
};

class CClaimTrieProofNode
{
public:
    CClaimTrieProofNode() {};
    CClaimTrieProofNode(std::vector<std::pair<unsigned char, uint256> > children,
                        bool hasValue, uint256 valHash)
        : children(children), hasValue(hasValue), valHash(valHash)
        {};
    std::vector<std::pair<unsigned char, uint256> > children;
    bool hasValue;
    uint256 valHash;
};

class CClaimTrieProof
{
public:
    CClaimTrieProof() {};
    CClaimTrieProof(std::vector<CClaimTrieProofNode> nodes, bool hasValue, COutPoint outPoint, int nHeightOfLastTakeover) : nodes(nodes), hasValue(hasValue), outPoint(outPoint), nHeightOfLastTakeover(nHeightOfLastTakeover) {}
    std::vector<CClaimTrieProofNode> nodes;
    bool hasValue;
    COutPoint outPoint;
    int nHeightOfLastTakeover;
};

class CClaimTrieCache
{
public:
    CClaimTrieCache(CClaimTrie* base, bool fRequireTakeoverHeights = true)
                    : base(base),
                      fRequireTakeoverHeights(fRequireTakeoverHeights)
    {
        assert(base);
        nCurrentHeight = base->nCurrentHeight;
    }

    uint256 getMerkleHash() const;

    bool empty() const;
    bool flush();
    bool dirty() const { return !dirtyHashes.empty(); }

    bool addClaim(const std::string& name, const COutPoint& outPoint,
                  uint160 claimId, CAmount nAmount, int nHeight) const;
    bool undoAddClaim(const std::string& name, const COutPoint& outPoint,
                      int nHeight) const;
    bool spendClaim(const std::string& name, const COutPoint& outPoint,
                    int nHeight, int& nValidAtHeight) const;
    bool undoSpendClaim(const std::string& name, const COutPoint& outPoint,
                        uint160 claimId, CAmount nAmount, int nHeight,
                        int nValidAtHeight) const;

    bool addSupport(const std::string& name, const COutPoint& outPoint,
                    CAmount nAmount, uint160 supportedClaimId,
                    int nHeight) const;
    bool undoAddSupport(const std::string& name, const COutPoint& outPoint,
                        int nHeight) const;
    bool spendSupport(const std::string& name, const COutPoint& outPoint,
                      int nHeight, int& nValidAtHeight) const;
    bool undoSpendSupport(const std::string& name, const COutPoint& outPoint,
                          uint160 supportedClaimId, CAmount nAmount,
                          int nHeight, int nValidAtHeight) const;

    uint256 getBestBlock();
    void setBestBlock(const uint256& hashBlock);

    bool incrementBlock(insertUndoType& insertUndo,
                        claimQueueRowType& expireUndo,
                        insertUndoType& insertSupportUndo,
                        supportQueueRowType& expireSupportUndo,
                        std::vector<std::pair<std::string, int> >& takeoverHeightUndo) const;
    bool decrementBlock(insertUndoType& insertUndo,
                        claimQueueRowType& expireUndo,
                        insertUndoType& insertSupportUndo,
                        supportQueueRowType& expireSupportUndo,
                        std::vector<std::pair<std::string, int> >& takeoverHeightUndo) const;

    ~CClaimTrieCache() { clear(); }

    bool insertClaimIntoTrie(const std::string& name, CClaimValue claim,
                             bool fCheckTakeover = false) const;
    bool removeClaimFromTrie(const std::string& name, const COutPoint& outPoint,
                             CClaimValue& claim,
                             bool fCheckTakeover = false) const;
    CClaimTrieProof getProofForName(const std::string& name) const;

    bool finalizeDecrement() const;

    void removeAndAddSupportToExpirationQueue(expirationQueueRowType &row, int height, bool increment) const;
    void removeAndAddToExpirationQueue(expirationQueueRowType &row, int height, bool increment) const;

    bool forkForExpirationChange(bool increment) const;


protected:
    CClaimTrie* base;

    bool fRequireTakeoverHeights;

    mutable nodeCacheType cache;
    mutable nodeCacheType block_originals;
    mutable std::set<std::string> dirtyHashes;
    mutable hashMapType cacheHashes;
    mutable claimQueueType claimQueueCache;
    mutable queueNameType claimQueueNameCache;
    mutable expirationQueueType expirationQueueCache;
    mutable supportMapType supportCache;
    mutable supportQueueType supportQueueCache;
    mutable queueNameType supportQueueNameCache;
    mutable expirationQueueType supportExpirationQueueCache;
    mutable std::set<std::string> namesToCheckForTakeover;
    mutable std::map<std::string, int> cacheTakeoverHeights; 
    mutable int nCurrentHeight; // Height of the block that is being worked on, which is
                                // one greater than the height of the chain's tip

    uint256 hashBlock;

    uint256 computeHash() const;

    bool reorderTrieNode(const std::string& name, bool fCheckTakeover) const;
    bool recursiveComputeMerkleHash(CClaimTrieNode* tnCurrent,
                                    std::string sPos) const;
    bool recursivePruneName(CClaimTrieNode* tnCurrent, unsigned int nPos,
                            std::string sName,
                            bool* pfNullified = NULL) const;

    bool clear() const;

    bool removeClaim(const std::string& name, const COutPoint& outPoint,
                     int nHeight, int& nValidAtHeight, bool fCheckTakeover) const;

    bool addClaimToQueues(const std::string& name, CClaimValue& claim) const;
    bool removeClaimFromQueue(const std::string& name, const COutPoint& outPoint,
                              CClaimValue& claim) const;
    void addToExpirationQueue(int nExpirationHeight, nameOutPointType& entry) const;
    void removeFromExpirationQueue(const std::string& name, const COutPoint& outPoint,
                                   int nHeight) const;

    claimQueueType::iterator getQueueCacheRow(int nHeight,
                                              bool createIfNotExists) const;
    queueNameType::iterator getQueueCacheNameRow(const std::string& name,
                                                 bool createIfNotExists) const;
    expirationQueueType::iterator getExpirationQueueCacheRow(int nHeight,
                                                             bool createIfNotExists) const;

    bool removeSupport(const std::string& name, const COutPoint& outPoint,
                       int nHeight, int& nValidAtHeight,
                       bool fCheckTakeover) const;
    bool removeSupportFromMap(const std::string& name, const COutPoint& outPoint,
                              CSupportValue& support,
                              bool fCheckTakeover) const;

    bool insertSupportIntoMap(const std::string& name,
                              CSupportValue support,
                              bool fCheckTakeover) const;

    supportQueueType::iterator getSupportQueueCacheRow(int nHeight,
                                                       bool createIfNotExists) const;
    queueNameType::iterator getSupportQueueCacheNameRow(const std::string& name,
                                                                 bool createIfNotExists) const;
    expirationQueueType::iterator getSupportExpirationQueueCacheRow(int nHeight,
                                                                     bool createIfNotExists) const;

    bool addSupportToQueues(const std::string& name, CSupportValue& support) const;
    bool removeSupportFromQueue(const std::string& name, const COutPoint& outPoint,
                                CSupportValue& support) const;

    void addSupportToExpirationQueue(int nExpirationHeight,
                                     nameOutPointType& entry) const;
    void removeSupportFromExpirationQueue(const std::string& name,
                                          const COutPoint& outPoint,
                                          int nHeight) const;

    bool getSupportsForName(const std::string& name,
                            supportMapEntryType& node) const;

    bool getLastTakeoverForName(const std::string& name, int& lastTakeoverHeight) const;

    int getDelayForName(const std::string& name) const;

    uint256 getLeafHashForProof(const std::string& currentPosition, unsigned char nodeChar,
                                const CClaimTrieNode* currentNode) const;

    CClaimTrieNode* addNodeToCache(const std::string& position, CClaimTrieNode* original) const;

    bool getOriginalInfoForName(const std::string& name, CClaimValue& claim) const;

    int getNumBlocksOfContinuousOwnership(const std::string& name) const;
};

#endif // BITCOIN_CLAIMTRIE_H