// AF_INET: On veut de l'IPv4.
// SOCK_STREAM: On veut du TCP.
// 0: Protocole par défaut (TCP pour SOCK_STREAM).
int sock_listen = socket(AF_INET, SOCK_STREAM, 0);
if (sock_listen < 0) {
    // Si ça rate, on ne peut rien faire.
    std::cerr << "Erreur : échec de la création du socket\n";
    return EXIT_FAILURE;
}

sockaddr_in addr;
addr.sin_family = AF_INET; // On confirme : IPv4
addr.sin_port = htons(8080); // Le port. htons() gère le "byte order" (Big Endian)
inet_pton(AF_INET, "0.0.0.0", &addr.sin_addr); // On écoute sur toutes les interfaces

if (bind(sock_listen, (sockaddr*)&addr, sizeof(addr)) < 0) {
    std::cerr << "Erreur : échec du bind (le port est peut-être déjà pris)\n";
    return EXIT_FAILURE;
}

// SOMAXCONN: Taille de la file d'attente pour les connexions
if (listen(sock_listen, SOMAXCONN) < 0) {
    std::cerr << "Erreur : échec de l’écoute\n";
    return EXIT_FAILURE;
}

fd_set master_set; // La liste permanente de TOUS les sockets (serveur + clients)
fd_set read_fds;   // Une copie temporaire que select() va modifier
int fdmax;         // Le numéro du plus grand socket (pour optimiser la boucle)

FD_ZERO(&master_set); // On vide la liste
FD_ZERO(&read_fds);

// On ajoute le seul socket qu'on a pour l'instant : celui qui écoute
FD_SET(sock_listen, &master_set);
fdmax = sock_listen; // Pour l'instant, c'est lui le max

std::cout << "Serveur en attente de connexions..." << std::endl;

while (true) {
    // select() est destructif : il modifie le 'read_fds' qu'on lui donne.
    // On lui passe donc une copie de notre liste 'master' à chaque tour.
    read_fds = master_set;

    // C'est ici que le serveur "dort" et attend que quelque chose se passe.
    // Il attend qu'un des sockets dans 'read_fds' devienne "prêt à lire".
    if (select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1) {
        std::cerr << "Erreur select()" << std::endl;
        break;
    }

    // Si on arrive ici, c'est que select() s'est réveillé
    // Au moins un socket a bougé. On doit trouver lequel.
    // On parcourt tous les sockets possibles, de 0 jusqu'au plus grand (fdmax).
    for (int i = 0; i <= fdmax; i++) {

        // FD_ISSET : Est-ce que le socket 'i' est dans la liste
        // des sockets qui sont "prêts" ?
        if (FD_ISSET(i, &read_fds)) {

            // Si le socket prêt, c'est notre socket d'écoute...
            if (i == sock_listen) {
                sockaddr_in client_addr;
                socklen_t len = sizeof(client_addr);
                int sock_client = accept(sock_listen, (sockaddr*)&client_addr, &len);

                if (sock_client < 0) {
                    std::cerr << "Erreur accept()" << std::endl;
                } else {
                    // On l'ajoute à notre liste 'master' pour le surveiller
                    FD_SET(sock_client, &master_set); 
                    if (sock_client > fdmax)
                        fdmax = sock_client; // On met à jour le max si besoin

                    std::cout << "Nouvelle connexion (fd=" << sock_client << ")" << std::endl;

                    // C'est ici qu'on initialise ce client dans nos maps C++
                    // Ex: client_authenticated[sock_client] = false;
                    // Ex: client_buffer[sock_client] = "";
                }
            } 

            else {
                // Le socket 'i' est un client qui nous envoie un message.
                // On passe la main à une fonction qui gère la réception.
                handleClientData(i, master_set, fdmax);
            }
        }
    }
}

void handleClientData(int client_fd, fd_set& master_set, int& fdmax) {
    char buffer[4096]; // Un buffer temporaire pour ce recv()
    int bytes = recv(client_fd, buffer, sizeof(buffer), 0);

    // Si recv() renvoie 0, le client a fermé la connexion (Ctrl+C).
    // Si recv() renvoie -1, c'est une erreur.
    if (bytes <= 0) {
        if (bytes == 0)
            std::cout << "Client (fd=" << client_fd << ") déconnecté." << std::endl;
        else
            std::cerr << "Erreur recv()" << std::endl;

        close(client_fd); // On ferme son socket
        FD_CLR(client_fd, &master_set);

        // C'est ici qu'on appelle la logique de QUIT
    }

    else {
        // On ajoute les données brutes au buffer PERSISTANT de CE client
        client_buffer[client_fd].append(buffer, bytes);

        // On traite le buffer. On cherche des commandes complètes
        //    (terminées par \r\n) TANT QU'IL Y EN A.
        size_t eol_pos;
        while ((eol_pos = client_buffer[client_fd].find("\r\n")) != std::string::npos) {

            // On extrait la commande complète
            std::string command = client_buffer[client_fd].substr(0, eol_pos);

            // On la SUPPRIME du buffer (très important)
            //     On garde le reste (ex: une moitié de commande suivante)
            client_buffer[client_fd].erase(0, eol_pos + 2); // +2 pour virer \r\n

            // On la traite ENFIN !
            if (!command.empty()) {
                handleClientMessage(client_fd, command);
            }
            // La boucle 'while' recommence direct, pour voir s'il y avait
            // une 2ème commande collée (ex: "NICK...\r\nUSER...\r\n")
        }
    }
}

void handleClientMessage(int client_fd, const std::string& message) {
    std::cout << "Reçu de (fd=" << client_fd << "): " << message << std::endl;

    // On check si la ligne COMMENCE par "NICK "
    if (message.rfind("NICK ", 0) == 0) {
        // handleNick(client_fd, message);
    } 
    else if (message.rfind("USER ", 0) == 0) {
        // handleUser(client_fd, message);
    }
    else if (message.rfind("PASS ", 0) == 0) {
        // handlePass(client_fd, message);
    }
    else if (message.rfind("JOIN ", 0) == 0) {
        // handleJoin(client_fd, message);
    }
    // ... etc
}

// Format: :<nom_serveur> <CODE> <nick> :<message>
void sendReply(int client_fd, const std::string& code, const std::string& nickname, const std::string& message) {
    // Ex: ":irc.nathaan.me 001 nathan :Welcome to the ft_irc server!\r\n"
    std::string reply = ":" + SERVER_NAME + " " + code + " " + nickname + " :" + message + "\r\n";

    // On envoie la réponse au client
    if (send(client_fd, reply.c_str(), reply.length(), 0) < 0) {
        std::cerr << "Erreur send()" << std::endl;
    }
}

// ...
// Et dans la logique, APRÈS que NICK, USER et PASS soient validés :
// sendReply(client_fd, "001", "nathan", "Welcome to the ft_irc server!");
// sendReply(client_fd, "002", "nathan", "Your host is ..., running version X");
// sendReply(client_fd, "003", "nathan", "This server was created ...");
// sendReply(client_fd, "004", "nathan", "...");