#pragma once

#include <sql/SqlQuery.h>
#include <Properties.h>
#include "VirtualServerManager.h"
#include <ssl/SSLManager.h>
#include <src/lincense/LicenseService.h>
#include "manager/SqlDataManager.h"
#include "lincense/TeamSpeakLicense.h"
#include "server/WebIoManager.h"
#include <misc/task_executor.h>

namespace ts {
    namespace weblist {
        class WebListManager;
    }

    namespace permission {
        class PermissionNameMapper;
    }

    namespace server {
        namespace license {
            class LicenseService;
        }

        namespace file {
            class FileServerHandler;
        }

        namespace log {
            class ActionLogger;
        }

        class ServerCommandExecutor;

        class InstanceHandler {
            public:
                explicit InstanceHandler(SqlDataManager*);
                ~InstanceHandler();

                bool startInstance();
                void stopInstance();

                ts::Properties& properties(){
                    return *_properties;
                }

                std::shared_ptr<ts::server::InternalClient> getInitialServerAdmin(){ return globalServerAdmin; }
                std::shared_ptr<ts::GroupManager> getGroupManager(){ return groupManager; }

                std::shared_ptr<ts::ServerChannelTree> getChannelTree() { return this->default_tree; }
                std::shared_mutex& getChannelTreeLock() { return this->default_tree_lock; }

                VirtualServerManager* getVoiceServerManager(){ return this->voiceServerManager; }
                QueryServer* getQueryServer(){ return queryServer; }
                DatabaseHelper* databaseHelper(){ return this->dbHelper; }
                BanManager* banManager(){ return this->banMgr; }
                ssl::SSLManager* sslManager(){ return this->sslMgr; }
                sql::SqlManager* getSql(){ return sql->sql(); }
                log::ActionLogger* action_logger() { return &*this->action_logger_; }
                file::FileServerHandler* getFileServerHandler() { return this->file_server_handler_; }

                std::chrono::time_point<std::chrono::system_clock> getStartTimestamp(){ return startTimestamp; }

                void executeTick(VirtualServer*);
                void cancelExecute(VirtualServer*);

                bool reloadConfig(std::vector<std::string>& /* errors */, bool /* reload file */);
                void setWebCertRoot(const std::string& /* key */, const std::string& /* certificate */, const std::string& /* revision */);

                const std::shared_ptr<ConnectedClient>& musicRoot() { return this->_musicRoot; }

                std::chrono::milliseconds calculateSpokenTime();
                void resetSpeechTime();

                bool resetMonthlyStats();

                [[nodiscard]] inline const auto& general_task_executor(){ return this->general_task_executor_; }

                std::shared_ptr<stats::ConnectionStatistics> getStatistics(){ return statistics; }
                std::shared_ptr<threads::Scheduler> scheduler(){ return this->tick_manager; }
                std::shared_ptr<license::InstanceLicenseInfo> generateLicenseData();

                std::shared_ptr<TeamSpeakLicense> getTeamSpeakLicense() { return this->teamspeak_license; }
                std::shared_ptr<ts::Properties> getDefaultServerProperties() { return this->default_server_properties; }
                std::shared_ptr<webio::LoopManager> getWebIoLoop() { return this->web_event_loop; }
                std::shared_ptr<weblist::WebListManager> getWebList() { return this->web_list; }

                std::shared_ptr<permission::PermissionNameMapper> getPermissionMapper() { return this->permission_mapper; }
                std::shared_ptr<ts::event::EventExecutor> getConversationIo() { return this->conversation_io; }

                [[nodiscard]] inline const auto& server_command_executor() { return this->server_command_executor_; }

                permission::v2::PermissionFlaggedValue calculate_permission(
                        permission::PermissionType,
                        ClientDbId,
                        ClientType type,
                        ChannelId channel,
                        bool granted = false,
                        std::shared_ptr<CalculateCache> cache = nullptr
                );

                std::vector<std::pair<permission::PermissionType, permission::v2::PermissionFlaggedValue>> calculate_permissions(
                        const std::deque<permission::PermissionType>&,
                        ClientDbId,
                        ClientType type,
                        ChannelId channel,
                        bool granted = false,
                        std::shared_ptr<CalculateCache> cache = nullptr
                );

                [[nodiscard]] inline std::shared_ptr<license::LicenseService> license_service() { return this->license_service_; }
            private:
                std::mutex activeLock;
                std::condition_variable activeCon;
                bool active = false;

                std::chrono::system_clock::time_point startTimestamp;
                std::chrono::system_clock::time_point sqlTestTimestamp;
                std::chrono::system_clock::time_point speachUpdateTimestamp;
                std::chrono::system_clock::time_point groupSaveTimestamp;
                std::chrono::system_clock::time_point channelSaveTimestamp;
                std::chrono::system_clock::time_point generalUpdateTimestamp;
                std::chrono::system_clock::time_point statisticsUpdateTimestamp;
                std::chrono::system_clock::time_point memcleanTimestamp;
                SqlDataManager* sql;

                QueryServer* queryServer = nullptr;
                VirtualServerManager* voiceServerManager = nullptr;
                DatabaseHelper* dbHelper = nullptr;
                BanManager* banMgr = nullptr;
                ssl::SSLManager* sslMgr = nullptr;
                file::FileServerHandler* file_server_handler_{nullptr};
                std::unique_ptr<log::ActionLogger> action_logger_{nullptr};

                ts::Properties* _properties = nullptr;

                std::shared_ptr<ServerCommandExecutor> server_command_executor_{};

                std::shared_ptr<ts::event::EventExecutor> conversation_io = nullptr;
                std::shared_ptr<webio::LoopManager> web_event_loop = nullptr;
                std::shared_ptr<weblist::WebListManager> web_list = nullptr;

                std::shared_ptr<ts::Properties> default_server_properties = nullptr;
                std::shared_ptr<ts::ServerChannelTree> default_tree = nullptr;
                std::shared_mutex default_tree_lock;
                std::shared_ptr<ts::GroupManager> groupManager = nullptr;

                std::shared_ptr<ts::server::InternalClient> globalServerAdmin = nullptr;
                std::shared_ptr<ConnectedClient> _musicRoot = nullptr;

                std::shared_ptr<license::LicenseService> license_service_{nullptr};
                std::shared_ptr<stats::ConnectionStatistics> statistics = nullptr;
                std::shared_ptr<threads::Scheduler> tick_manager = nullptr;

                std::shared_ptr<task_executor> general_task_executor_{nullptr};

                std::shared_ptr<permission::PermissionNameMapper> permission_mapper = nullptr;
                std::shared_ptr<TeamSpeakLicense> teamspeak_license = nullptr;

                std::string web_cert_revision{};

                threads::Mutex lock_tick;
            private:
                bool setupDefaultGroups();
                void tickInstance();

                void save_group_permissions();
                void save_channel_permissions();

                void loadWebCertificate();
        };
    }
}
extern ts::server::InstanceHandler* serverInstance;