/**
 * DMX Monitor for M5Stack Core2 + ISOLATED RS485 Unit
 * 
 * ISOLATED RS485ユニット（CA IS3082W絶縁トランシーバ）をPort Aに接続して
 * DMX512信号を受信し、Core2のディスプレイにチャンネル値を表示
 * 
 * 接続:
 *   ISOLATED RS485 Unit (Port A):
 *     - TXD: GPIO33
 *     - RXD: GPIO32
 *     - 5V:  5V
 *     - GND: GND
 *   RS485側:
 *     - A → DMX+ (Data+)
 *     - B → DMX- (Data-)
 *     - GND → DMX GND
 */

#include <M5Unified.hpp>
#include <M5GFX.h>
#include <esp_dmx.h>
#include <esp_intr_alloc.h>
#include "build_time.h"

// ========================================
// DMX設定（Core2 + ISOLATED RS485 Unit - Port A）
// ========================================
#define DMX_RX_PIN      33    // GPIO33 (Port A) ← ユニットのTXDに接続
#define DMX_TX_PIN      32    // GPIO32 (Port A) → ユニットのRXDに接続
#define DMX_EN_PIN      -1    // ENピンなし（IS3082Wは自動方向切り替え）

const dmx_port_t DMX_PORT = DMX_NUM_1;
#define DMX_CH_COUNT    512
#define DMX_TIMEOUT_MS  3000
#define DMX_RECV_TIMEOUT_TICK pdMS_TO_TICKS(30)

// DMXデータ
static uint8_t dmx_data[DMX_PACKET_SIZE];
static bool dmx_signal_detected = false;
static unsigned long last_dmx_packet = 0;
static int dmx_packet_count = 0;
static int dmx_packet_per_sec = 0;
static unsigned long last_count_reset = 0;
static int dmx_data_length = -1;
static int dmx_data_length_min = 512;
static int dmx_data_length_max = 0;
static int dmx_data_length_change_count = 0;

// 表示設定
static int display_start_ch = 1;
static const int DISPLAY_COLS = 10;
static const int DISPLAY_ROWS = 6;
static const int DISPLAY_CH_COUNT = DISPLAY_COLS * DISPLAY_ROWS;

// 前回値（差分更新用）
static uint8_t prev_dmx_values[DMX_PACKET_SIZE];
static bool screen_initialized = false;
static int prev_packet_per_sec = -1;
static int prev_data_length = -1;
static int prev_len_min = -1;
static int prev_len_max = -1;
static int prev_len_change_count = -1;
static int prev_start_ch = -1;
static int dmx_display_mode = 0;

// LCD更新周波数計測
static int lcd_update_count = 0;
static int lcd_update_per_sec = 0;
static unsigned long last_lcd_count_reset = 0;
static int prev_lcd_update_per_sec = -1;

// 最後に変化したチャンネル情報
static int last_changed_ch = 0;
static uint8_t last_changed_value = 0;
static int prev_last_changed_ch = -1;
static uint8_t prev_last_changed_value = 255;
static int frame_min_changed_ch = 9999;
static uint8_t frame_min_changed_value = 0;

// デュアルコア
static TaskHandle_t displayTaskHandle = NULL;
static SemaphoreHandle_t dmxDataMutex = NULL;
static uint8_t dmx_data_copy[DMX_PACKET_SIZE];

// 512chバーグラフ用
static uint8_t prev_512_values[513];
static bool bar512_initialized = false;

// スプライト
static M5Canvas cellSprite(&M5.Display);
static bool sprite_initialized = false;

// 小型数字フォント（4x6ピクセル）
static const uint8_t smallDigits[16][6] = {
    {0b0110, 0b1001, 0b1001, 0b1001, 0b1001, 0b0110}, // 0
    {0b0010, 0b0110, 0b0010, 0b0010, 0b0010, 0b0111}, // 1
    {0b0110, 0b1001, 0b0010, 0b0100, 0b1000, 0b1111}, // 2
    {0b0110, 0b1001, 0b0010, 0b0001, 0b1001, 0b0110}, // 3
    {0b0001, 0b0011, 0b0101, 0b1001, 0b1111, 0b0001}, // 4
    {0b1111, 0b1000, 0b1110, 0b0001, 0b1001, 0b0110}, // 5
    {0b0110, 0b1000, 0b1110, 0b1001, 0b1001, 0b0110}, // 6
    {0b1111, 0b0001, 0b0010, 0b0010, 0b0100, 0b0100}, // 7
    {0b0110, 0b1001, 0b0110, 0b1001, 0b1001, 0b0110}, // 8
    {0b0110, 0b1001, 0b1001, 0b0111, 0b0001, 0b0110}, // 9
    {0b0110, 0b1001, 0b1111, 0b1001, 0b1001, 0b1001}, // A
    {0b1110, 0b1001, 0b1110, 0b1001, 0b1001, 0b1110}, // B
    {0b0110, 0b1001, 0b1000, 0b1000, 0b1001, 0b0110}, // C
    {0b1110, 0b1001, 0b1001, 0b1001, 0b1001, 0b1110}, // D
    {0b1111, 0b1000, 0b1110, 0b1000, 0b1000, 0b1111}, // E
    {0b1111, 0b1000, 0b1110, 0b1000, 0b1000, 0b1000}, // F
};

// スプライトに小さい数字を描画
void drawSmallDigitSprite(M5Canvas* spr, int x, int y, int digit, uint16_t color, int scale) {
    if (digit < 0 || digit > 15) return;
    for (int row = 0; row < 6; row++) {
        for (int col = 0; col < 4; col++) {
            if (smallDigits[digit][row] & (0b1000 >> col)) {
                if (scale == 1) {
                    spr->drawPixel(x + col, y + row, color);
                } else {
                    spr->fillRect(x + col * scale, y + row * scale, scale, scale, color);
                }
            }
        }
    }
}

// LCDに小さい数字を描画
void drawSmallDigit(int x, int y, int digit, uint16_t color, int scale) {
    if (digit < 0 || digit > 15) return;
    for (int row = 0; row < 6; row++) {
        for (int col = 0; col < 4; col++) {
            if (smallDigits[digit][row] & (0b1000 >> col)) {
                if (scale == 1) {
                    M5.Display.drawPixel(x + col, y + row, color);
                } else {
                    M5.Display.fillRect(x + col * scale, y + row * scale, scale, scale, color);
                }
            }
        }
    }
}

// 2桁数字を描画（LCD）
void drawSmallNumber2(int x, int y, int num, uint16_t color, int scale) {
    char buf[3];
    snprintf(buf, sizeof(buf), "%2d", num);
    int char_w = 5 * scale;
    for (int i = 0; i < 2; i++) {
        char c = buf[i];
        if (c == ' ') continue;
        int digit = c - '0';
        drawSmallDigit(x + i * char_w, y, digit, color, scale);
    }
}

// 3桁数字を描画（LCD）- ゼロ埋め
void drawSmallNumber3(int x, int y, int num, uint16_t color, int scale) {
    char buf[4];
    snprintf(buf, sizeof(buf), "%03d", num);
    int char_w = 5 * scale;
    for (int i = 0; i < 3; i++) {
        char c = buf[i];
        int digit = c - '0';
        drawSmallDigit(x + i * char_w, y, digit, color, scale);
    }
}

// ========================================
// DMX初期化
// ========================================
void initDmx() {
    Serial.println("Initializing DMX...");
    
    dmx_config_t config = {
        .interrupt_flags = ESP_INTR_FLAG_IRAM,
        .root_device_parameter_count = 0,
        .sub_device_parameter_count = 0,
        .model_id = 0,
        .product_category = 0,
        .software_version_id = 0x00010000,
        .software_version_label = "1.0.0",
        .queue_size_max = 0
    };
    
    if (!dmx_driver_install(DMX_PORT, &config, nullptr, 0)) {
        Serial.println("DMX driver install failed!");
        return;
    }
    
    if (!dmx_set_pin(DMX_PORT, DMX_TX_PIN, DMX_RX_PIN, DMX_EN_PIN)) {
        Serial.println("DMX set pin failed!");
        return;
    }
    
    if (DMX_EN_PIN >= 0) {
        pinMode(DMX_EN_PIN, OUTPUT);
        digitalWrite(DMX_EN_PIN, LOW);
    }
    
    Serial.printf("DMX initialized: RX=GPIO%d, TX=GPIO%d\n", DMX_RX_PIN, DMX_TX_PIN);
}

// ========================================
// 初期画面描画
// ========================================
void drawInitScreen() {
    M5.Display.fillScreen(TFT_BLACK);
    
    M5.Display.setTextDatum(textdatum_t::top_left);
    M5.Display.setFont(&fonts::Font0);
    M5.Display.setTextColor(M5.Display.color565(128, 128, 128));
    char title[32];
    snprintf(title, sizeof(title), "DMX %03d-%03d", display_start_ch, display_start_ch + DISPLAY_CH_COUNT - 1);
    M5.Display.drawString(title, 2, 2);
    
    prev_last_changed_ch = -1;
    
    const int grid_x = 0;
    const int grid_y = 15;
    const int cell_w = 32;
    const int cell_h = 30;
    const int bar_w = 2;
    const int bar_max_h = 26;
    const uint16_t row_line_color = M5.Display.color565(0, 0, 60);
    
    for (int row = 0; row < DISPLAY_ROWS; row++) {
        int top_line_y = grid_y + row * cell_h - 1;
        M5.Display.drawFastHLine(0, top_line_y, 320, row_line_color);
        
        for (int col = 0; col < DISPLAY_COLS; col++) {
            int ch = display_start_ch + row * DISPLAY_COLS + col;
            int x = grid_x + col * cell_w;
            int y = grid_y + row * cell_h;
            
            drawSmallNumber2(x + cell_w - bar_w - 11, y + 1, ch, TFT_DARKGREY, 1);
            
            int bar_x = x + cell_w - bar_w;
            int bar_y = y - 1;
            M5.Display.fillRect(bar_x, bar_y, bar_w, bar_max_h, M5.Display.color565(30, 30, 30));
        }
        int line_y = grid_y + (row + 1) * cell_h - 1;
        M5.Display.drawFastHLine(0, line_y, 320, row_line_color);
    }
    
    M5.Display.fillRect(0, 232, 320, 8, TFT_BLACK);
    
    M5.Display.setTextDatum(textdatum_t::bottom_right);
    M5.Display.setTextColor(TFT_DARKGREY);
    M5.Display.setFont(&fonts::Font0);
    M5.Display.drawString(BUILD_TIMESTAMP, 318, 240);
    
    if (!sprite_initialized) {
        cellSprite.setColorDepth(16);
        cellSprite.createSprite(32, 28);
        sprite_initialized = true;
    }
    
    screen_initialized = true;
    prev_start_ch = display_start_ch;
    
    memset(prev_dmx_values, 0xFF, sizeof(prev_dmx_values));
    
    // 512chバーグラフも再初期化が必要
    bar512_initialized = false;
    memset(prev_512_values, 0, sizeof(prev_512_values));
    
    // フッター表示も強制更新
    prev_packet_per_sec = -1;
    prev_data_length = -1;
    prev_len_min = -1;
    prev_len_max = -1;
    prev_len_change_count = -1;
    prev_lcd_update_per_sec = -1;
}

// ========================================
// DMX受信処理
// ========================================
void processDmxReceive() {
    dmx_packet_t packet;
    unsigned long now = millis();
    
    if (dmx_receive(DMX_PORT, &packet, DMX_RECV_TIMEOUT_TICK)) {
        if (packet.err == DMX_OK) {
            if (dmxDataMutex != NULL && xSemaphoreTake(dmxDataMutex, pdMS_TO_TICKS(1)) == pdTRUE) {
                dmx_read(DMX_PORT, dmx_data, packet.size);
                xSemaphoreGive(dmxDataMutex);
            } else {
                dmx_read(DMX_PORT, dmx_data, packet.size);
            }
            int len = packet.size - 1;
            
            if (len != dmx_data_length) {
                if (dmx_data_length_change_count < 999) {
                    dmx_data_length_change_count++;
                }
            }
            
            if (len < dmx_data_length_min) {
                dmx_data_length_min = len;
            }
            if (len > dmx_data_length_max) {
                dmx_data_length_max = len;
            }
            
            dmx_data_length = len;
            
            last_dmx_packet = now;
            dmx_signal_detected = true;
            dmx_packet_count++;
            
            if (last_count_reset == 0) {
                last_count_reset = now;
            }
            if (now - last_count_reset >= 1000) {
                dmx_packet_per_sec = dmx_packet_count;
                dmx_packet_count = 0;
                last_count_reset = now;
            }
        }
    }
    
    if (dmx_signal_detected && (now - last_dmx_packet > DMX_TIMEOUT_MS)) {
        dmx_signal_detected = false;
        dmx_packet_per_sec = 0;
        dmx_data_length = -1;
        dmx_data_length_min = 512;
        dmx_data_length_max = 0;
        dmx_data_length_change_count = 0;
        prev_data_length = -1;
        prev_len_min = -1;
        prev_len_max = -1;
        prev_len_change_count = -1;
        last_count_reset = 0;
    }
}

// ========================================
// ボタン処理
// ========================================
void handleButtons() {
    M5.update();
    
    auto touch = M5.Touch.getDetail();
    if (touch.wasPressed()) {
        int tx = touch.x;
        int ty = touch.y;
        
        if (ty > 160) {
            if (tx < 107) {
                display_start_ch -= DISPLAY_CH_COUNT;
                if (display_start_ch < 1) display_start_ch = 1;
            } else if (tx > 213) {
                display_start_ch += DISPLAY_CH_COUNT;
                if (display_start_ch > 512 - DISPLAY_CH_COUNT + 1) {
                    display_start_ch = 512 - DISPLAY_CH_COUNT + 1;
                }
            } else {
                dmx_display_mode = (dmx_display_mode + 1) % 3;
                memset(prev_dmx_values, 0xFF, sizeof(prev_dmx_values));
            }
        }
    }
}

// ========================================
// 画面更新タスク（Core 0で実行）
// ========================================
void displayTask(void* parameter) {
    unsigned long last_display_update = 0;
    unsigned long last_button_check = 0;
    
    while (true) {
        unsigned long now = millis();
        
        if (now - last_button_check >= 100) {
            last_button_check = now;
            handleButtons();
        }
        
        if (now - last_display_update >= 25) {
            last_display_update = now;
            
            if (xSemaphoreTake(dmxDataMutex, pdMS_TO_TICKS(5)) == pdTRUE) {
                memcpy(dmx_data_copy, dmx_data, sizeof(dmx_data));
                xSemaphoreGive(dmxDataMutex);
            }
            
            updateDmxMonitor();
        }
        
        vTaskDelay(pdMS_TO_TICKS(1));
    }
}

// ========================================
// セットアップ
// ========================================
void setup() {
    auto cfg = M5.config();
    cfg.serial_baudrate = 115200;
    M5.begin(cfg);
    
    Serial.println("\n=== DMX Monitor for Core2 + ISOLATED RS485 ===");
    
    dmxDataMutex = xSemaphoreCreateMutex();
    
    M5.Display.setRotation(1);
    M5.Display.setBrightness(128);
    M5.Display.fillScreen(TFT_BLACK);
    
    initDmx();
    drawInitScreen();
    
    xTaskCreatePinnedToCore(
        displayTask, "DisplayTask", 8192, NULL, 1,
        &displayTaskHandle, 0
    );
    
    Serial.println("Setup complete!");
}

// ========================================
// メインループ（Core 1でDMX受信専用）
// ========================================
void loop() {
    processDmxReceive();
}