/**
 * ESP-IDF ST7735 Display Driver (basierend auf LilyGO T-Dongle-C5 Demo)
 * 
 * GPIO-Pins für T-Dongle-C5:
 *   CS  = GPIO10, DC  = GPIO3, RST = GPIO1
 *   BL  = GPIO0,  MOSI = GPIO2, SCK = GPIO6
 *
 * Display: ST7735S, 80x160, Rotation 3 (invertiert), Offset x=26, y=1
 */

#include "st7735.h"
#include "esp_log.h"
#include "esp_rom_gpio.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include <string.h>
#include <stdlib.h>

static const char *TAG = "st7735";

/* ST7735 Register-Kommandos */
#define ST7735_NOP     0x00
#define ST7735_SWRESET 0x01
#define ST7735_RDDID   0x04
#define ST7735_RDDST   0x09

#define ST7735_SLPIN   0x10
#define ST7735_SLPOUT  0x11
#define ST7735_PTLON   0x12
#define ST7735_NORON   0x13

#define ST7735_INVOFF  0x20
#define ST7735_INVON   0x21
#define ST7735_DISPOFF 0x28
#define ST7735_DISPON  0x29
#define ST7735_CASET   0x2A
#define ST7735_RASET   0x2B
#define ST7735_RAMWR   0x2C
#define ST7735_RAMRD   0x2E

#define ST7735_PTLAR   0x30
#define ST7735_VSCRDEF 0x33
#define ST7735_COLMOD  0x3A
#define ST7735_MADCTL  0x36
#define ST7735_VSCRSADD 0x37

#define ST7735_FRMCTR1 0xB1
#define ST7735_FRMCTR2 0xB2
#define ST7735_FRMCTR3 0xB3
#define ST7735_INVCTR  0xB4
#define ST7735_DISSET5 0xB6

#define ST7735_PWCTR1  0xC0
#define ST7735_PWCTR2  0xC1
#define ST7735_PWCTR3  0xC2
#define ST7735_PWCTR4  0xC3
#define ST7735_PWCTR5  0xC4
#define ST7735_VMCTR1  0xC5

#define ST7735_PWCTR6  0xFC

#define ST7735_GMCTRP1 0xE0
#define ST7735_GMCTRN1 0xE1

/* Display Struktur */
typedef struct {
    spi_device_handle_t spi;
    void *display_handle;
    uint8_t rotation;
    uint16_t width;
    uint16_t height;
    int cs_gpio;
    int dc_gpio;
    int rst_gpio;
    int bl_gpio;
    int mosi_gpio;
    int sck_gpio;
} st7735_dev_t;

/* Hilfsfunktion: SPI-Kommando senden */
static esp_err_t st7735_send_cmd(st7735_dev_t *dev, uint8_t cmd)
{
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = 8;
    t.tx_buffer = &cmd;
    t.user = (void *)0; // DC = LOW für Kommando
    return spi_device_polling_transmit(dev->spi, &t);
}

/* Hilfsfunktion: SPI-Daten senden */
static esp_err_t st7735_send_data(st7735_dev_t *dev, const uint8_t *data, size_t len)
{
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = len * 8;
    t.tx_buffer = data;
    t.user = (void *)1; // DC = HIGH für Daten
    return spi_device_polling_transmit(dev->spi, &t);
}

/* Hilfsfunktion: SPI-Array senden */
static esp_err_t st7735_send_array(st7735_dev_t *dev, const uint8_t *data, size_t len)
{
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = len * 8;
    t.tx_buffer = data;
    t.user = (void *)1;
    return spi_device_polling_transmit(dev->spi, &t);
}

/* ST7735 Init-Sequenz (aus LilyGO Demo) */
static const struct {
    uint8_t cmd;
    const uint8_t *data;
    uint8_t len;
    uint32_t delay_ms;
} st7735_init_cmds[] = {
    {ST7735_SWRESET, NULL, 0, 150},
    {ST7735_SLPOUT, NULL, 0, 255},
    {ST7735_FRMCTR1, (const uint8_t[]){0x01, 0x2C, 0x2D}, 3, 0},
    {ST7735_FRMCTR2, (const uint8_t[]){0x01, 0x2C, 0x2D}, 3, 0},
    {ST7735_FRMCTR3, (const uint8_t[]){0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D}, 6, 0},
    {ST7735_INVCTR, (const uint8_t[]){0x07}, 1, 0},
    {ST7735_PWCTR1, (const uint8_t[]){0xA2, 0x02, 0x84}, 3, 0},
    {ST7735_PWCTR2, (const uint8_t[]){0xC5}, 1, 0},
    {ST7735_PWCTR3, (const uint8_t[]){0x0A, 0x00}, 2, 0},
    {ST7735_PWCTR4, (const uint8_t[]){0x8A, 0x2A}, 2, 0},
    {ST7735_PWCTR5, (const uint8_t[]){0x8A, 0xEE}, 2, 0},
    {ST7735_VMCTR1, (const uint8_t[]){0x0E}, 1, 0},
    {ST7735_INVON, NULL, 0, 0},
    {ST7735_COLMOD, (const uint8_t[]){0x05}, 1, 0}, // 16-bit RGB
    {ST7735_GMCTRP1, (const uint8_t[]){
        0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d,
        0x29, 0x25, 0x2B, 0x39, 0x00, 0x01, 0x03, 0x10
    }, 16, 0},
    {ST7735_GMCTRN1, (const uint8_t[]){
        0x03, 0x1d, 0x07, 0x06, 0x2E, 0x2C, 0x29, 0x2D,
        0x2E, 0x2E, 0x37, 0x3F, 0x00, 0x00, 0x02, 0x10
    }, 16, 0},
    {ST7735_NORON, NULL, 0, 10},
    {ST7735_DISPON, NULL, 0, 100},
    {0x00, NULL, 0, 0}, // Ende
};

esp_err_t st7735_init(const st7735_gpio_config_t *gpio_cfg, 
                       uint8_t rotation, 
                       void **handle)
{
    st7735_dev_t *dev = calloc(1, sizeof(st7735_dev_t));
    if (!dev) {
        ESP_LOGE(TAG, "Failed to allocate dev struct");
        return ESP_ERR_NO_MEM;
    }
    
    /* GPIO-Konfiguration (Default oder benutzerdefiniert) */
    if (gpio_cfg) {
        dev->cs_gpio = gpio_cfg->cs_gpio;
        dev->dc_gpio = gpio_cfg->dc_gpio;
        dev->rst_gpio = gpio_cfg->rst_gpio;
        dev->bl_gpio = gpio_cfg->bl_gpio;
        dev->mosi_gpio = gpio_cfg->mosi_gpio;
        dev->sck_gpio = gpio_cfg->sck_gpio;
    } else {
        /* Default T-Dongle-C5 Pins */
        dev->cs_gpio = 10;
        dev->dc_gpio = 3;
        dev->rst_gpio = 1;
        dev->bl_gpio = 0;
        dev->mosi_gpio = 2;
        dev->sck_gpio = 6;
    }
    
    dev->rotation = rotation;
    dev->width = (rotation == 1 || rotation == 3) ? 160 : 80;
    dev->height = (rotation == 1 || rotation == 3) ? 80 : 160;
    
    ESP_LOGI(TAG, "Initialisiere ST7735 (CS=%d, DC=%d, RST=%d, BL=%d)",
             dev->cs_gpio, dev->dc_gpio, dev->rst_gpio, dev->bl_gpio);
    
    /* GPIOs konfigurieren */
    gpio_set_direction((gpio_num_t)dev->cs_gpio, GPIO_MODE_OUTPUT);
    gpio_set_direction((gpio_num_t)dev->dc_gpio, GPIO_MODE_OUTPUT);
    gpio_set_direction((gpio_num_t)dev->rst_gpio, GPIO_MODE_OUTPUT);
    gpio_set_direction((gpio_num_t)dev->bl_gpio, GPIO_MODE_OUTPUT);
    /* Hardware-Reset */
    gpio_set_level(dev->rst_gpio, 1);
    esp_rom_delay_us(100 * 1000);
    gpio_set_level(dev->rst_gpio, 0);
    esp_rom_delay_us(100 * 1000);
    gpio_set_level(dev->rst_gpio, 1);
    esp_rom_delay_us(120 * 1000);
    
    /* Backlight aus (aktiv LOW) */
    gpio_set_level(dev->bl_gpio, 1);
    
    /* SPI initialisieren */
    spi_bus_config_t bus_cfg = {
        .mosi_io_num = dev->mosi_gpio,
        .miso_io_num = -1,
        .sclk_io_num = dev->sck_gpio,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4096,
    };
    esp_err_t ret;
    ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, 1);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "SPI bus init failed: %s", esp_err_to_name(ret));
        free(dev);
        return ret;
    }
    
    /* SPI-Device konfigurieren */
    spi_device_interface_config_t dev_cfg = {
        .clock_speed_hz = 40 * 1000 * 1000, // 40 MHz
        .mode = 0,
        .spics_io_num = dev->cs_gpio,
        .queue_size = 7,
        .flags = SPI_DEVICE_NO_DUMMY,
    };
    ret = spi_bus_add_device(SPI2_HOST, &dev_cfg, &dev->spi);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "SPI device add failed: %s", esp_err_to_name(ret));
        free(dev);
        return ret;
    }
    
    /* ST7735 Init-Sequenz senden */
    for (int i = 0; st7735_init_cmds[i].cmd != 0x00; i++) {
        st7735_send_cmd(dev, st7735_init_cmds[i].cmd);
        if (st7735_init_cmds[i].data) {
            st7735_send_array(dev, st7735_init_cmds[i].data, st7735_init_cmds[i].len);
        }
        if (st7735_init_cmds[i].delay_ms > 0) {
            esp_rom_delay_us(st7735_init_cmds[i].delay_ms * 1000);
        }
    }
    
    /* Rotation setzen (MADCTL) */
    static const uint8_t rotation_config[4] = {
        0x00, // 0°
        0x60, // 90°
        0xC0, // 180°
        0xA0, // 270°
    };
    
    uint8_t madctl = (rotation_config[rotation] & 0xF7) | 0x08; // BGR-Mode
    st7735_send_cmd(dev, ST7735_MADCTL);
    st7735_send_data(dev, &madctl, 1);
    
    ESP_LOGI(TAG, "ST7735 Display init erfolgreich (Rot=%d, %dx%d)",
             rotation, dev->width, dev->height);
    
    *handle = dev;
    return ESP_OK;
}

esp_err_t st7735_display_off(void *handle)
{
    st7735_dev_t *dev = (st7735_dev_t *)handle;
    st7735_send_cmd(dev, ST7735_DISPOFF);
    esp_rom_delay_us(120 * 1000);
    return ESP_OK;
}

esp_err_t st7735_display_on(void *handle)
{
    st7735_dev_t *dev = (st7735_dev_t *)handle;
    st7735_send_cmd(dev, ST7735_DISPON);
    esp_rom_delay_us(100 * 1000);
    return ESP_OK;
}

static esp_err_t st7735_set_addr_window(st7735_dev_t *dev, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
{
    /* Offset berücksichtigen */
    if (dev->rotation == 1 || dev->rotation == 3) {
        x0 += ST7735_ROW_OFFSET;
        x1 += ST7735_ROW_OFFSET;
        y0 += ST7735_COL_OFFSET;
        y1 += ST7735_COL_OFFSET;
    } else {
        x0 += ST7735_COL_OFFSET;
        x1 += ST7735_COL_OFFSET;
        y0 += ST7735_ROW_OFFSET;
        y1 += ST7735_ROW_OFFSET;
    }
    
    /* Column Address Set */
    uint8_t col_data[4] = { x0 >> 8, x0 & 0xFF, x1 >> 8, x1 & 0xFF };
    st7735_send_cmd(dev, ST7735_CASET);
    st7735_send_array(dev, col_data, 4);
    
    /* Row Address Set */
    uint8_t row_data[4] = { y0 >> 8, y0 & 0xFF, y1 >> 8, y1 & 0xFF };
    st7735_send_cmd(dev, ST7735_RASET);
    st7735_send_array(dev, row_data, 4);
    
    /* Memory Write */
    st7735_send_cmd(dev, ST7735_RAMWR);
    return ESP_OK;
}

esp_err_t st7735_fill_screen(void *handle, uint16_t color)
{
    st7735_dev_t *dev = (st7735_dev_t *)handle;
    
    st7735_set_addr_window(dev, 0, 0, dev->width - 1, dev->height - 1);
    
    uint8_t color_data[2] = { color >> 8, color & 0xFF };
    uint32_t total_pixels = dev->width * dev->height;
    
    /* In Blöcken senden (max 4KB pro Transfer) */
    const uint32_t block_size = 1024; // 512 pixels (2 bytes each)
    uint16_t *block = malloc(block_size * sizeof(uint16_t));
    if (!block) {
        ESP_LOGE(TAG, "Failed to alloc block");
        return ESP_ERR_NO_MEM;
    }
    
    for (uint32_t i = 0; i < block_size; i++) {
        block[i] = color;
    }
    
    while (total_pixels > 0) {
        uint32_t send_count = (total_pixels > block_size) ? block_size : total_pixels;
        spi_transaction_t t;
        memset(&t, 0, sizeof(t));
        t.length = send_count * 2 * 8;
        t.tx_buffer = block;
        t.user = (void *)1;
        spi_device_polling_transmit(dev->spi, &t);
        total_pixels -= send_count;
    }
    
    free(block);
    return ESP_OK;
}

esp_err_t st7735_draw_pixel(void *handle, int16_t x, int16_t y, uint16_t color)
{
    st7735_dev_t *dev = (st7735_dev_t *)handle;
    
    if (x < 0 || x >= dev->width || y < 0 || y >= dev->height) {
        return ESP_ERR_INVALID_ARG;
    }
    
    st7735_set_addr_window(dev, x, y, x, y);
    
    uint8_t color_data[2] = { color >> 8, color & 0xFF };
    st7735_send_array(dev, color_data, 2);
    return ESP_OK;
}

esp_err_t st7735_draw_rect(void *handle, int16_t x, int16_t y, 
                            uint16_t w, uint16_t h, uint16_t color)
{
    st7735_dev_t *dev = (st7735_dev_t *)handle;
    
    /* Rahmen zeichnen (nur Kanten) */
    /* Oben */
    st7735_draw_line(dev, x, y, x + w - 1, y, color);
    /* Unten */
    st7735_draw_line(dev, x, y + h - 1, x + w - 1, y + h - 1, color);
    /* Links */
    st7735_draw_line(dev, x, y, x, y + h - 1, color);
    /* Rechts */
    st7735_draw_line(dev, x + w - 1, y, x + w - 1, y + h - 1, color);
    
    return ESP_OK;
}

esp_err_t st7735_draw_line(void *handle, int16_t x0, int16_t y0, 
                           int16_t x1, int16_t y1, uint16_t color)
{
    st7735_dev_t *dev = (st7735_dev_t *)handle;
    
    /* Bresenham's Line Algorithm */
    int dx = abs(x1 - x0);
    int dy = abs(y1 - y0);
    int sx = (x0 < x1) ? 1 : -1;
    int sy = (y0 < y1) ? 1 : -1;
    int err = dx - dy;
    
    while (1) {
        st7735_draw_pixel(dev, x0, y0, color);
        
        if (x0 == x1 && y0 == y1) break;
        
        int e2 = 2 * err;
        if (e2 > -dy) {
            err -= dy;
            x0 += sx;
        }
        if (e2 < dx) {
            err += dx;
            y0 += sy;
        }
    }
    
    return ESP_OK;
}