#pragma once

#include <sql/SqlQuery.h>
#include <Properties.h>
#include "ServerManager.h"
#include "../../license/shared/LicenseRequest.h"
#include "lincense/LicenseHelper.h"
#include <ssl/SSLManager.h>
#include "manager/SqlDataManager.h"
#include "lincense/TeamSpeakLicense.h"
#include "server/WebIoManager.h"

namespace ts {
	namespace weblist {
		class WebListManager;
	}

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

                bool startInstance();
                void stopInstance();

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

                std::shared_ptr<ts::server::InternalClient> getInitalServerAdmin(){ 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; }

                ServerManager* getVoiceServerManager(){ return this->voiceServerManager; }
                FileServer* getFileServer(){ return fileServer; }
                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(); }

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

                void executeTick(TSServer*);
                void cancelExecute(TSServer*);

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

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

		        bool resetMonthlyStats();

		        std::shared_ptr<stats::ConnectionStatistics> getStatistics(){ return statistics; }
		        std::shared_ptr<threads::Scheduler> scheduler(){ return this->tick_manager; }
		        std::shared_ptr<license::LicenseRequestData> 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; }
            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;

                FileServer* fileServer = nullptr;
                QueryServer* queryServer = nullptr;
                ServerManager* voiceServerManager = nullptr;
                DatabaseHelper* dbHelper = nullptr;
		        BanManager* banMgr = nullptr;
		        ssl::SSLManager* sslMgr = nullptr;

                ts::Properties* _properties = 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::LicenseHelper> licenseHelper = nullptr;
		        std::shared_ptr<stats::ConnectionStatistics> statistics = nullptr;
                std::shared_ptr<threads::Scheduler> tick_manager = nullptr;

                std::shared_ptr<TeamSpeakLicense> teamspeak_license = nullptr;

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

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