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

const uart_port_t uart_num = UART_NUM_0;
const int uart_buffer_size = (1024 * 2);
QueueHandle_t uart_queue;

void uartInit() {
    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,
    };
    ESP_ERROR_CHECK(uart_param_config(uart_num, &uart_config));
    ESP_ERROR_CHECK(uart_driver_install(UART_NUM_0, uart_buffer_size, uart_buffer_size, 10, &uart_queue, 0));
}

void uartPuts(char data[]) {
    uart_write_bytes(uart_num, (const char*)data, strlen(data));
}

void uartGets(uint8_t data[]) {
    int length = 0;
    while (!length) {
        ESP_ERROR_CHECK(uart_get_buffered_data_len(uart_num, (size_t*)&length));
    }
    length = uart_read_bytes(uart_num, data, length, 100);
    data[length - 1] = 0;
}

// Función para rotar una matriz 90 grados hacia la derecha
int **rotarMatriz90(int **matriz, int *renglones, int *columnas) {
    int n = *renglones;
    int m = *columnas;

    // Reservar memoria para la matriz rotada
    int **rotada = (int **)malloc(m * sizeof(int *));
    for (int i = 0; i < m; i++) {
        rotada[i] = (int *)malloc(n * sizeof(int));
    }

    // Rellenar la matriz rotada
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            rotada[j][n - i - 1] = matriz[i][j];
        }
    }

    // Liberar la matriz original
    for (int i = 0; i < n; i++) {
        free(matriz[i]);
    }
    free(matriz);

    // Actualizar los nuevos tamaños de renglones y columnas
    *renglones = m;
    *columnas = n;

    return rotada;
}

void app_main() {
    char Ren[20], Col[20], Mat[20], Rot[20];
    uartInit();

    uartPuts("Renglones: \n");
    uartGets((uint8_t*)Ren);
    int Renglones = atoi(Ren);

    uartPuts("Columnas: \n");
    uartGets((uint8_t*)Col);
    int Columnas = atoi(Col);

    uartPuts("Rotaciones: \n");
    uartGets((uint8_t*)Rot);
    int Rotaciones = atoi(Rot);

    // Reservar memoria para la matriz original
    int **matriz = (int **)malloc(Renglones * sizeof(int *));
    for (int i = 0; i < Renglones; i++) {
        matriz[i] = (int *)malloc(Columnas * sizeof(int));
    }

    // Leer los valores de la matriz
    uartPuts("Ingresa los valores de la matriz:\n");
    for (int i = 0; i < Renglones; i++) {
        for (int j = 0; j < Columnas; j++) {
            char mensaje[100];
            snprintf(mensaje, sizeof(mensaje), "Valor para la posición [%d][%d]: \n", i, j);
            uartPuts(mensaje);

            uartGets((uint8_t*)Mat);
            matriz[i][j] = atoi(Mat);
        }
    }

    // Mostrar la matriz original
    uartPuts("Matriz original:\n");
    for (int i = 0; i < Renglones; i++) {
        for (int j = 0; j < Columnas; j++) {
            char valor[10];
            snprintf(valor, sizeof(valor), "%d ", matriz[i][j]);
            uartPuts(valor);
        }
        uartPuts("\n");
    }

    // Aplicar rotaciones
    for (int r = 0; r < Rotaciones; r++) {
        matriz = rotarMatriz90(matriz, &Renglones, &Columnas);
    }

    // Mostrar la matriz después de las rotaciones
    uartPuts("Matriz después de las rotaciones:\n");
    for (int i = 0; i < Renglones; i++) {
        for (int j = 0; j < Columnas; j++) {
            char valor[10];
            snprintf(valor, sizeof(valor), "%d ", matriz[i][j]);
            uartPuts(valor);
        }
        uartPuts("\n");
    }

    // Liberar la matriz final
    for (int i = 0; i < Renglones; i++) {
        free(matriz[i]);
    }
    free(matriz);

    while (true) {
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}