#include "Socket/TCPSocket.hpp"
#include "Socket/Address.hpp"
#include "Socket/Log.hpp"
#include "Packet/Packet.hpp"
#include "Utils/Snowflake.hpp"
#include "precomp.hpp"

int main() {
    Chattr::TCPSocket sock;
    sock.init(AF_INET6);

    Chattr::Address serveraddr(AF_INET6, "::1", 9011);

    if (sock.connect(serveraddr) == INVALID_SOCKET) {
        spdlog::error("{}", strerror(errno));
        return 0;
    }
    spdlog::info("Connection established from {}", (std::string)serveraddr);

    Chattr::Snowflake myId;

    Chattr::LoginRequestPacket loginRequestPacket;
    loginRequestPacket.__data.packetType = Chattr::PacketCategory::PACKET_REQUEST;
    loginRequestPacket.__data.requestType = Chattr::RequestType::LOGIN;
    loginRequestPacket.__data.dataType = Chattr::DataType::BINARY;
    loginRequestPacket.__data.packetLength = 14;
    memcpy(loginRequestPacket.__data.data, "Hello, World!", 14);
    loginRequestPacket.convToN();
    sock.send(loginRequestPacket.serialized, 8 + 14, 0);

    Chattr::LoginResponsePacket loginResponsePacket;
    sock.recv(loginResponsePacket.serialized, 18, 0);
    loginResponsePacket.convToH();
    ::memcpy(&myId, loginResponsePacket.__data.yourId, sizeof(Chattr::Snowflake));

    Chattr::UsersListRequestPacket usersListRequestPacket;
    usersListRequestPacket.__data.packetType = Chattr::PacketCategory::PACKET_REQUEST;
    usersListRequestPacket.__data.requestType = Chattr::RequestType::USERS_LIST;
    usersListRequestPacket.__data.dataType = Chattr::DataType::TEXT;
    usersListRequestPacket.__data.packetLength = 0;
    usersListRequestPacket.convToN();
    sock.send(usersListRequestPacket.serialized, 8, 0);

    std::vector<std::pair<Chattr::Snowflake, std::string>> users;

    Chattr::UsersListResponsePacket usersListResponsePacket;
    sock.recv(usersListResponsePacket.serialized, 8, 0);
    std::uint16_t dataLength = ::ntohs(usersListResponsePacket.__data.packetLength);
    sock.recv(usersListResponsePacket.serialized + 8, dataLength, 0);
    usersListRequestPacket.convToH();

    int usersCount = usersListResponsePacket.__data.usersCount;
    users.reserve(usersCount);
    Chattr::Snowflake userId;
    ::memcpy(&userId.snowflake, usersListResponsePacket.__data.userId, sizeof(Chattr::Snowflake));
    users.emplace_back(
        userId,
        std::string((char*)usersListResponsePacket.__data.name, usersListResponsePacket.__data.packetLength - 14)
    );

    for (int i = 0; i < usersCount - 1; i++) {
        sock.recv(usersListResponsePacket.serialized, 8, 0);
        std::uint16_t dataLength = ::ntohs(usersListResponsePacket.__data.packetLength);
        sock.recv(usersListResponsePacket.serialized + 8, dataLength, 0);
        usersListRequestPacket.convToH();

        ::memcpy(&userId.snowflake, usersListResponsePacket.__data.userId, sizeof(Chattr::Snowflake));
        users.emplace_back(
            userId,
            std::string((char*)usersListResponsePacket.__data.name, usersListResponsePacket.__data.packetLength - 14)
        );
    }

    Chattr::DataPostPacket dataPostPacket;
    dataPostPacket.__data.packetType = Chattr::PacketCategory::PACKET_POST;
    dataPostPacket.__data.requestType = Chattr::RequestType::DATA;
    dataPostPacket.__data.dataType = Chattr::DataType::TEXT;
    dataPostPacket.__data.packetLength = 14 + 8;
    for (auto user : users)
        if (user.first != myId) {
            ::memcpy(dataPostPacket.__data.destId, &user.first.snowflake, sizeof(Chattr::Snowflake));
            break;
        }
    memcpy(dataPostPacket.__data.data, "Hello, World!", 14);
    dataPostPacket.convToN();
    sock.send(&dataPostPacket.serialized, 6 + 14 + 8, 0);

    Chattr::ResponsePacket packet;
    sock.recv(&packet.serialized, 10, 0);
    packet.convToH();

    sleep(1000000);
}