#include "metrics_serial.h"

#include <stdbool.h>
#include <stdio.h>
#include <string.h>

#include "driver/uart.h"
#include "driver/usb_serial_jtag.h"
#include "esp_err.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "metrics_protocol.h"
#include "ui_screen.h"

static const char *TAG = "metrics_serial";
static QueueHandle_t s_serial_metrics_queue;

static void consume_byte(char ch, char *line, size_t *length)
{
    if (ch == '\r') {
        return;
    }

    if (ch == '\n') {
        line[*length] = '\0';
        *length = 0;

        ui_metrics_t metrics;
        if (metrics_parse_line(line, &metrics)) {
            if (s_serial_metrics_queue != NULL) {
                xQueueOverwrite(s_serial_metrics_queue, &metrics);
            }
        }
        return;
    }

    if (*length < 511) {
        line[*length] = ch;
        *length += 1;
    } else {
        *length = 0;
    }
}

static void usb_serial_task(void *arg)
{
    (void)arg;
    char line[512];
    size_t length = 0;
    uint8_t buffer[64];

    while (1) {
        int read = usb_serial_jtag_read_bytes(buffer, sizeof(buffer), pdMS_TO_TICKS(100));
        for (int i = 0; i < read; i++) {
            consume_byte((char)buffer[i], line, &length);
        }
    }
}

static void uart_serial_task(void *arg)
{
    (void)arg;
    char line[512];
    size_t length = 0;
    uint8_t buffer[64];

    while (1) {
        int read = uart_read_bytes(UART_NUM_0, buffer, sizeof(buffer), pdMS_TO_TICKS(100));
        for (int i = 0; i < read; i++) {
            consume_byte((char)buffer[i], line, &length);
        }
    }
}

void metrics_serial_start(void)
{
    if (s_serial_metrics_queue == NULL) {
        s_serial_metrics_queue = xQueueCreate(1, sizeof(ui_metrics_t));
        if (s_serial_metrics_queue == NULL) {
            ESP_LOGW(TAG, "serial metrics queue unavailable");
            return;
        }
    }

    usb_serial_jtag_driver_config_t usb_config = {
        .tx_buffer_size = 256,
        .rx_buffer_size = 1024,
    };
    esp_err_t usb_ret = usb_serial_jtag_driver_install(&usb_config);
    if (usb_ret != ESP_OK && usb_ret != ESP_ERR_INVALID_STATE) {
        ESP_LOGW(TAG, "USB Serial/JTAG install failed: %s", esp_err_to_name(usb_ret));
    } else {
        xTaskCreate(usb_serial_task, "metrics_usb", 4096, NULL, 4, NULL);
    }

    const 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,
        .source_clk = UART_SCLK_DEFAULT,
    };
    uart_param_config(UART_NUM_0, &uart_config);
    esp_err_t uart_ret = uart_driver_install(UART_NUM_0, 1024, 0, 0, NULL, 0);
    if (uart_ret != ESP_OK && uart_ret != ESP_ERR_INVALID_STATE) {
        ESP_LOGW(TAG, "UART0 install failed: %s", esp_err_to_name(uart_ret));
    } else {
        xTaskCreate(uart_serial_task, "metrics_uart", 4096, NULL, 4, NULL);
    }
}

bool metrics_serial_take_latest(ui_metrics_t *metrics)
{
    if (metrics == NULL || s_serial_metrics_queue == NULL) {
        return false;
    }

    return xQueueReceive(s_serial_metrics_queue, metrics, 0) == pdTRUE;
}