#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) {
        roomNames_ = std::future<std::unordered_map<Snowflake, std::string>>();
        findRoomId_ = std::future<std::unordered_map<std::string, Snowflake>>();
        userNames_ = std::future<std::unordered_map<Snowflake, std::string>>();
        findUserId_ = std::future<std::unordered_map<std::string, Snowflake>>();

		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));
            std::exit(EXIT_FAILURE);
        }

        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 processLoginResponsePacket(LoginResponsePacket loginResponsePacket, 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 sendMessage(Snowflake ID, std::string message);

    void registerUser(std::string userName);
    void deleteUser(Snowflake UID);
    void getUserList();

    void createRoom(std::string roomName);
    void deleteRoom(Snowflake RID);
    void 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;

    std::future<ResponsePacket> lastResponsePacket_;

    TCPSocket sock_;

    std::mutex resourceMutex_;
    std::mutex screenMutex_;

    std::queue<std::string> messageQueue_;
    std::vector<std::string> messageHistory_;

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

    std::future<std::unordered_map<Snowflake, std::string>> userNames_;
    std::future<std::unordered_map<std::string, Snowflake>> findUserId_;
};

}