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

namespace Chattr {

class ClientManager {
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) {
            sock_.init(AF_INET);
            serveraddr.set(AF_INET, config.IP, config.Port);
        }
        else if (config.ipVersion == 6) {
            sock_.init(AF_INET6);
            serveraddr.set(AF_INET6, config.IP, config.Port);
        }

        if (sock_.connect(serveraddr) == INVALID_SOCKET) {
            spdlog::error("{}", strerror(errno));
            return;
        }

        data_ = new IOCPPASSINDATA;
        ::memset(&data_->overlapped, 0, sizeof(OVERLAPPED));
        data_->socket = std::make_shared<TCPSocket>(std::move(sock_));
        data_->recvbytes = data_->sendbytes = 0;
        data_->wsabuf.buf = data_->buf;
        data_->wsabuf.len = 1500;
        data_->IOCPInstance = &iocp_;
        iocp_.registerSocket(data_);

        spdlog::info("Connection established from [{}]", (std::string)serveraddr);
	}

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

    void processresponsePacket(ResponsePacket responsePacket, IOCPPASSINDATA* data);
    void processRoomCreateResponsePacket(RoomCreateResponsePacket roomCreateResponsePacket, IOCPPASSINDATA* data);
    void processRoomListResponse(RoomListResponsePacket roomListResponsePacket, IOCPPASSINDATA* data);
    void processRoomJoinResponsePacket(RoomJoinResponsePacket roomJoinResponsePacket, IOCPPASSINDATA* data);
    void processRoomExitResponsePacket(RoomExitResponsePacket roomExitResponsePacket, IOCPPASSINDATA* data);
    void processUsersListResponsePacket(UsersListResponsePacket usersListResponsePacket, IOCPPASSINDATA* data);
    void processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA* data);
    void processContinuePacket(ContinuePacket continuePacket, IOCPPASSINDATA* data);

    void registerUser(std::string userName);
    void deleteUser(Snowflake UID);
    std::vector<std::pair<Snowflake, std::string>> getUserList();

    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_;

    Snowflake myID_;
    Snowflake myRoomID_;

    IOCPPASSINDATA* data_;

    bool inRoom_ = false;

    TCPSocket sock_;

    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_;
};

}