// components/meter_manager/driver/meter_modbus/meter_dds661.c
// Driver Modbus RTU para DDS661.
// Suporta 1 ou 2 DDS661 no mesmo bus RS485:
//   GRID -> slave ID 1
//   EVSE -> slave ID 2
// Usa um único Modbus master e uma única task de leitura.

#include "meter_dds661.h"

#include "modbus_params.h"
#include "mbcontroller.h"
#include "meter_events.h"

#include "esp_log.h"
#include "esp_timer.h"
#include "driver/uart.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"

#include <stddef.h>
#include <string.h>
#include <math.h>

#define TAG "serial_mdb_dds661"

// ======= UART/Modbus config =======
#define MB_PORT_NUM 2
#define MB_DEV_SPEED 9600

// Ajuste os pinos conforme seu hardware (evite GPIO2 para RTS/DE/RE se possível)
#define MB_UART_TXD 17
#define MB_UART_RXD 16
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485

// ======= DDS661 no mesmo bus =======
#define DDS661_GRID_SLAVE_ID 1
#define DDS661_EVSE_SLAVE_ID 2

#define UPDATE_INTERVAL (3000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (120 / portTICK_PERIOD_MS)
#define DDS661_LOCK_TIMEOUT pdMS_TO_TICKS(10000)

// ======= Helpers típicos do teu projeto =======
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
#define STR(x) ((const char *)(x))
#define OPTS(min, max, step) {.opt1 = min, .opt2 = max, .opt3 = step}
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

// ======= Estado =======
static bool is_initialized = false;
static volatile bool task_should_run = false;
static TaskHandle_t meter_task = NULL;
static SemaphoreHandle_t dds661_lock = NULL;

// ======= CIDs locais por meter =======
enum
{
    CID_VOLTAGE = 0,
    CID_CURRENT,
    CID_ACTIVE_POWER_KW,
    CID_POWER_FACTOR,
    CID_FREQUENCY,
    CID_TOTAL_ACTIVE_ENERGY_KWH,
    CID_COUNT
};

typedef enum
{
    DDS661_SLOT_GRID = 0,
    DDS661_SLOT_EVSE,
    DDS661_MAX_INSTANCES
} dds661_slot_t;

typedef struct
{
    bool registered;
    const char *source; // "GRID" ou "EVSE"
    uint8_t slave_id;   // 1 ou 2
    uint16_t cid_base;  // atribuído dinamicamente em dds661_rebuild_descriptors_locked()
} dds661_instance_t;

static dds661_instance_t dds661_instances[DDS661_MAX_INSTANCES] = {
    [DDS661_SLOT_GRID] = {
        .registered = false,
        .source = "GRID",
        .slave_id = DDS661_GRID_SLAVE_ID,
        .cid_base = 0,
    },
    [DDS661_SLOT_EVSE] = {
        .registered = false,
        .source = "EVSE",
        .slave_id = DDS661_EVSE_SLAVE_ID,
        .cid_base = 0,
    },
};

// ======= Mapa de registradores (Input Registers; FC=0x04) =======
// Endereços típicos para DDS-661 (float32):
#define REG_VOLTAGE 0x0000         // V    (float32)
#define REG_CURRENT 0x0008         // A    (float32)
#define REG_ACTIVE_POWER_KW 0x0012 // kW   (float32)
#define REG_POWER_FACTOR 0x002A    // PF   (float32)
#define REG_FREQUENCY 0x0036       // Hz   (float32)
#define REG_E_ACTIVE_KWH 0x0100    // kWh  (float32)

// ======= Template de parâmetros para um DDS661 =======
static const mb_parameter_descriptor_t dds661_param_template[CID_COUNT] = {
    {CID_VOLTAGE, "Voltage", "V", 1,
     MB_PARAM_INPUT, REG_VOLTAGE, 2, HOLD_OFFSET(l1_voltage),
     PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},

    {CID_CURRENT, "Current", "A", 1,
     MB_PARAM_INPUT, REG_CURRENT, 2, HOLD_OFFSET(l1_current),
     PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},

    {CID_ACTIVE_POWER_KW, "Active Power", "kW", 1,
     MB_PARAM_INPUT, REG_ACTIVE_POWER_KW, 2, HOLD_OFFSET(active_power),
     PARAM_TYPE_FLOAT_CDAB, 4, OPTS(-100, 100, 0.01), PAR_PERMS_READ},

    {CID_POWER_FACTOR, "Power Factor", "", 1,
     MB_PARAM_INPUT, REG_POWER_FACTOR, 2, HOLD_OFFSET(power_factor),
     PARAM_TYPE_FLOAT_CDAB, 4, OPTS(-1, 1, 0.001), PAR_PERMS_READ},

    {CID_FREQUENCY, "Frequency", "Hz", 1,
     MB_PARAM_INPUT, REG_FREQUENCY, 2, HOLD_OFFSET(frequency),
     PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},

    {CID_TOTAL_ACTIVE_ENERGY_KWH, "Total Active Energy", "kWh", 1,
     MB_PARAM_INPUT, REG_E_ACTIVE_KWH, 2, HOLD_OFFSET(active_energy),
     PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 1000000, 0.01), PAR_PERMS_READ},
};

// O esp-modbus exige cid e param_key únicos no Data Dictionary.
// Como GRID e EVSE usam o mesmo mapa de registos, o param_key precisa de prefixo por instância.
static const char *const dds661_param_keys[DDS661_MAX_INSTANCES][CID_COUNT] = {
    [DDS661_SLOT_GRID] = {
        "GRID Voltage",
        "GRID Current",
        "GRID Active Power",
        "GRID Power Factor",
        "GRID Frequency",
        "GRID Total Active Energy",
    },
    [DDS661_SLOT_EVSE] = {
        "EVSE Voltage",
        "EVSE Current",
        "EVSE Active Power",
        "EVSE Power Factor",
        "EVSE Frequency",
        "EVSE Total Active Energy",
    },
};

static mb_parameter_descriptor_t device_parameters_dds661[DDS661_MAX_INSTANCES * CID_COUNT];
static uint16_t num_device_parameters_dds661 = 0;
static bool dds661_descriptor_dirty = true;

// ======= Ponteiro para buffer destino =======
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
{
    if (!param || param->param_offset == 0)
        return NULL;
    return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
}

static bool dds661_has_registered_instance_locked(void)
{
    for (uint8_t i = 0; i < DDS661_MAX_INSTANCES; ++i)
    {
        if (dds661_instances[i].registered)
            return true;
    }
    return false;
}

static esp_err_t dds661_rebuild_descriptors_locked(void)
{
    num_device_parameters_dds661 = 0;
    dds661_descriptor_dirty = true;

    for (uint8_t inst_idx = 0; inst_idx < DDS661_MAX_INSTANCES; ++inst_idx)
    {
        dds661_instance_t *inst = &dds661_instances[inst_idx];
        if (!inst->registered)
            continue;

        // Mantém os CIDs contíguos no descriptor ativo.
        // Isto evita problemas em versões do esp-modbus que tratam CID como índice.
        inst->cid_base = num_device_parameters_dds661;

        for (uint16_t local_cid = 0; local_cid < CID_COUNT; ++local_cid)
        {
            mb_parameter_descriptor_t *dst = &device_parameters_dds661[num_device_parameters_dds661++];
            *dst = dds661_param_template[local_cid];
            dst->cid = inst->cid_base + local_cid;
            dst->param_key = dds661_param_keys[inst_idx][local_cid];
            dst->mb_slave_addr = inst->slave_id;
        }
    }

    dds661_descriptor_dirty = true;

    ESP_LOGI(TAG, "DDS661 descriptor table prepared: %u parameters", num_device_parameters_dds661);
    return ESP_OK;
}

static esp_err_t dds661_apply_descriptors_locked(void)
{
    if (num_device_parameters_dds661 == 0)
        return ESP_ERR_INVALID_STATE;

    if (!dds661_descriptor_dirty)
        return ESP_OK;

    esp_err_t err = mbc_master_set_descriptor(device_parameters_dds661, num_device_parameters_dds661);
    if (err != ESP_OK)
    {
        ESP_LOGE(TAG, "mbc_master_set_descriptor failed: %s", esp_err_to_name(err));
        return err;
    }

    dds661_descriptor_dirty = false;
    ESP_LOGI(TAG, "DDS661 descriptor table applied: %u parameters", num_device_parameters_dds661);
    return ESP_OK;
}

static esp_err_t dds661_master_init_once(void)
{
    if (is_initialized)
        return ESP_OK;

    if (!dds661_lock)
    {
        dds661_lock = xSemaphoreCreateMutex();
        if (!dds661_lock)
            return ESP_ERR_NO_MEM;
    }

    ESP_LOGI(TAG, "meter_dds661 Modbus master init");

    mb_communication_info_t comm = {
        .port = MB_PORT_NUM,
        .mode = MB_MODE_RTU,
        .baudrate = MB_DEV_SPEED,
        .parity = UART_PARITY_EVEN, // DDS-661: 9600 8E1
    };

    void *handler = NULL;
    esp_err_t err = mbc_master_init(MB_PORT_SERIAL_MASTER, &handler);
    if (err != ESP_OK)
        return err;

    err = mbc_master_setup(&comm);
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    // Pinos e parâmetros básicos
    err = uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE);
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    err = uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS);
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    err = uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0);
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    err = uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1);
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    // IMPORTANTE: start antes do set_mode
    err = mbc_master_start();
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    // Só agora muda para RS485 half duplex
    err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX);
    if (err != ESP_OK)
    {
        (void)mbc_master_destroy();
        return err;
    }

    // Logs de debug Modbus. Reduz para ESP_LOG_INFO/ESP_LOG_WARN em produção se necessário.
    esp_log_level_set("MB_CONTROLLER_MASTER", ESP_LOG_DEBUG);
    esp_log_level_set("MB_PORT_COMMON", ESP_LOG_DEBUG);
    esp_log_level_set("MB_SERIAL_MASTER", ESP_LOG_DEBUG);

    vTaskDelay(pdMS_TO_TICKS(5));

    is_initialized = true;
    return ESP_OK;
}

static esp_err_t dds661_register_instance(dds661_slot_t slot)
{
    if (slot >= DDS661_MAX_INSTANCES)
        return ESP_ERR_INVALID_ARG;

    esp_err_t err = dds661_master_init_once();
    if (err != ESP_OK)
        return err;

    if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) != pdTRUE)
        return ESP_ERR_TIMEOUT;

    dds661_instances[slot].registered = true;
    ESP_LOGI(TAG, "DDS661 %s registered on Modbus slave ID %u",
             dds661_instances[slot].source,
             dds661_instances[slot].slave_id);

    err = dds661_rebuild_descriptors_locked();
    xSemaphoreGive(dds661_lock);

    return err;
}

static void dds661_shutdown_if_idle(void)
{
    bool any_registered = false;

    if (dds661_lock && xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) == pdTRUE)
    {
        any_registered = dds661_has_registered_instance_locked();
        xSemaphoreGive(dds661_lock);
    }

    if (any_registered || !is_initialized)
        return;

    ESP_LOGI(TAG, "No DDS661 instances registered; stopping shared Modbus master");

    task_should_run = false;
    for (int i = 0; i < 20 && meter_task != NULL; ++i)
    {
        vTaskDelay(pdMS_TO_TICKS(10));
    }

    if (meter_task != NULL)
    {
        ESP_LOGW(TAG, "DDS661 task did not exit in time; deleting it");
        vTaskDelete(meter_task);
        meter_task = NULL;
    }

    esp_err_t err = mbc_master_destroy();
    if (err != ESP_OK)
        ESP_LOGW(TAG, "mbc_master_destroy() returned %s", esp_err_to_name(err));

    if (uart_is_driver_installed(MB_PORT_NUM))
        uart_driver_delete(MB_PORT_NUM);

    is_initialized = false;
    num_device_parameters_dds661 = 0;
    dds661_descriptor_dirty = true;
}

static void dds661_unregister_instance(dds661_slot_t slot)
{
    if (slot >= DDS661_MAX_INSTANCES)
        return;

    if (!is_initialized || !dds661_lock)
        return;

    if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) == pdTRUE)
    {
        ESP_LOGI(TAG, "DDS661 %s unregistered", dds661_instances[slot].source);
        dds661_instances[slot].registered = false;
        (void)dds661_rebuild_descriptors_locked();
        xSemaphoreGive(dds661_lock);
    }

    dds661_shutdown_if_idle();
}

static void dds661_read_instance_locked(const dds661_instance_t *inst)
{
    esp_err_t err;
    const mb_parameter_descriptor_t *desc = NULL;

    float v = 0.0f;     // V
    float i = 0.0f;     // A
    float pf = 0.0f;    // -
    float hz = 0.0f;    // Hz
    float e_kwh = 0.0f; // kWh
    float p_kw = 0.0f;  // kW

    float voltage[3] = {0};
    float current[3] = {0};
    int32_t watt[3] = {0};

    bool got_any_value = false;

    for (uint16_t local_cid = 0; local_cid < CID_COUNT; local_cid++)
    {
        const uint16_t cid = inst->cid_base + local_cid;

        err = mbc_master_get_cid_info(cid, &desc);
        if (err != ESP_OK || !desc)
        {
            ESP_LOGE(TAG, "%s get_cid_info(%u) failed: %s", inst->source, cid, esp_err_to_name(err));
            continue;
        }

        void *data_ptr = get_param_ptr(desc);
        if (!data_ptr)
        {
            ESP_LOGE(TAG, "%s CID %u (%s): null data_ptr", inst->source, cid, desc->param_key);
            continue;
        }

        uint8_t type = 0;
        err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
        if (err != ESP_OK)
        {
            ESP_LOGE(TAG, "%s CID %u (%s) read failed: %s",
                     inst->source, cid, desc->param_key, esp_err_to_name(err));
            vTaskDelay(POLL_INTERVAL);
            continue;
        }

        uint8_t raw[4];
        memcpy(raw, data_ptr, sizeof(raw));
        ESP_LOGD(TAG, "%s CID %u (%s) raw bytes: %02X %02X %02X %02X",
                 inst->source, cid, desc->param_key, raw[0], raw[1], raw[2], raw[3]);

        const float val = *(float *)data_ptr;
        got_any_value = true;

        ESP_LOGD(TAG, "%s %s: %.3f %s", inst->source, desc->param_key, val, desc->param_units);

        switch (local_cid)
        {
        case CID_VOLTAGE:
            v = val;
            voltage[0] = v;
            break;
        case CID_CURRENT:
            i = val;
            current[0] = i;
            break;
        case CID_POWER_FACTOR:
            pf = val;
            break;
        case CID_FREQUENCY:
            hz = val;
            break;
        case CID_ACTIVE_POWER_KW:
        {
            p_kw = val;

            /*
             * DDS661 bidirecional:
             *   p_w > 0  => importação
             *   p_w < 0  => exportação
             *
             * Alguns modelos devolvem W apesar do registo estar nomeado como kW.
             * Outros podem devolver kW.
             *
             * Não usar abs() no valor final, apenas na deteção de escala.
             */
            float p_w = p_kw;

            const float apparent_w = fabsf(v * i);

            if (apparent_w > 1.0f && fabsf(p_w) < (apparent_w * 0.2f))
            {
                // Exemplo: -0.723 kW -> -723 W
                p_w *= 1000.0f;
            }

            watt[0] = (int32_t)lrintf(p_w);
            watt[1] = 0;
            watt[2] = 0;
            break;
        }
        case CID_TOTAL_ACTIVE_ENERGY_KWH:
            e_kwh = val;
            break;
        default:
            break;
        }

        vTaskDelay(POLL_INTERVAL);
    }

    if (!got_any_value)
    {
        ESP_LOGW(TAG, "%s no valid DDS661 values read in this cycle", inst->source);
        return;
    }

    meter_event_data_t evt = {
        .source = inst->source,
        .frequency = hz,
        .power_factor = pf,
        .total_energy = e_kwh,
        .watt_total = watt[0] + watt[1] + watt[2],
        .timestamp_us = esp_timer_get_time(),
    };
    memcpy(evt.vrms, voltage, sizeof(evt.vrms));
    memcpy(evt.irms, current, sizeof(evt.irms));
    memcpy(evt.watt, watt, sizeof(evt.watt));

    const int32_t p_total_w = watt[0] + watt[1] + watt[2];

    ESP_LOGI(TAG,
             "%s DDS661 event: V=%.1fV I=%.3fA P=%ldW E=%.3fkWh Hz=%.2f PF=%.3f",
             inst->source,
             voltage[0],
             current[0],
             (long)p_total_w,
             e_kwh,
             hz,
             pf);

    esp_err_t post_err = esp_event_post(METER_EVENT, METER_EVENT_DATA_READY, &evt, sizeof(evt), portMAX_DELAY);
    if (post_err != ESP_OK)
        ESP_LOGW(TAG, "%s failed to post meter event: %s", inst->source, esp_err_to_name(post_err));
}

// ======= Tarefa de aquisição =======
static void serial_mdb_task(void *param)
{
    (void)param;

    while (task_should_run)
    {
        if (!is_initialized || !dds661_lock)
        {
            vTaskDelay(UPDATE_INTERVAL);
            continue;
        }

        bool had_instance = false;

        for (uint8_t slot = 0; slot < DDS661_MAX_INSTANCES && task_should_run; ++slot)
        {
            if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) != pdTRUE)
            {
                ESP_LOGW(TAG, "DDS661 task timeout waiting lock");
                continue;
            }

            dds661_instance_t inst = dds661_instances[slot];
            if (inst.registered)
            {
                had_instance = true;
                dds661_read_instance_locked(&inst);
            }

            xSemaphoreGive(dds661_lock);
        }

        vTaskDelay(had_instance ? UPDATE_INTERVAL : pdMS_TO_TICKS(500));
    }

    ESP_LOGI(TAG, "DDS661 task stopped");
    meter_task = NULL;
    vTaskDelete(NULL);
}

// ======= API pública =======
// Compatibilidade: chamada antiga inicializa DDS661 como GRID/ID 1.
esp_err_t meter_dds661_init(void)
{
    return meter_dds661_grid_init();
}

esp_err_t meter_dds661_grid_init(void)
{
    return dds661_register_instance(DDS661_SLOT_GRID);
}

esp_err_t meter_dds661_evse_init(void)
{
    return dds661_register_instance(DDS661_SLOT_EVSE);
}

esp_err_t meter_dds661_start(void)
{
    if (!is_initialized)
    {
        ESP_LOGE(TAG, "meter_dds661 not initialized");
        return ESP_ERR_INVALID_STATE;
    }

    if (!dds661_lock)
        return ESP_ERR_INVALID_STATE;

    if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) != pdTRUE)
        return ESP_ERR_TIMEOUT;

    const bool has_instance = dds661_has_registered_instance_locked();
    esp_err_t desc_err = ESP_OK;
    if (has_instance)
        desc_err = dds661_apply_descriptors_locked();
    xSemaphoreGive(dds661_lock);

    if (!has_instance)
    {
        ESP_LOGW(TAG, "meter_dds661 start ignored: no instances registered");
        return ESP_ERR_INVALID_STATE;
    }

    if (desc_err != ESP_OK)
        return desc_err;

    if (meter_task == NULL)
    {
        task_should_run = true;
        BaseType_t ok = xTaskCreate(serial_mdb_task, "meter_dds661_task", 4096, NULL, 3, &meter_task);
        if (ok != pdPASS)
        {
            task_should_run = false;
            meter_task = NULL;
            return ESP_ERR_NO_MEM;
        }
        ESP_LOGI(TAG, "meter_dds661 shared task started");
    }

    return ESP_OK;
}

esp_err_t meter_dds661_grid_start(void)
{
    return meter_dds661_start();
}

esp_err_t meter_dds661_evse_start(void)
{
    return meter_dds661_start();
}

void meter_dds661_stop(void)
{
    meter_dds661_grid_stop();
}

void meter_dds661_grid_stop(void)
{
    dds661_unregister_instance(DDS661_SLOT_GRID);
}

void meter_dds661_evse_stop(void)
{
    dds661_unregister_instance(DDS661_SLOT_EVSE);
}