#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>

#define BUFFER_SIZE 1024
#define DEFAULT_PORT 8888

bool running = true;

void signalHandler(int signum) {
    std::cout << "Interrupt signal (" << signum << ") received.\n";
    running = false;
}

int main(int argc, char* argv[]) {
    // 注冊(cè)信號(hào)處理函數(shù)，用于優(yōu)雅關(guān)閉
    signal(SIGINT, signalHandler);
    signal(SIGTERM, signalHandler);
    
    // 解析命令行參數(shù)
    int port = DEFAULT_PORT;
    if (argc > 1) {
        port = std::stoi(argv[1]);
    }
    
    // 客戶(hù)端ID（進(jìn)程ID）
    pid_t pid = getpid();
    std::cout << "Client started with PID: " << pid << std::endl;
    
    // 創(chuàng)建Socket
    int clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (clientSocket < 0) {
        std::cerr << "Error creating socket" << std::endl;
        return 1;
    }
    
    // 設(shè)置服務(wù)器地址
    struct sockaddr_in serverAddr;
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(port);
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    
    // 綁定Socket到地址
    if (bind(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        std::cerr << "Error binding socket to port " << port << std::endl;
        close(clientSocket);
        return 1;
    }
    
    // 監(jiān)聽(tīng)連接
    if (listen(clientSocket, 5) < 0) {
        std::cerr << "Error listening on socket" << std::endl;
        close(clientSocket);
        return 1;
    }
    
    std::cout << "Client listening on port " << port << std::endl;
    
    // 接受服務(wù)器連接
    struct sockaddr_in serverConnAddr;
    socklen_t serverLen = sizeof(serverConnAddr);
    int serverConnection = accept(clientSocket, (struct sockaddr*)&serverConnAddr, &serverLen);
    
    if (serverConnection < 0) {
        std::cerr << "Error accepting connection" << std::endl;
        close(clientSocket);
        return 1;
    }
    
    std::cout << "Connected to server at " 
              << inet_ntoa(serverConnAddr.sin_addr) 
              << ":" << ntohs(serverConnAddr.sin_port) 
              << std::endl;
    
    // 接收服務(wù)器消息
    char buffer[BUFFER_SIZE];
    while (running) {
        memset(buffer, 0, BUFFER_SIZE);
        int bytesReceived = recv(serverConnection, buffer, BUFFER_SIZE - 1, 0);
        
        if (bytesReceived > 0) {
            std::cout << "Message received: " << buffer << std::endl;
            
            // 發(fā)送確認(rèn)
            std::string ack = "Client " + std::to_string(pid) + " received message";
            send(serverConnection, ack.c_str(), ack.length(), 0);
        } 
        else if (bytesReceived == 0) {
            std::cout << "Server disconnected" << std::endl;
            break;
        }
        else {
            if (errno != EINTR) { // 忽略信號(hào)中斷
                std::cerr << "Error receiving data: " << strerror(errno) << std::endl;
                break;
            }
        }
    }
    
    // 清理資源
    close(serverConnection);
    close(clientSocket);
    std::cout << "Client terminated" << std::endl;
    
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <thread>
#include <chrono>
#include <fstream>
#include <sstream>
#include <signal.h>
#include <sys/wait.h>
#include <mutex>
#include <condition_variable>

#define BUFFER_SIZE 1024
#define DEFAULT_BASE_PORT 8888
#define DEFAULT_NUM_CLIENTS 3
#define CONFIG_FILE "server_config.txt"

std::mutex mtx;
std::condition_variable cv;
bool allClientsConnected = false;
int connectedClients = 0;
int totalClients = 0;
std::vector<pid_t> clientPids;
std::vector<int> clientSockets;

// 從配置文件讀取配置
bool readConfig(int& numClients, int& basePort) {
    std::ifstream configFile(CONFIG_FILE);
    if (!configFile.is_open()) {
        std::cout << "Config file not found, using defaults" << std::endl;
        return false;
    }
    
    std::string line;
    while (std::getline(configFile, line)) {
        std::istringstream iss(line);
        std::string key;
        if (std::getline(iss, key, '=')) {
            std::string value;
            if (std::getline(iss, value)) {
                if (key == "NUM_CLIENTS") {
                    numClients = std::stoi(value);
                } else if (key == "BASE_PORT") {
                    basePort = std::stoi(value);
                }
            }
        }
    }
    
    configFile.close();
    return true;
}

// 寫(xiě)入默認(rèn)配置到文件
void writeDefaultConfig() {
    std::ofstream configFile(CONFIG_FILE);
    if (configFile.is_open()) {
        configFile << "NUM_CLIENTS=" << DEFAULT_NUM_CLIENTS << std::endl;
        configFile << "BASE_PORT=" << DEFAULT_BASE_PORT << std::endl;
        configFile.close();
        std::cout << "Created default configuration file" << std::endl;
    } else {
        std::cerr << "Unable to create configuration file" << std::endl;
    }
}

// 啟動(dòng)客戶(hù)端進(jìn)程
pid_t launchClient(int port) {
    pid_t pid = fork();
    
    if (pid == 0) {
        // 子進(jìn)程
        std::string portStr = std::to_string(port);
        execl("./Client", "Client", portStr.c_str(), nullptr);
        
        // 如果execl返回，說(shuō)明出錯(cuò)了
        std::cerr << "Error launching client: " << strerror(errno) << std::endl;
        exit(1);
    } else if (pid < 0) {
        // fork失敗
        std::cerr << "Fork failed: " << strerror(errno) << std::endl;
        return -1;
    }
    
    // 父進(jìn)程
    return pid;
}

// 連接到客戶(hù)端
bool connectToClient(int& clientSocket, int port) {
    clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (clientSocket < 0) {
        std::cerr << "Error creating socket for client on port " << port << std::endl;
        return false;
    }
    
    struct sockaddr_in clientAddr;
    memset(&clientAddr, 0, sizeof(clientAddr));
    clientAddr.sin_family = AF_INET;
    clientAddr.sin_port = htons(port);
    clientAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    // 嘗試連接，帶重試
    int retries = 10;
    while (retries > 0) {
        if (connect(clientSocket, (struct sockaddr*)&clientAddr, sizeof(clientAddr)) == 0) {
            std::cout << "Connected to client on port " << port << std::endl;
            return true;
        }
        
        std::cout << "Connection attempt failed, retrying in 1 second..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
        retries--;
    }
    
    std::cerr << "Failed to connect to client on port " << port << std::endl;
    close(clientSocket);
    return false;
}

// 連接客戶(hù)端的線(xiàn)程函數(shù)
void clientConnectionThread(int port, int clientIndex) {
    int clientSocket;
    if (connectToClient(clientSocket, port)) {
        std::lock_guard<std::mutex> lock(mtx);
        clientSockets[clientIndex] = clientSocket;
        connectedClients++;
        
        if (connectedClients == totalClients) {
            allClientsConnected = true;
            cv.notify_one();
        }
    }
}

// 向所有已連接的客戶(hù)端發(fā)送消息
void sendToAllClients(const std::string& message) {
    for (int socket : clientSockets) {
        if (socket > 0) {
            send(socket, message.c_str(), message.length(), 0);
            
            // 接收確認(rèn)
            char buffer[BUFFER_SIZE];
            memset(buffer, 0, BUFFER_SIZE);
            int bytesReceived = recv(socket, buffer, BUFFER_SIZE - 1, 0);
            if (bytesReceived > 0) {
                std::cout << "Acknowledgment: " << buffer << std::endl;
            }
        }
    }
}

// 清理資源
void cleanup() {
    // 關(guān)閉所有客戶(hù)端Socket
    for (int socket : clientSockets) {
        if (socket > 0) {
            close(socket);
        }
    }
    
    // 終止所有客戶(hù)端進(jìn)程
    for (pid_t pid : clientPids) {
        if (pid > 0) {
            kill(pid, SIGTERM);
            waitpid(pid, nullptr, 0);
        }
    }
}

// 信號(hào)處理函數(shù)
void signalHandler(int signum) {
    std::cout << "Interrupt signal (" << signum << ") received.\n";
    cleanup();
    exit(signum);
}

int main() {
    // 注冊(cè)信號(hào)處理函數(shù)
    signal(SIGINT, signalHandler);
    signal(SIGTERM, signalHandler);
    
    // 讀取配置
    int numClients = DEFAULT_NUM_CLIENTS;
    int basePort = DEFAULT_BASE_PORT;
    
    if (!readConfig(numClients, basePort)) {
        writeDefaultConfig();
    }
    
    std::cout << "Starting server with " << numClients << " clients, base port: " << basePort << std::endl;
    
    // 初始化客戶(hù)端向量
    totalClients = numClients;
    clientPids.resize(numClients, -1);
    clientSockets.resize(numClients, -1);
    
    // 啟動(dòng)客戶(hù)端進(jìn)程
    for (int i = 0; i < numClients; i++) {
        int port = basePort + i;
        pid_t pid = launchClient(port);
        
        if (pid > 0) {
            clientPids[i] = pid;
            std::cout << "Launched client " << i + 1 << " with PID " << pid << " on port " << port << std::endl;
        } else {
            std::cerr << "Failed to launch client " << i + 1 << std::endl;
        }
    }
    
    // 給客戶(hù)端啟動(dòng)的時(shí)間
    std::cout << "Waiting for clients to start..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    // 連接到客戶(hù)端
    std::vector<std::thread> connectionThreads;
    for (int i = 0; i < numClients; i++) {
        if (clientPids[i] > 0) {
            int port = basePort + i;
            connectionThreads.push_back(std::thread(clientConnectionThread, port, i));
        }
    }
    
    // 等待所有連接建立
    {
        std::unique_lock<std::mutex> lock(mtx);
        if (!allClientsConnected) {
            std::cout << "Waiting for all clients to connect..." << std::endl;
            cv.wait(lock, []{ return allClientsConnected; });
        }
    }
    
    // 等待所有連接線(xiàn)程結(jié)束
    for (auto& thread : connectionThreads) {
        thread.join();
    }
    
    std::cout << "All clients connected. Ready to send messages." << std::endl;
    
    // 主循環(huán)
    std::string message;
    while (true) {
        std::cout << "Enter message to send to all clients (or 'exit' to quit): ";
        std::getline(std::cin, message);
        
        if (message == "exit") {
            break;
        }
        
        std::cout << "Sending message to all clients..." << std::endl;
        sendToAllClients(message);
    }
    
    // 清理
    cleanup();
    std::cout << "Server terminated" << std::endl;
    
    return 0;
}

CC = g++
CFLAGS = -std=c++11 -Wall -pthread
LDFLAGS = -pthread

all: Client Server

Client: client.cpp
	$(CC) $(CFLAGS) -o Client client.cpp $(LDFLAGS)

Server: server.cpp
	$(CC) $(CFLAGS) -o Server server.cpp $(LDFLAGS)

clean:
	rm -f Client Server server_config.txt

.PHONY: all clean

# 編譯
make

# 運(yùn)行服務(wù)器
./Server

signal(SIGINT, signalHandler);
signal(SIGTERM, signalHandler);

std::vector<std::thread> connectionThreads;
for (int i = 0; i < numClients; i++) {
    if (clientPids[i] > 0) {
        int port = basePort + i;
        connectionThreads.push_back(std::thread(clientConnectionThread, port, i));
    }
}

{
    std::unique_lock<std::mutex> lock(mtx);
    if (!allClientsConnected) {
        std::cout << "Waiting for all clients to connect..." << std::endl;
        cv.wait(lock, []{ return allClientsConnected; });
    }
}