#include <WiFi.h>
#include <lwip/sockets.h> // For socket API
#include <esp_log.h>      // For logging

static const char *TAG = "ReverseDistanceSensor";

#define SERVER_IP "10.13.37.1"        // Localhost IP address
#define SERVER_PORT 8100         // Server port
#define LISTENING_PORT 8101     // This device port
#define BUFLEN 1024
#define SENSOR_NAME "Reverse Distance Sensor" // Define the sensor name

const char* ssid = "Wokwi-GUEST";
const char* password = ""; // Empty because there's no password for this network

void run_server(void *param) {
    char rx_buffer[1024];
    char addr_str[128];
    int addr_family = AF_INET;
    int ip_protocol = IPPROTO_IP;

    struct sockaddr_in dest_addr;
    dest_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(LISTENING_PORT);

    int listen_sock = socket(addr_family, SOCK_STREAM, ip_protocol);
    if (listen_sock < 0) {
        ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
        vTaskDelete(NULL);
        return;
    }
    ESP_LOGI(TAG, "Socket created");

    int err = bind(listen_sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
    if (err != 0) {
        ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno);
        close(listen_sock);
        vTaskDelete(NULL);
        return;
    }
    ESP_LOGI(TAG, "Socket bound, port %d", LISTENING_PORT);

    err = listen(listen_sock, 1);
    if (err != 0) {
        ESP_LOGE(TAG, "Error occurred during listen: errno %d", errno);
        close(listen_sock);
        vTaskDelete(NULL);
        return;
    }
    ESP_LOGI(TAG, "Socket listening");

    while (1) {
        struct sockaddr_in source_addr;
        socklen_t addr_len = sizeof(source_addr);
        int sock = accept(listen_sock, (struct sockaddr *)&source_addr, &addr_len);
        if (sock < 0) {
            ESP_LOGE(TAG, "Unable to accept connection: errno %d", errno);
            continue;
        }

        inet_ntoa_r(source_addr.sin_addr, addr_str, sizeof(addr_str) - 1);
        ESP_LOGI(TAG, "Socket accepted IP address: %s", addr_str);

        // Receive the initial message from the client
        int len = recv(sock, rx_buffer, sizeof(rx_buffer) - 1, 0);
        if (len > 0) {
            rx_buffer[len] = 0;
            ESP_LOGI(TAG, "Received %d bytes: %s", len, rx_buffer);

            // Acknowledge the received message
            const char *response = "Message received!";
            err = send(sock, response, strlen(response), 0);
            if (err < 0) {
                ESP_LOGE(TAG, "Failed to send response: errno %d", errno);
                close(sock);
                continue;
            }
            ESP_LOGI(TAG, "Sent acknowledgment to client");

            // Now, keep sending random numbers every 2 seconds
            srand(time(NULL));  // Seed the random number generator
            while (1) {
                int random_num = rand() % 100;  // Generate a random number between 0 and 99
                char num_str[128];
                sprintf(num_str, "ID:%s,VALUE:%d", SENSOR_NAME, random_num);

                // Send the random number to the client
                err = send(sock, num_str, strlen(num_str), 0);
                if (err < 0) {
                    ESP_LOGE(TAG, "Failed to send random number: errno %d", errno);
                    break;
                }
                ESP_LOGI(TAG, "Sent random number to client: %d", random_num);

                delay(2000);  // Wait for 2 seconds before sending the next number
            }
        }

        close(sock);
        ESP_LOGI(TAG, "Socket closed");
    }

    close(listen_sock);
    ESP_LOGI(TAG, "Socket server stopped");
    vTaskDelete(NULL);
}

void run_client(void *param) {
    while (1) {
        ESP_LOGI(TAG, "Running again");

        struct sockaddr_in dest_addr;
        dest_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
        dest_addr.sin_family = AF_INET;
        dest_addr.sin_port = htons(SERVER_PORT);

        int sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0) {
            ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
            continue;
        }
        ESP_LOGI(TAG, "Socket created, connecting to %s:%d", SERVER_IP, SERVER_PORT);

        int err = connect(sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
        if (err != 0) {
            ESP_LOGE(TAG, "Socket unable to connect: errno %d", errno);
            close(sock);
            continue;
        }

        ESP_LOGI(TAG, "Successfully connected to %s:%d", SERVER_IP, SERVER_PORT);
        const char *payload = "Hello from ESP32";
        send(sock, payload, strlen(payload), 0);
        ESP_LOGI(TAG, "Message sent");

        close(sock);
        ESP_LOGI(TAG, "Socket closed");

        delay(10000);  // Wait before trying again
    }
}

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(1000);
        Serial.println("Connecting to WiFi...");
    }
    Serial.println("Connected to WiFi");

    xTaskCreate(run_server, "run_server", 4096, NULL, 1, NULL);
    // xTaskCreate(run_client, "run_client", 4096, NULL, 1, NULL);
}

void loop() {
    // Nothing to do here, tasks are running independently
}