#pragma once

#include "Variable.h"
#include <string>
#include <utility>
#include <query/Command.h>
#include <BasicChannel.h>
#include <Error.h>
#include <netinet/in.h>
#include "src/VirtualServer.h"
#include "../Group.h"

#define DEBUG_PERMISSION

namespace ts {
    namespace music {
        class MusicBotManager;
    }
    namespace server {
        class VirtualServer;

        class DataClient {
                friend class VirtualServer;
                friend class QueryServer;
                friend class music::MusicBotManager;
            public:
                struct PropertyWrapper {
                     std::shared_ptr<PropertyManager> handle;

                    PropertyManager* operator->() {
                        return handle.get();
                    }

                    const PropertyManager* operator->() const {
                        return handle.get();
                    }

                    template<class F>
                    std::result_of_t<F(PropertyManager &)> operator->*(F &&f) {
                        return std::forward<F>(f)(*handle);
                    }

                    template<class F>
                    std::result_of_t<F(PropertyManager const &)> operator->*(F &&f) const {
                        return std::forward<F>(f)(*handle);
                    }

                    /*
                    template <typename T>
                    ts::PropertyWrapper operator[](T type) {
                        return (*handle)[type];
                    }
                    */

                    template <typename T>
                    ts::Property operator[](const T& type) {
                        return (*handle)[type];
                    }
                };

                DataClient(sql::SqlManager*, const std::shared_ptr<VirtualServer>&);
                virtual ~DataClient();


                PropertyWrapper properties(){ return { this->_properties }; }

                /* main permission calculate function */
                /**
                 * Calculate the given permissions.
                 * This method can be called from everywhere without any locking needed.
                 * @param channel
                 * @param granted
                 * @param cache
                 * @return
                 */
                permission::v2::PermissionFlaggedValue calculate_permission(
                        permission::PermissionType,
                        ChannelId channel,
                        bool granted = false,
                        std::shared_ptr<CalculateCache> cache = nullptr
                );

                /**
                 * Calculate the given permissions.
                 * This method can be called from everywhere without any locking needed.
                 * @param channel
                 * @param granted
                 * @param cache
                 * @return
                 */
                std::vector<std::pair<permission::PermissionType, permission::v2::PermissionFlaggedValue>> calculate_permissions(
                        const std::deque<permission::PermissionType>&,
                        ChannelId channel,
                        bool granted = false,
                        std::shared_ptr<CalculateCache> cache = nullptr
                );

                virtual std::vector<std::shared_ptr<GroupAssignment>> assignedServerGroups();
                virtual std::shared_ptr<GroupAssignment> assignedChannelGroup(const std::shared_ptr<BasicChannel> &);
                virtual bool serverGroupAssigned(const std::shared_ptr<Group> &);
                virtual bool channelGroupAssigned(const std::shared_ptr<Group> &, const std::shared_ptr<BasicChannel> &);

                virtual std::string getDisplayName() { return this->properties()[property::CLIENT_NICKNAME]; }
                virtual std::string getLoginName() { return this->properties()[property::CLIENT_LOGIN_NAME]; }
                virtual void setDisplayName(std::string displayName) { this->properties()[property::CLIENT_NICKNAME] = displayName; }


                virtual ClientType getExternalType(){
                    uint8_t type = this->properties()[property::CLIENT_TYPE];
                    return (ClientType) type;
                }

                virtual ClientType getType(){
                    uint8_t type = this->properties()[property::CLIENT_TYPE_EXACT];
                    return (ClientType) type;
                }

                virtual std::string getUid() { return this->properties()[property::CLIENT_UNIQUE_IDENTIFIER]; }
                virtual std::string getAvatarId();
                virtual ClientDbId getClientDatabaseId() { return this->properties()[property::CLIENT_DATABASE_ID]; }


                virtual bool loadDataForCurrentServer();
            protected:
                sql::SqlManager* sql;
                std::shared_ptr<VirtualServer> server;

                std::shared_ptr<permission::v2::PermissionManager> clientPermissions = nullptr;
                std::shared_ptr<PropertyManager> _properties;

                std::shared_ptr<BasicChannel> currentChannel = nullptr;
        };
    }
}