#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <cstring>
#include <netinet/in.h>
#include <unistd.h>

// Функция для длительных вычислений (здесь просто пример)
std::vector<int> compute(const std::vector<int>& data) {
    std::this_thread::sleep_for(std::chrono::seconds(10)); // Эмуляция длительных вычислений
    std::vector<int> result = data; // Здесь можно вставить реальную логику
    for (auto& val : result) {
        val *= 2; // Пример вычисления
    }
    return result;
}

// Глобальные переменные для синхронизации состояния вычислений
std::mutex compute_mutex;
bool is_computation_done = false;
std::vector<int> computation_result;

// Функция для обработки клиента
void handle_client(int client_socket) {
    while (true) {
        char request_type;
        ssize_t read_size = recv(client_socket, &request_type, sizeof(request_type), 0);
        if (read_size <= 0) {
            std::cerr << "Connection closed or error occurred\n";
            break;
        }

        if (request_type == 0) {
            // Клиент отправляет данные для вычислений
            int data_size;
            recv(client_socket, &data_size, sizeof(data_size), 0);

            std::vector<int> data(data_size);
            recv(client_socket, data.data(), data_size * sizeof(int), 0);

            std::thread([data]() {
                std::lock_guard<std::mutex> lock(compute_mutex);
                computation_result = compute(data);
                is_computation_done = true;
            }).detach();

            std::cout << "Received data for computation\n";
        } else if (request_type == 1) {
            // Клиент спрашивает о состоянии вычислений
            std::lock_guard<std::mutex> lock(compute_mutex);
            if (is_computation_done) {
                int result_size = computation_result.size();
                send(client_socket, &result_size, sizeof(result_size), 0);
                send(client_socket, computation_result.data(), result_size * sizeof(int), 0);
                std::cout << "Sent computation result to client\n";
            } else {
                int not_ready = -1;
                send(client_socket, &not_ready, sizeof(not_ready), 0);
                std::cout << "Computation not done yet\n";
            }
        }
    }

    close(client_socket);
}

int main() {
    int server_socket;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

    // Создание серверного сокета
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        std::cerr << "Failed to create socket\n";
        return 1;
    }

    // Параметры адреса сервера
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8080);

    // Привязка сокета к порту
    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "Bind failed\n";
        return 1;
    }

    // Ожидание подключения клиентов
    listen(server_socket, 5);
    std::cout << "Server listening on port 8080\n";

    while (true) {
        // Принятие подключения
        int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addr_len);
        if (client_socket < 0) {
            std::cerr << "Failed to accept connection\n";
            continue;
        }

        std::cout << "Client connected\n";
        std::thread(handle_client, client_socket).detach(); // Обработка клиента в отдельном потоке
    }

    close(server_socket);
    return 0;
}