#include <stdio.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/uart.h"
#include "driver/gpio.h"
#include "esp_log.h"


//DEFINES PARA EL USO DE MENSAJES LOGI
#define TAG __func__
#define CONFIG_LOG_DEFAULT_LEVEL_VERBOSE 1
#define CONFIG_LOG_MAXIMUM_LEVEL  5

// Configuración de pines para LEDs
#define LED_COUNT 8
const gpio_num_t LEDS[LED_COUNT] = {16, 17, 18, 19, 21, 22, 23, 13};

// Configuración de UART
#define UART_NUM UART_NUM_0
#define BUF_SIZE 1024

// Función para inicializar UART
void uart_init() {
    uart_config_t uart_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity    = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
    };
    uart_param_config(UART_NUM, &uart_config);
    uart_set_pin(UART_NUM, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    uart_driver_install(UART_NUM, BUF_SIZE, BUF_SIZE, 0, NULL, 0);
}

// Función para inicializar GPIO
void gpio_init() {
    for (int i = 0; i < LED_COUNT; i++) {
        gpio_reset_pin(LEDS[i]);
        gpio_set_direction(LEDS[i], GPIO_MODE_OUTPUT);
    }
}

// Función genérica para recibir una línea desde UART
void uart_gets(uart_port_t uart_num, char *buffer, size_t buffer_size){
    int index = 0;
    char caracter;

    while(1){
        int len = uart_read_bytes(uart_num, (uint8_t *)&caracter, 1, pdMS_TO_TICKS(1000));
        if(len > 0){
            uart_write_byte(uart_num, &caracter, 1);

            if(caracter == '\n' || caracter == '\r'){
                buffer[index] = '\0' 
                break;
            }else if (index < buffer_size - 1){
                buffer[buffer_size++] = caracter;
            }
        }
    }
}

// Función para comparar elementos del arreglo (para usar con qsort)
int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

// Función para mostrar un número en LEDs en formato binario
void mostrar_en_leds(uint8_t numero) {
    for (int i = 0; i < LED_COUNT; i++) {
        gpio_set_level(LEDS[i], (numero >> i) & 0x01);
    }
    vTaskDelay(pdMS_TO_TICKS(1000)); // Esperar un segundo
}

// Tarea para recibir y procesar datos
void recibir_datos(void *arg) {
    char buffer[128];
    int N = 0;

    while (1) {
        esp_log_level_set(TAG, ESP_LOG_VERBOSE);
        // Recibir el tamaño del arreglo
        ESP_LOGI(TAG, "Ingrese el tamaño del arreglo (N): ");
        uart_gets(UART_NUM, buffer, sizeof(buffer));
        N = atoi(buffer);

        if (N <= 0) {
            printf("Valor inválido para N. Intente nuevamente.\n");
            continue; // Reiniciar el ciclo si el tamaño es inválido
        }

        int *W = malloc(N * sizeof(int));
        if (W == NULL) {
            printf("Error al asignar memoria.\n");
            continue; // Reiniciar el ciclo si hay error de memoria
        }

        // Recibir los elementos del arreglo
        printf("Ingrese %d elementos:\n", N);
        for (int i = 0; i < N; i++) {
            uart_gets(UART_NUM, buffer, sizeof(buffer));
            W[i] = atoi(buffer);
        }

        // Ordenar el arreglo usando la función compare
        qsort(W, N, sizeof(int), compare);

        // Eliminar duplicados y rellenar con -1
        for (int i = 0; i < N - 1; i++) {
            if (W[i] == W[i + 1]) {
                W[i + 1] = -1;
            }
        }

        ESP_LOGI(TAG,"Mostrando arreglo: \n");
        for (int i = 0; i < N; i++){
          ESP_LOGI(TAG, "%d ", W[i]);
        }

        // Mostrar los elementos en los LEDs
        for (int i = 0; i < N; i++) {
            if (W[i] != -1) {
                ESP_LOGI(TAG,"Mostrando en LEDs: %d\n", W[i]);
                mostrar_en_leds(W[i]);
            }
        }

        free(W); // Liberar memoria antes de la siguiente iteración
    }
}

// Función principal
void app_main() {
    uart_init();
    gpio_init();

    xTaskCreate(recibir_datos, "recibir_datos", 4096, NULL, 10, NULL);
}