#pragma once
#include "esp_err.h"
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void (*flexispot_notify_callback_t)();

typedef enum {
    FLEXISPOT_BUTTON_NONE    = 0,
    FLEXISPOT_BUTTON_UP      = 0x0001,
    FLEXISPOT_BUTTON_DOWN    = 0x0002,
    FLEXISPOT_BUTTON_MEMORY  = 0x0020,
    FLEXISPOT_BUTTON_PRESET1 = 0x0004,
    FLEXISPOT_BUTTON_PRESET2 = 0x0008,
    FLEXISPOT_BUTTON_PRESET3 = 0x0010,
    FLEXISPOT_BUTTON_PRESET4 = 0x0100,
} flexispot_button_t;
extern flexispot_button_t flexispot_button_state;

void flexispot_send_packet(uint8_t type, const uint8_t *payload, size_t size);
void flexispot_set_button_state(flexispot_button_t buttons);
void flexispot_get_lcd_str(char *buffer, size_t size);
void flexispot_register_notify_callback(flexispot_notify_callback_t callback);
esp_err_t flexispot_init(void);

#ifdef __cplusplus
}
#endif

#include "flexispot.h"
#include "driver/uart.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include <string.h>

static const char *TAG = "flexispot";
flexispot_button_t flexispot_button_state = FLEXISPOT_BUTTON_NONE;

// UART Configuration for M5AtomS3
#define FLEXISPOT_UART_NUM      UART_NUM_1
#define FLEXISPOT_TXD_PIN       GPIO_NUM_5
#define FLEXISPOT_RXD_PIN       GPIO_NUM_6
#define FLEXISPOT_DETECT_PIN    GPIO_NUM_7
#define FLEXISPOT_BUF_SIZE      1024

static uint16_t crc16_modbus(const uint8_t *data, size_t len) {
    uint16_t crc = 0xFFFF;
    for (size_t i = 0; i < len; i++) {
        crc ^= data[i];
        for (int j = 0; j < 8; j++) {
            if (crc & 1) crc = (crc >> 1) ^ 0xA001;
            else crc >>= 1;
        }
    }
    return crc;
}

void flexispot_send_packet(uint8_t type, const uint8_t *payload, size_t size) {
    uint8_t packet[32] = { 0x9b, size + 4, type };
    if (size) memcpy(&packet[3], payload, size);
    uint16_t checksum = crc16_modbus(&packet[1], size + 2);
    packet[3 + size] = checksum >> 8;    // CRC high byte first (big endian)
    packet[4 + size] = checksum & 0xFF;  // CRC low byte
    packet[5 + size] = 0x9d;

    char hex_str[128] = {0};
    for (int i = 0; i < 6 + size; i++) {
        sprintf(hex_str + i * 3, "%02x ", packet[i]);
    }
    // ESP_LOGI(TAG, "TX: %s", hex_str);

    int len = uart_write_bytes(FLEXISPOT_UART_NUM, packet, 6 + size);
    if (len != 6 + size) ESP_LOGE(TAG, "Failed to send packet");
}

static void send_button_state(flexispot_button_t buttons) {
    // ESP_LOGI(TAG, "Sending button state [0x%04d]", buttons);
    flexispot_send_packet(0x02, (uint8_t[]){ buttons & 0xFF, buttons >> 8 }, 2);
}

/*
* MARK: RX
*/
static int rx_offset = -1, rx_remain = 0;
static uint8_t rx_buf[128];
static SemaphoreHandle_t current_state_mutex;
static struct {
    char lcd_str[32];
    int height;
} current_state;
static flexispot_notify_callback_t notify_callback;

static char *decode_7seg(char *str, uint8_t byte) {
    struct { char c; uint8_t code; } chars[] = {
        { '-', 0x40 },
        { '0', 0x3f },
        { '1', 0x06 },
        { '2', 0x5b },
        { '3', 0x4f },
        { '4', 0x66 },
        { '5', 0x6d },
        { '6', 0x7d },
        { '7', 0x07 },
        { '8', 0x7f },
        { '9', 0x6f },
        { 'C', 0x39 },
        { 'E', 0x79 },
        { 'L', 0x38 },
        { 'R', 0x77 },
        { 'T', 0x31 },
        { 'o', 0x5c },
    };

    // Remove decimal point bit for comparison
    uint8_t segments = byte & 0x7f;
    for (int i = 0; i < sizeof(chars) / sizeof(chars[0]); i++) {
        if (chars[i].code == segments) {
            *str++ = chars[i].c;
            break;
        }
    }
    if (byte & 0x80) {
        *str++ = '.';
    }
    return str;
}

static void display_packet_received(uint8_t *data, int size) {
    if (size != 7) return;
    char buf[8] = {}, *ptr = buf;
    for (int i = 1; i <= 3; i++) ptr = decode_7seg(ptr, data[i]);
    if (ptr != buf) {
        ESP_LOGI(TAG, "Display: %s", buf);
        xSemaphoreTake(current_state_mutex, portMAX_DELAY);
        strncpy(current_state.lcd_str, buf, sizeof(current_state.lcd_str));
        xSemaphoreGive(current_state_mutex);
        if (notify_callback) notify_callback();
    }
}

void flexispot_get_lcd_str(char *buffer, size_t size) {
    xSemaphoreTake(current_state_mutex, portMAX_DELAY);
    strncpy(buffer, current_state.lcd_str, size);
    xSemaphoreGive(current_state_mutex);
}

void flexispot_register_notify_callback(flexispot_notify_callback_t callback) {
    notify_callback = callback;
}

static void rx_consume_byte(uint8_t byte) {
    if (rx_offset < 0) {
        if (byte == 0x9b) rx_offset = 0;
        return;
    }
    if (rx_remain == 0) {
        rx_remain = byte;
        return;
    }
    rx_buf[rx_offset++] = byte;
    if (--rx_remain == 0) {
        if (rx_buf[rx_offset - 1] == 0x9d) {
            char hex_str[64] = {0};
            for (int i = 0; i < rx_offset && i < 20; i++) {
                sprintf(hex_str + i * 3, "%02x ", rx_buf[i]);
            }
            // ESP_LOGI(TAG, "RX[%d]: %s", rx_offset, hex_str);
            if (rx_buf[0] == 0x11) send_button_state(flexispot_button_state);
            if (rx_buf[0] == 0x12) display_packet_received(rx_buf, rx_offset);
        }
        rx_offset = -1;
    }
}

static void rx_task(void *pvParameters) {
    uint8_t rx_buf[16];

    ESP_LOGI(TAG, "UART Rx task started");

    while (1) {
        int len = uart_read_bytes(FLEXISPOT_UART_NUM, rx_buf, sizeof(rx_buf), pdMS_TO_TICKS(100));
        for (int i = 0; i < len; i++) rx_consume_byte(rx_buf[i]);
    }
}

static esp_err_t rx_task_start(void) {
    BaseType_t ret = xTaskCreate(rx_task, "flexispot", 4096, NULL, 5, NULL);
    if (ret != pdPASS) {
        ESP_LOGE(TAG, "Failed to create UART Rx task");
        return ESP_FAIL;
    }

    ESP_LOGI(TAG, "UART Rx task created");
    return ESP_OK;
}

esp_err_t flexispot_init(void) {
    current_state_mutex = xSemaphoreCreateMutex();
    if (current_state_mutex == NULL) {
        ESP_LOGE(TAG, "Failed to create current_state_mutex");
        return ESP_FAIL;
    }

    esp_err_t ret;

    // Configure UART parameters
    uart_config_t uart_config = {
        .baud_rate = 9600,
        .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,
    };

    // Install UART driver
    ret = uart_driver_install(FLEXISPOT_UART_NUM, FLEXISPOT_BUF_SIZE * 2, 0, 0, NULL, 0);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to install UART driver: %s", esp_err_to_name(ret));
        return ret;
    }

    // Configure UART parameters
    ret = uart_param_config(FLEXISPOT_UART_NUM, &uart_config);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to configure UART parameters: %s", esp_err_to_name(ret));
        uart_driver_delete(FLEXISPOT_UART_NUM);
        return ret;
    }

    // Set UART pins
    ret = uart_set_pin(FLEXISPOT_UART_NUM,
                      FLEXISPOT_TXD_PIN,
                      FLEXISPOT_RXD_PIN,
                      UART_PIN_NO_CHANGE,
                      UART_PIN_NO_CHANGE);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to set UART pins: %s", esp_err_to_name(ret));
        uart_driver_delete(FLEXISPOT_UART_NUM);
        return ret;
    }

    // Configure Detect PIN
    gpio_config_t detect_pin_config = {
        .pin_bit_mask = (1ULL << FLEXISPOT_DETECT_PIN),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
    ret = gpio_config(&detect_pin_config);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to configure detect pin: %s", esp_err_to_name(ret));
        uart_driver_delete(FLEXISPOT_UART_NUM);
        return ret;
    }
    gpio_set_level(FLEXISPOT_DETECT_PIN, 1); // set detect pin always high

    // Start UART Rx Task
    ret = rx_task_start();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to start UART Rx Task: %s", esp_err_to_name(ret));
        uart_driver_delete(FLEXISPOT_UART_NUM);
        return ret;
    }
    ESP_LOGI(TAG, "Flexispot UART initialized successfully");
    ESP_LOGI(TAG, "  UART: UART%d, TX: GPIO%d, RX: GPIO%d",
            FLEXISPOT_UART_NUM, FLEXISPOT_TXD_PIN, FLEXISPOT_RXD_PIN);

    return ESP_OK;
}