/**
 * V2X-Sniffer Firmware f�r ESP32-C5 (T-Dongle-C5)
 * 
 * ESP32-C5: USB-CDC f�r Daten + 802.11p Promiscuous Mode
 * 
 * Funktion:
 * - Sniffed 802.11p V2X-Frames (BSM, CAM, DENM) auf 5.9 GHz Band
 * - L�st jedes Frame direkt in der Promisc-CB (kein Queue!)
 * - Speichert jedes Frame als CSV auf SD-Karte
 * - Channel-Hopping �ber alle V2X-Kan�le
 * - USB-CDC Live-Daten�bertragung
 * - Periodische Statistik ins Log
 * - CSV-Auto-Rotation bei >50MB
 * 
 * SD-Karte (SPI):
 *   GPIO CLK=6, MOSI=7, CMD=2, CS=23
 * 
 * USB-CDC:
 *   Native USB am ESP32-C5
 * 
 * CSV-Format (v2x_frames.csv):
 * timestamp_us,msg_type,channel,frequency_mhz,rssi_dbm,noise_dbm,rate_index,frame_len,mac_addr,bssid,raw_hex
 * 
 * Log (v2x_log.txt):
 * Start-Info, periodische Stats, Fehler, CSV-Rotation
 * 
 * Pinbelegung T-Dongle-C5:
 *   SD_CLK   = GPIO 6
 *   SD_MOSI  = GPIO 7 (D0)
 *   SD_CMD   = GPIO 2 (D2)
 *   SD_CS    = GPIO 23
 *   LED_CI   = GPIO 4  (APA102 Blue)
 *   LED_DI   = GPIO 5  (APA102 Green)
 */

#include <stdio.h>
#include <string.h>
#include <time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "nvs_flash.h"
#include "esp_timer.h"
#include "driver/usb_serial_jtag.h"
#include "driver/gpio.h"
#include "v2x_display.h"  /* Enth�lt v2x_frame_t, v2x_msg_type_t, Konstanten */

static const char *TAG = "V2X-Sniffer";

/* ====== 802.11p V2X-Kan�le (ETSI EN 302 637) ====== */
#define V2X_NUM_CHANNELS  10
static const uint32_t v2x_freqs[] = {
    5845, 5855, 5865, 5875,  /* Kanal 157-160 */
    5885, 5895, 5905, 5915,  /* Kanal 161-164 */
    5925, 4300,              /* Kanal 165, 4300 MHz */
};

/* Konstanten */
#define CHANNEL_HOP_INTERVAL_MS  (30 * 1000)
#define STAT_DUMP_INTERVAL_MS    (60 * 1000)
#define USB_BUF_SIZE             4096
#define CSV_FLUSH_INTERVAL       200

/* Globale Variablen */
uint32_t g_v2x_frame_count = 0;
int8_t   g_v2x_max_rssi = -120;
int      g_v2x_channel_idx = 0;
uint32_t g_v2x_current_freq = 5900;

/* ====== Message-Type Erkennung ====== */
static v2x_msg_type_t detect_msg_type(const uint8_t *data, uint16_t len)
{
    if (!data || len < 8) return V2X_MSG_UNKNOWN;
    
    /* SAE J2735 BSM: protocolVersion(1) + messageID(1) + length(2) */
    uint8_t proto = data[0];
    if (proto > 3) return V2X_MSG_UNKNOWN;
    
    uint8_t msg_id = data[1];
    
    /* CAM (C2C: Cooperation Awareness Message) */
    if (msg_id == 0x02) return V2X_MSG_CAM;
    
    /* DENM (C2I: Decentralized Environmental Notification Message) */
    if (msg_id == 0x03) return V2X_MSG_DENM;
    
    /* BSM (BSM: Basic Safety Message) */
    if (msg_id == 0x01) return V2X_MSG_BSM;
    
    /* IEEE 1609.2 Security Extension */
    if (msg_id == 0x60) return V2X_MSG_BSM;
    
    return V2X_MSG_UNKNOWN;
}

/* ====== 802.11p Promiscuous Callback (direktes Processing!) ====== */
static void v2x_promiscuous_cb(void *arg, wifi_promiscuous_pkt_type_t pkt_type)
{
    (void)arg;
    (void)pkt_type;

    wifi_promiscuous_pkt_t *pkt = (wifi_promiscuous_pkt_t *)arg;
    if (!pkt) return;

    v2x_frame_t frame;
    memset(&frame, 0, sizeof(frame));

    frame.timestamp_us = (uint64_t)esp_timer_get_time();
    frame.rssi_dbm = pkt->rx_ctrl.rssi;
    frame.noise_dbm = pkt->rx_ctrl.noise_floor;
    frame.rate_index = pkt->rx_ctrl.rate;
    frame.frame_len = pkt->rx_ctrl.sig_len;
    frame.frequency_mhz = (float)g_v2x_current_freq;
    frame.channel = g_v2x_channel_idx;

    /* MAC-Adressen extrahieren */
    if (pkt->rx_ctrl.sig_len >= 30) {
        uint8_t *mac = pkt->payload;
        memcpy(frame.bssid, mac + 10, 6);
        memcpy(frame.mac_addr, mac + 16, 6);
    }

    /* V2X-Payload ab Offset 24 */
    uint16_t v2x_offset = 24;
    if (pkt->rx_ctrl.sig_len > v2x_offset) {
        frame.raw_len = pkt->rx_ctrl.sig_len - v2x_offset;
        if (frame.raw_len > V2X_MAX_FRAME_LEN) {
            frame.raw_len = V2X_MAX_FRAME_LEN;
        }
        memcpy(frame.raw_data, pkt->payload + v2x_offset, frame.raw_len);
        frame.msg_type = detect_msg_type(frame.raw_data, frame.raw_len);
        
        if (frame.rssi_dbm > g_v2x_max_rssi) {
            g_v2x_max_rssi = frame.rssi_dbm;
        }
    }

    /* === Auf SD-Karte schreiben (CSV + Stats via v2x_driver) === */
    v2x_sd_write_frame(&frame);

    /* === Als Live-Dump über USB-Serial-JTAG senden === */
    if (usb_serial_jtag_is_connected()) {
        char usb_buf[RAW_HEX_BUF + 256];
        frame_to_csv_line(&frame, usb_buf, sizeof(usb_buf));
        usb_serial_jtag_write_bytes(usb_buf, strlen(usb_buf), 100);
    }


    g_v2x_frame_count++;
}

/* ====== Channel Hopper Task ====== */
static void v2x_channel_hopper_task(void *pvParameters)
{
    uint8_t hop_idx = 0;

    ESP_LOGI(TAG, "Channel Hopper gestartet (jedes %d Sekunden)", CHANNEL_HOP_INTERVAL_MS / 1000);

    while (1) {
        uint32_t freq = v2x_freqs[hop_idx % V2X_NUM_CHANNELS];
        
        /* ESP32-C5: WiFi Channel direkt setzen */
        esp_err_t ch_ret = esp_wifi_set_channel(
            (uint8_t)(freq / 5),  /* Channel number (freq/5 f�r 5GHz) */
            WIFI_SECOND_CHAN_NONE
        );
        if (ch_ret != ESP_OK) {
            ESP_LOGW(TAG, "Channel-Wechsel fehlgeschlagen: %s", esp_err_to_name(ch_ret));
        }
        
        g_v2x_current_freq = freq;
        g_v2x_channel_idx = hop_idx;

        ESP_LOGI(TAG, "CH %d: %lu MHz", hop_idx, (unsigned long)freq);
        
        hop_idx++;
        vTaskDelay(pdMS_TO_TICKS(CHANNEL_HOP_INTERVAL_MS));
    }
}

/* ====== Statistik Task ====== */
static void v2x_stats_task(void *pvParameters)
{
    ESP_LOGI(TAG, "Statistik-Task gestartet");

    while (1) {
        v2x_sd_dump_stats();
        
        ESP_LOGI(TAG, "Frames: %lu | Max RSSI: %d dBm", 
                 (unsigned long)g_v2x_frame_count, g_v2x_max_rssi);
        
        vTaskDelay(pdMS_TO_TICKS(STAT_DUMP_INTERVAL_MS));
    }
}

/* ====== Application Entry Point ====== */
void app_main(void)
{
    ESP_LOGI(TAG, "====== V2X-Sniffer f�r ESP32-C5 BEREIT =======");
    ESP_LOGI(TAG, "802.11p V2X-Band (5.9 GHz) | SD-Karte (SPI) | USB-CDC");
    ESP_LOGI(TAG, "=================================");

    /* === NVS initialisieren === */
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_LOGW(TAG, "NVS bereinigen...");
        nvs_flash_erase();
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    /* === USB-Serial-JTAG initialisieren === */
    usb_serial_jtag_driver_config_t usb_cfg = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT();
    ret = usb_serial_jtag_driver_install(&usb_cfg);
    if (ret == ESP_OK) {
        ESP_LOGI(TAG, "USB-Serial-JTAG initialisiert");
    } else {
        ESP_LOGW(TAG, "USB-Serial-JTAG nicht verf�gbar");
    }

    /* === WiFi initialisieren === */
    esp_netif_init();
    esp_event_loop_create_default();
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_start();

    /* === SD-Karte initialisieren (SPI-Modus) === */
    ESP_LOGI(TAG, "Initialisiere SD-Karte (GPIO6/7/2/23)...");
    ret = v2x_sd_init();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "SD-Karte fehlgeschlagen: %s", esp_err_to_name(ret));
        ESP_LOGW(TAG, "Fahre ohne SD-Karte fort (Daten gehen verloren)!");
    } else {
        FILE *fp = fopen(SD_CSV_FILE, "a+");
        if (fp) {
            fprintf(fp, "%s\n", CSV_HEADER);
            fclose(fp);
            ESP_LOGI(TAG, "CSV-Header geschrieben: %s", SD_CSV_FILE);
        }
    }

    /* === Stats initialisieren === */
    v2x_sd_reset_stats();

    /* === Tasks starten === */
    xTaskCreate(v2x_channel_hopper_task, "channel_hopper", 4096, NULL, 3, NULL);
    xTaskCreate(v2x_stats_task, "stats_task", 2048, NULL, 2, NULL);

    /* === Promiscuous Mode aktivieren === */
    esp_wifi_set_promiscuous(true);
    esp_wifi_set_promiscuous_rx_cb(v2x_promiscuous_cb);

    ESP_LOGI(TAG, "====== V2X-Sniffer BETRIEB BEREIT ======");
    ESP_LOGI(TAG, "  SD:     %s (SPI)", SD_CARD_MOUNT_POINT);
    ESP_LOGI(TAG, "  CSV:    %s", SD_CSV_FILE);
    ESP_LOGI(TAG, "  Log:    %s", SD_LOG_FILE);
    ESP_LOGI(TAG, "  Kanal:  157-164 + 17/18 (5.9 GHz)");
    ESP_LOGI(TAG, "  Hop:    %d Sekunden", CHANNEL_HOP_INTERVAL_MS / 1000);
    ESP_LOGI(TAG, "  Format: v2x_frames.csv (Excel/CSV-kompatibel)");
    ESP_LOGI(TAG, "=============================================");
}