#pragma once

#include "types.hpp"
#include "Key.hpp"
#include "DataView.hpp"
#include "DatabaseStorage.hpp"
#include "Hash.hpp"
#include "utils.hpp"
#include "Signature.hpp"
#include "Permission.hpp"
#include "DatabaseNode.hpp"
#include "Encryption.hpp"
#include "OwnedMemory.hpp"
#include "DatabaseOperation.hpp"
#include "DatabaseOrder.hpp"
#include <opendht/dhtrunner.h>
#include <vector>
#include <ntp/NtpClient.hpp>
#include <boost/filesystem/path.hpp>
#include <sibs/SafeSerializer.hpp>
#include <stdexcept>
#include <functional>

namespace odhtdb
{    
    class CommitCreateException : public std::runtime_error
    {
    public:
        CommitCreateException(const std::string &errMsg) : std::runtime_error(errMsg) {}
    };
    
    class CommitAddException : public std::runtime_error
    {
    public:
        CommitAddException(const std::string &errMsg) : std::runtime_error(errMsg) {}
    };
    
    class DatabaseCreateException : public std::runtime_error
    {
    public:
        DatabaseCreateException(const std::string &errMsg) : std::runtime_error(errMsg) {}
    };
    
    class DatabaseAddException : public std::runtime_error
    {
    public:
        DatabaseAddException(const std::string &errMsg) : std::runtime_error(errMsg) {}
    };
    
    struct DatabaseCreateNodeRequest
    {
        DISABLE_COPY(DatabaseCreateNodeRequest)
        
        const Hash *nodeHash;
        u64 timestamp; // In microseconds
        const Signature::PublicKey *creatorPublicKey;
        const DataView groupId;
        bool loadedFromCache;
        
        DatabaseCreateNodeRequest(const Hash *_nodeHash, u64 _timestamp, const Signature::PublicKey *_creatorPublicKey, const DataView &_groupId) : 
            nodeHash(_nodeHash),
            timestamp(_timestamp),
            creatorPublicKey(_creatorPublicKey),
            groupId(_groupId),
            loadedFromCache(false)
        {
            
        }
    };

    struct DatabaseAddNodeRequest
    {
        DISABLE_COPY(DatabaseAddNodeRequest)
        
        const Hash *nodeHash;
        const Hash *requestHash;
        u64 timestamp; // In microseconds
        const Signature::PublicKey *creatorPublicKey;
        const DataView decryptedData;
        bool loadedFromCache;
        
        DatabaseAddNodeRequest(const Hash *_nodeHash, const Hash *_requestHash, u64 _timestamp, const Signature::PublicKey *_creatorPublicKey, const DataView &_decryptedData) : 
            nodeHash(_nodeHash),
            requestHash(_requestHash),
            timestamp(_timestamp),
            creatorPublicKey(_creatorPublicKey),
            decryptedData(_decryptedData),
            loadedFromCache(false)
        {
            
        }
    };

    struct DatabaseAddUserRequest
    {
        DISABLE_COPY(DatabaseAddUserRequest)

        const Hash *nodeHash;
        const Hash *requestHash;
        u64 timestamp; // In microseconds
        const Signature::PublicKey *creatorPublicKey;
        const Signature::PublicKey *userToAddPublicKey;
        const DataView groupToAddUserTo;
        bool loadedFromCache;

        DatabaseAddUserRequest(const Hash *_nodeHash, const Hash *_requestHash, u64 _timestamp, const Signature::PublicKey *_creatorPublicKey, const Signature::PublicKey *_userToAddPublicKey, const DataView &_groupToAddUserTo) : 
            nodeHash(_nodeHash),
            requestHash(_requestHash),
            timestamp(_timestamp),
            creatorPublicKey(_creatorPublicKey),
            userToAddPublicKey(_userToAddPublicKey),
            groupToAddUserTo(_groupToAddUserTo),
            loadedFromCache(false)
        {

        }
    };
    
    class DatabaseCreateResponse
    {
    public:
        DatabaseCreateResponse(std::shared_ptr<Signature::KeyPair> nodeAdminKeyPair, std::shared_ptr<OwnedByteArray> nodeAdminGroupId, std::shared_ptr<OwnedByteArray> key, std::shared_ptr<Hash> hash);
        
        const std::shared_ptr<Signature::KeyPair> getNodeAdminKeyPair() const;
        const std::shared_ptr<OwnedByteArray> getNodeAdminGroupId() const;
        const std::shared_ptr<OwnedByteArray> getNodeEncryptionKey() const;
        const std::shared_ptr<Hash> getRequestHash() const;
    private:
        std::shared_ptr<Signature::KeyPair> nodeAdminKeyPair;
        std::shared_ptr<OwnedByteArray> nodeAdminGroupId;
        std::shared_ptr<OwnedByteArray> key;
        std::shared_ptr<Hash> hash;
    };
    
    struct DatabaseSeedInfo
    {
        std::shared_ptr<std::future<size_t>> newDataListenerFuture;
        std::shared_ptr<std::future<size_t>> responseKeyFuture;
        std::shared_ptr<std::future<size_t>> requestOldDataListenerFuture;
        
        std::shared_ptr<dht::InfoHash> reponseKeyInfoHash;
        
        DatabaseSeedInfo(){}
        DatabaseSeedInfo(const DatabaseSeedInfo &other)
        {
            newDataListenerFuture = other.newDataListenerFuture;
            responseKeyFuture = other.responseKeyFuture;
            requestOldDataListenerFuture = other.requestOldDataListenerFuture;
            reponseKeyInfoHash = other.reponseKeyInfoHash;
        }
        DatabaseSeedInfo& operator=(const DatabaseSeedInfo &other)
        {
            newDataListenerFuture = other.newDataListenerFuture;
            responseKeyFuture = other.responseKeyFuture;
            requestOldDataListenerFuture = other.requestOldDataListenerFuture;
            reponseKeyInfoHash = other.reponseKeyInfoHash;
            return *this;
        }
    };

    using CreateNodeCallbackFunc = std::function<void(const DatabaseCreateNodeRequest&)>;
    using AddNodeCallbackFunc = std::function<void(const DatabaseAddNodeRequest&)>;
    using AddUserCallbackFunc = std::function<void(const DatabaseAddUserRequest&)>;
    
    using ReceiveCustomMessageCallbackFunc = std::function<sibs::SafeSerializer(const void *data, usize size)>;
    using SendCustomMessageCallbackFunc = std::function<bool(bool gotResponse, const void *data, usize size)>;

    struct DatabaseCallbackFuncs
    {
        CreateNodeCallbackFunc createNodeCallbackFunc;
        AddNodeCallbackFunc addNodeCallbackFunc;
        AddUserCallbackFunc addUserCallbackFunc;
    };

    class Database
    {
        DISABLE_COPY(Database)
        friend class DatabaseStorage;
    public:
        Database(const char *bootstrapNodeAddr, u16 port, const boost::filesystem::path &storageDir, DatabaseCallbackFuncs callbackFuncs);
        ~Database();

        // Safe to call multiple times with same node hash, will be ignored if the node is already beeing seeded
        void seed(const DatabaseNode &nodeToSeed, DatabaseFetchOrder fetchOrder = DatabaseFetchOrder::OLDEST_FIRST);
        void stopSeeding(const Hash &nodeHash);
        void loadNode(const Hash &nodeHash, DatabaseLoadOrder loadOrder = DatabaseLoadOrder::OLDEST_FIRST);
        
        // Throws DatabaseCreateException on failure.
        std::unique_ptr<DatabaseCreateResponse> create();
        // Throws PermissionDeniedException if user @userToPerformActionWith is not allowed to add data to node
        void addData(const DatabaseNode &nodeInfo, const Signature::KeyPair &userToPerformActionWith, DataView dataToAdd);
        // Throws PermissionDeniedException if user @userToPerformActionWith is not allowed to add user @userToAdd to group @groupToAddUserTo
        void addUser(const DatabaseNode &nodeInfo, const Signature::KeyPair &userToPerformActionWith, const Signature::PublicKey &userToAddPublicKey, const DataView &groupToAddUserTo);
        
        static ntp::NtpTimestamp getSyncedTimestampUtc();
        
        bool doesStoredUserExist(const std::string &username) const;
        
        // Throws SqlExecException if user with same name already exists
        void storeUserWithoutNodes(const std::string &username, const std::string &password);
        
        // Username has to be either unique or if it's the same as existing one, then password has to match.
        // Node has to be unique for the user.
        // Throws DatabaseStorageWrongPassword or SqlExecException on failure (if username is not unique in node).
        void storeNodeInfoForUserEncrypted(const DatabaseNode &nodeInfo, const std::string &username, const std::string &password, const Signature::KeyPair &keyPair);
        
        // Returns nodes, node encryption key, public key and private key of encrypted user.
        // Throws DatabaseStorageWrongPassword if password for the stored user is wrong.
        MapHash<StoredNodeInfo> getStoredNodeUserInfoDecrypted(const std::string &username, const std::string &password) const;
        
        std::vector<OwnedByteArray> getUserGroups(const Hash &nodeHash, const Signature::PublicKey &userPublicKey) const;

        // Returns -1 on failure
        int getUserLowestPermissionLevel(const Hash &nodeHash, const Signature::PublicKey &userPublicKey) const;
        
        std::future<size_t> receiveCustomMessage(const dht::InfoHash &requestKey, ReceiveCustomMessageCallbackFunc callbackFunc);
        
        void sendCustomMessage(const dht::InfoHash &key, std::vector<u8> &&data);
        
        // Return true in @callbackFunc if you want to continue listening for responses, otherwise return false
        std::future<size_t> sendCustomMessage(const dht::InfoHash &key, std::vector<u8> &&data, SendCustomMessageCallbackFunc callbackFunc);
        
        void cancelNodeListener(const dht::InfoHash &infoHash, std::future<size_t> &nodeListener);
        
        int clearCache();
        
        static dht::InfoHash getInfoHash(const void *data, usize size);
    private:
        void sendOldDataToPeer(const DatabaseNode nodeToSeed, const std::shared_ptr<dht::InfoHash> requestResponseInfoHash, const std::shared_ptr<dht::Value> value, usize valueOffset);
        void deserializeCreateRequest(const std::shared_ptr<dht::Value> &value, const Hash &hash, const std::shared_ptr<OwnedByteArray> encryptionKey);
        void deserializeAddRequest(const std::shared_ptr<dht::Value> &value, const Hash &requestDataHash, const std::shared_ptr<Hash> &nodeHash, const std::shared_ptr<OwnedByteArray> encryptionKey);
        bool listenCreateData(std::shared_ptr<dht::Value> value, const Hash &hash, const std::shared_ptr<OwnedByteArray> encryptionKey);
        bool listenAddData(std::shared_ptr<dht::Value> value, const Hash &requestDataHash, const std::shared_ptr<Hash> nodeHash, const std::shared_ptr<OwnedByteArray> encryptionKey);
    private:
        dht::DhtRunner node;
        DatabaseStorage databaseStorage;
        std::function<void(const DatabaseCreateNodeRequest&)> onCreateNodeCallbackFunc;
        std::function<void(const DatabaseAddNodeRequest&)> onAddNodeCallbackFunc;
        std::function<void(const DatabaseAddUserRequest&)> onAddUserCallbackFunc;
        MapHash<DatabaseSeedInfo> seedInfoMap;
        std::thread remoteNodesSaveThread;
        bool shuttingDown;
    };
}