#pragma once
#include "Utils/ThreadPool.hpp"
#include "Utils/ConfigManager.hpp"
#include "Socket/IOCP.hpp"
#include "Packet/Packet.hpp"

namespace Chattr {

class ServerManager {
public:
    void _IOCPClient(ThreadPool* thread, IOCPPASSINDATA* data);

    PacketSet packetParser(Packet Packet);

	template<typename _Callable>
	void init(_Callable _IOCPClient) {
		auto config = ConfigManager::load();
		log::setDefaultLogger(config.logLevel, config.logFileName, config.logfileSize, config.logfileCount);
		threadPool_.init(0);
		iocp_.init(&threadPool_, _IOCPClient);

        struct Address serveraddr;
        if (config.ipVersion == 4) {
            listenSock_.init(AF_INET);
            serveraddr.set(AF_INET, config.IP, config.Port);
            clientAddr_.setType(AF_INET);
        }
        else if (config.ipVersion == 6) {
            listenSock_.init(AF_INET6);
            serveraddr.set(AF_INET6, config.IP, config.Port);
            clientAddr_.setType(AF_INET6);
        }
        listenSock_.bind(serveraddr);
        listenSock_.listen(SOMAXCONN);
        
        spdlog::info("Server listening on [{}]", (std::string)serveraddr);
	}

    void init() {
        init([this](ThreadPool* thread, IOCPPASSINDATA* data) {
            this->_IOCPClient(thread, data);
        });
    }

    void processLoginRequestPacket(LoginRequestPacket loginRequestPacket, IOCPPASSINDATA* data);
    void processRoomCreateRequestPacket(RoomCreateRequestPacket roomCreateRequestPacket, IOCPPASSINDATA* data);
    void processRoomListRequest(RoomListRequestPacket roomListRequestPacket, IOCPPASSINDATA* data);
    void processRoomJoinRequestPacket(RoomJoinRequestPacket roomJoinRequestPacket, IOCPPASSINDATA* data);
    void processRoomExitRequestPacket(RoomExitRequestPacket roomExitRequestPacket, IOCPPASSINDATA* data);
    void processUsersListRequestPacket(UsersListRequestPacket usersListRequestPacket, IOCPPASSINDATA* data);
    void processUsersListInRoomRequestPacket(RoomUsersListRequestPacket roomUsersListRequestPacket, IOCPPASSINDATA* data);
    void processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA* data);
    void processContinuePacket(ContinuePacket continuePacket, IOCPPASSINDATA* data);

    bool registerUser(std::string userName, std::shared_ptr<TCPSocket> sock);
    void deleteUser(Snowflake UID);
    std::vector<std::pair<Snowflake, std::string>> getUserList();
    std::vector<std::pair<Snowflake, std::string>> getUserListInRoom(Snowflake RID);

    Snowflake createRoom(std::string roomName);
    void deleteRoom(Snowflake RID);
    std::vector<std::pair<Snowflake, std::string>> getRoomList();

    void joinRoom(Snowflake UID, Snowflake RID);
    void exitRoom(Snowflake UID, Snowflake RID);

	void run();
private:
	ThreadPool threadPool_;
	IOCP iocp_;

    TCPSocket listenSock_;

    TCPSocket clientSock_;
    struct Address clientAddr_;

    std::mutex resourceMutex_;

    std::unordered_map<Snowflake, std::string> roomNames_;

    std::unordered_map<Snowflake, std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>>> rooms_;

    std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>> UID2userSocket_;
    std::unordered_map<std::shared_ptr<TCPSocket>, Snowflake> userSocket2UID_;

    std::unordered_map<Snowflake, std::string> userNames_;
    std::unordered_map<std::string, Snowflake> userName2ID_;

};

}