#pragma once
#include <compare>
#include <memory>
#include <unordered_map>
#include <functional>
#include <cereal/archives/portable_binary.hpp>
#include <chrono>
#include <vector>
#include <Helpers/Random.hpp>
#include "../Networking/NetClient.hpp"
#include "../Networking/NetServer.hpp"
#include "../Networking/NetLibrary.hpp"
#include "Helpers/NetworkingObjects/NetObjID.hpp"
#include "NetObjManagerTypeList.hpp"
#include "NetObjOwnerPtr.decl.hpp"
#include "NetObjTemporaryPtr.decl.hpp"
#include "../Networking/NetServer.hpp"

namespace NetworkingObjects {
    class NetObjManager {
        public:
            NetObjManager(bool initIsServer);
            void read_update_message(cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& clientReceivedFrom);
            void read_many_update_message(cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& clientReceivedFrom);
            void set_client(std::shared_ptr<NetClient> initClient, MessageCommandType initUpdateCommandID, MessageCommandType initMultiUpdateCommandID);
            void set_server(std::shared_ptr<NetServer> initServer, MessageCommandType initUpdateCommandID, MessageCommandType initMultiUpdateCommandID);
            void disconnect();
            bool is_server() const;
            bool is_connected() const;
            void set_netid_reassign_callback(const std::function<void(const NetworkingObjects::NetObjID& oldID, const NetworkingObjects::NetObjID& newID)>& newNetIDReassignCallback);
            void set_netobj_destroy_callback(const std::function<void(const NetworkingObjects::NetObjID& netID)>& newDestroyCallback);
            template <typename T> NetObjOwnerPtr<T> read_create_message(cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& clientReceivedFrom) {
                NetObjID id;
                a(id);
                auto it = objectData.find(id);
                if(it != objectData.end())
                    throw std::runtime_error("[NetObjManager::read_create_message] Attempted to create an object with a used ID");
                NetObjOwnerPtr<T> newPtr = emplace_raw_ptr(id, static_cast<T*>(typeList.get_type_index_data<T>(isServer).allocatorFunc()));
                typeList.get_type_index_data<T>(isServer).readConstructorFunc(NetObjTemporaryPtr(newPtr).template cast<void>(), a, clientReceivedFrom);
                return newPtr;
            }
            template <typename T> NetObjTemporaryPtr<T> read_get_obj_temporary_ref_from_message(cereal::PortableBinaryInputArchive& a) {
                NetObjID id;
                a(id);
                auto it = objectData.find(id);
                if(it == objectData.end())
                    return NetObjTemporaryPtr<T>();
                return NetObjTemporaryPtr<T>(this, id, std::static_pointer_cast<T>(it->second.p));
            }

            enum class SendUpdateType {
                SEND_TO_ALL,
                SEND_TO_ALL_EXCEPT,
                SEND_TO_SPECIFIC_CLIENT
            };
            void send_multi_update_messsage(std::function<void()> captureSendBlock, SendUpdateType updateType, const std::shared_ptr<NetServer::ClientData>& specificClient);

            // NOTE: DO NOT USE THESE FUNCTIONS UNLESS SITUATION ISN'T NORMAL, EVERY OBJECT SHOULD HAVE A UNIQUE ID AND IDS SHOULDNT BE REUSED UNDER ANY CIRCUMSTANCES
            template <typename T> NetObjOwnerPtr<T> make_obj_with_specific_id(const NetObjID& id) {
                return emplace_raw_ptr<T>(id, static_cast<T*>(typeList.get_type_index_data<T>(isServer).allocatorFunc()));
            }
            template <typename T, typename... Args> NetObjOwnerPtr<T> make_obj_direct_with_specific_id(const NetObjID& id, Args&&... items) {
                return emplace_raw_ptr<T>(id, new T(items...));
            }

            template <typename T> NetObjOwnerPtr<T> make_obj() {
                return emplace_raw_ptr<T>(NetObjID::random_gen(), static_cast<T*>(typeList.get_type_index_data<T>(isServer).allocatorFunc()));
            }
            // Don't use this function unless you're sure that class T isn't a base class
            template <typename T, typename... Args> NetObjOwnerPtr<T> make_obj_direct(Args&&... items) {
                return emplace_raw_ptr<T>(NetObjID::random_gen(), new T(items...));
            }
            template <typename T> NetObjOwnerPtr<T> make_obj_from_ptr(T* p) {
                return emplace_raw_ptr<T>(NetObjID::random_gen(), p);
            }
            template <typename T> NetObjTemporaryPtr<T> get_obj_temporary_ref_from_id(NetObjID id) {
                auto it = objectData.find(id);
                if(it == objectData.end())
                    return NetObjTemporaryPtr<T>();
                return NetObjTemporaryPtr<T>(this, id, static_cast<T*>(it->second.p));
            }
            template <typename ClientT, typename ServerT, typename ClientAllocatedType, typename ServerAllocatedType> void register_class(const NetObjManagerTypeList::ServerClientClassFunctions<ClientT, ServerT>& funcs) {
                typeList.register_class<ClientT, ServerT, ClientAllocatedType, ServerAllocatedType>(funcs);
            }
        private:
            void send_update_data_by_type(const std::string& channel, const std::shared_ptr<std::stringstream>& ss, SendUpdateType updateType, const std::shared_ptr<NetServer::ClientData>& specificClient);

            template <typename T> NetObjOwnerPtr<T> emplace_raw_ptr(NetObjID id, T* rawPtr) {
                if(!objectData.emplace(id, SingleObjectData{.netTypeID = typeList.get_type_index_data<T>(isServer).netTypeID, .p = rawPtr}).second)
                    throw std::runtime_error("[NetObjManager::emplace_raw_ptr] ID Collision");
                return NetObjOwnerPtr<T>(this, id, rawPtr);
            }

            template <typename T> static void send_update_to_all(const NetObjTemporaryPtr<T>& ptr, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
                if(ptr.get_obj_man()->isServer)
                    NetObjManager::send_server_update_to_all_clients(ptr, channel, sendUpdateFunc);
                else
                    NetObjManager::send_client_update(ptr, channel, sendUpdateFunc);
            }

            template <typename T> static void send_client_update(const NetObjTemporaryPtr<T>& ptr, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
                auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
                if(ss)
                    ptr.get_obj_man()->client->send_string_stream_to_server(channel, ss);
            }

            template <typename T> static void send_server_update_to_client(const NetObjTemporaryPtr<T>& ptr, const std::shared_ptr<NetServer::ClientData>& clientToSendTo, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
                if(clientToSendTo) {
                    auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
                    if(ss)
                        ptr.get_obj_man()->server->send_string_stream_to_client(clientToSendTo, channel, ss);
                }
            }

            template <typename T> static void send_server_update_to_all_clients_except(const NetObjTemporaryPtr<T>& ptr, const std::shared_ptr<NetServer::ClientData>& clientToNotSendTo, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
                auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
                if(ss)
                    ptr.get_obj_man()->server->send_string_stream_to_all_clients_except(clientToNotSendTo, channel, ss);
            }

            template <typename T> static void send_server_update_to_all_clients(const NetObjTemporaryPtr<T>& ptr, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
                auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
                if(ss)
                    ptr.get_obj_man()->server->send_string_stream_to_all_clients(channel, ss);
            }

            template <typename T> static std::shared_ptr<std::stringstream> send_update_general_check_for_multi_update(const std::string& channel, const NetObjTemporaryPtr<T>& ptr, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
                if(ptr.get_obj_man()->is_connected()) {
                    std::shared_ptr<MultiUpdateData> mData = ptr.get_obj_man()->multiUpdateData.lock();
                    if(mData) {
                        mData->channelToSendTo = channel;
                        (*mData->outArchive)(true, ptr.get_net_id());
                        sendUpdateFunc(ptr, *mData->outArchive);
                        return nullptr;
                    }
                    else {
                        auto ss(std::make_shared<std::stringstream>(std::ios::binary | std::ios::out));
                        {
                            cereal::PortableBinaryOutputArchive m(*ss);
                            m(ptr.get_obj_man()->updateCommandID, ptr.get_net_id());
                            sendUpdateFunc(ptr, m);
                        }
                        return ss;
                    }
                }
                return nullptr;
            }

            template <typename T> static void write_create_message(const NetObjTemporaryPtr<T>& ptr, cereal::PortableBinaryOutputArchive& a) {
                a(ptr.get_net_id());
                ptr.get_obj_man()->typeList.template get_type_index_data<T>(ptr.get_obj_man()->isServer).writeConstructorFunc(ptr.template cast<void>(), a);
            }

            template <typename T> friend class NetObjOwnerPtr;
            template <typename T> friend class NetObjTemporaryPtr;
            template <typename T> friend class NetObjWeakPtr;

            struct SingleObjectData {
                NetTypeIDType netTypeID;
                void* p;
            };

            struct MultiUpdateData {
                std::string channelToSendTo;
                std::shared_ptr<std::stringstream> ss;
                std::unique_ptr<cereal::PortableBinaryOutputArchive> outArchive;
            };
            std::weak_ptr<MultiUpdateData> multiUpdateData;

            bool isServer;
            std::shared_ptr<NetClient> client;
            std::shared_ptr<NetServer> server;
            MessageCommandType updateCommandID;
            MessageCommandType multiUpdateCommandID;
            std::unordered_map<NetObjID, SingleObjectData> objectData;
            NetObjManagerTypeList typeList;
            NetTypeIDType nextTypeID;
            std::function<void(const NetworkingObjects::NetObjID& oldID, const NetworkingObjects::NetObjID& newID)> netIDReassignCallback;
            std::function<void(const NetworkingObjects::NetObjID& netID)> destroyCallback;
    };
}