// Tạo socket
int serverSocket = socket(AF_INET, SOCK_STREAM, 0);

// Cấu hình địa chỉ server
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;        // IPv4
serverAddr.sin_addr.s_addr = INADDR_ANY; // Lắng nghe tất cả interfaces
serverAddr.sin_port = htons(8888);      // Port 8888

// Bind socket với địa chỉ
bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

// Lắng nghe kết nối (queue tối đa 5 pending connections)
listen(serverSocket, 5);

while (isRunning) {
    struct sockaddr_in clientAddr;
    socklen_t clientLen = sizeof(clientAddr);
    
    // Chờ và chấp nhận kết nối mới
    int clientSocket = accept(serverSocket, 
                             (struct sockaddr*)&clientAddr, 
                             &clientLen);
    
    if (clientSocket >= 0) {
        // Lưu client socket để broadcast tin nhắn
        clientSockets.push_back(clientSocket);
        
        // Tạo thread riêng để xử lý client này
        std::thread(&ChatSocket::handleClient, this, clientSocket).detach();
    }
}

void handleClient(int clientSocket) {
    char buffer[1024];
    std::string incompleteMessage;
    
    while (isRunning) {
        // Nhận dữ liệu từ client
        int bytesReceived = recv(clientSocket, buffer, sizeof(buffer)-1, 0);
        
        if (bytesReceived <= 0) {
            // Client ngắt kết nối
            break;
        }
        
        buffer[bytesReceived] = '\0';
        incompleteMessage += buffer;
        
        // Xử lý các tin nhắn hoàn chỉnh (kết thúc bằng '\n')
        size_t pos = 0;
        while ((pos = incompleteMessage.find('\n')) != std::string::npos) {
            std::string message = incompleteMessage.substr(0, pos);
            incompleteMessage.erase(0, pos + 1);
            
            // Broadcast tin nhắn đến tất cả clients khác
            broadcastMessage(message, clientSocket);
        }
    }
    
    // Cleanup khi client disconnect
    removeClient(clientSocket);
}

void broadcastMessage(const std::string& message, int senderSocket) {
    std::string fullMessage = message + "\n";
    
    std::lock_guard<std::mutex> lock(clientsMutex);
    for (int clientSocket : clientSockets) {
        if (clientSocket != senderSocket) {
            send(clientSocket, fullMessage.c_str(), fullMessage.length(), 0);
        }
    }
}

void notifyMessageReceived(const std::string& message) {
    JNIEnv* env;
    
    // Attach thread hiện tại với JVM
    if (jvm->AttachCurrentThread(&env, nullptr) != JNI_OK) return;
    
    // Tạo Java String từ C++ string
    jstring jMessage = env->NewStringUTF(message.c_str());
    
    // Gọi method Java
    env->CallVoidMethod(callbackObject, onMessageReceivedMethod, jMessage);
    
    // Cleanup
    env->DeleteLocalRef(jMessage);
    jvm->DetachCurrentThread();
}

// Kiểm tra socket creation
if (serverSocket < 0) {
    LOGE("Socket creation failed: %s", strerror(errno));
    return false;
}

// Kiểm tra bind
if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
    LOGE("Bind failed: %s", strerror(errno));
    close(serverSocket);
    return false;
}

// RAII pattern
class SocketWrapper {
    int socket_;
public:
    SocketWrapper(int socket) : socket_(socket) {}
    ~SocketWrapper() { 
        if (socket_ >= 0) close(socket_); 
    }
    int get() const { return socket_; }
};

class ThreadSafeClientList {
    std::vector<int> clients_;
    std::mutex mutex_;
    
public:
    void addClient(int socket) {
        std::lock_guard<std::mutex> lock(mutex_);
        clients_.push_back(socket);
    }
    
    void removeClient(int socket) {
        std::lock_guard<std::mutex> lock(mutex_);
        clients_.erase(std::remove(clients_.begin(), clients_.end(), socket),
                      clients_.end());
    }
};

class MessageBuffer {
    std::queue<std::string> messages_;
    std::mutex mutex_;
    
public:
    void addMessage(const std::string& msg) {
        std::lock_guard<std::mutex> lock(mutex_);
        messages_.push(msg);
        
        // Batch send khi đủ messages hoặc timeout
        if (messages_.size() >= BATCH_SIZE) {
            flushMessages();
        }
    }
};

int epfd = epoll_create1(0);
struct epoll_event event, events[MAX_EVENTS];

// Add server socket to epoll
event.events = EPOLLIN;
event.data.fd = serverSocket;
epoll_ctl(epfd, EPOLL_CTL_ADD, serverSocket, &event);

while (true) {
    int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
    
    for (int i = 0; i < nfds; ++i) {
        if (events[i].data.fd == serverSocket) {
            // Accept new connection
        } else {
            // Handle client data
        }
    }
}

// Add detailed logging
#define NETWORK_DEBUG 1

#if NETWORK_DEBUG
    LOGI("Sending message: %s (length: %d)", message.c_str(), message.length());
    LOGI("Bytes sent: %d", bytesSent);
#endif

// Valgrind for native code
valgrind --tool=memcheck --leak-check=full ./your_app

// AddressSanitizer
// Add to CMakeLists.txt:
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")