/* Includes ------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef CFG_DEV_TYPE_LAND_PD
/* 标准C库头文件. */
#include <arpa/inet.h>

/* 用户代码头文件. */
#include "hwgpio.h"
#include "serial.h"
#include "pd_modbus.h"
#include "pd_dau.h"

/* Private variables ---------------------------------------------------------*/
modbus_t modbus;

void _modbus_show(void)
{
    card_t *pcard = NULL;
    printh("UNIT STATUS CURRENT ALARM\r\n");
    for (int slot = 0; slot < PD_SLOTS_MAX; slot++)
    {
        pcard = &modbus.card[slot];
        printh("%-04d %3d %8d %6d\r\n", pcard->unit_id, pcard->status, pcard->current, pcard->alarm);
    }
}

/* modbus 状态显示 */
CMD(modbus_show,
    modbus_show_cmd,
    "show modbus",
    "Show\n"
    "Modbus\n")
{
    _modbus_show();

    return CMD_SUCCESS;
}


int32_t _modbus_tcp_transaction(uint8_t unit_id, uint16_t start_addr, uint16_t data_num) 
{
    int txlen = 0;
    int rxlen = 0;
    modbus_tcp_t *frame = (modbus_tcp_t *)modbus.txbuf;
    uint8_t *pdata = NULL;
    uint8_t datalen = 0;
    static uint16_t transaction_id = 0;
    frame->transaction_id = htons(++transaction_id);
    frame->protocol_id = htons(0); // Modbus
    // 长度：unit_id（1字节） + 后续PDU（5字节：功能码1 + 起始地址2 + 数量2）
    frame->length = htons(6);
    frame->unit_id = unit_id;
    // PDU
    frame->function_code = 0x03; 
    pdata = modbus.txbuf + sizeof(modbus_tcp_t);
    pdata[datalen++] = (start_addr >> 8) & 0xFF;  // 起始地址高字节
    pdata[datalen++] = start_addr & 0xFF;         // 起始地址低字节
    pdata[datalen++] = (data_num >> 8) & 0xFF;    // 数据数量高字节
    pdata[datalen++] = data_num & 0xFF;           // 数据数量低字节

    txlen = datalen + sizeof(modbus_tcp_t);

    // 发送请求帧
    GPIO_485BUS(WRITE);
    if (serial_write(modbus.fd, modbus.txbuf, txlen) < 0)
    {
        DBG(DBG_M_PD_MODBUS_ERR, "Modbus write error\r\n");
        return E_ERROR;
    }
    
    DBG(DBG_M_PD_MODBUS, "Modbus write len = %d\r\n", txlen);
    DBG_ARRAY(DBG_M_PD_MODBUS, (char *)modbus.txbuf, txlen);
    
    // 等待传输完成
    usleep(13000);  // 13000

    GPIO_485BUS(READ);
    rxlen = serial_read(modbus.fd, modbus.rxbuf, sizeof(modbus.rxbuf));
    if (rxlen > 0)
    {
        uint16_t length;
        
        DBG(DBG_M_PD_MODBUS, "Modbus read len = %d\r\n", rxlen);
        DBG_ARRAY(DBG_M_PD_MODBUS, (char *)modbus.rxbuf, rxlen);

        length = modbus.rxbuf[POS_DATA_LEN] << 8;
        length += modbus.rxbuf[POS_DATA_LEN + 1];
        if (rxlen == length + 6)
        {
            uint16_t trans_id = (modbus.rxbuf[0] << 8) + modbus.rxbuf[1];
            if (trans_id == transaction_id && modbus.rxbuf[POS_UINT_ID] == unit_id)
            {
                return E_NONE;
            }
        }
    }
        
    return E_ERROR;
}

int32_t _modbus_rtu_transaction(void) 
{
    int sndlen = 0;
    int rcvlen = 0;
    uint8_t *ptxbuf = modbus.txbuf;
    ptxbuf[sndlen++] = 0x05;
    ptxbuf[sndlen++] = 0x03;
    ptxbuf[sndlen++] = 0x00;
    ptxbuf[sndlen++] = 0x34;
    ptxbuf[sndlen++] = 0x00;
    ptxbuf[sndlen++] = 0x02;
    ptxbuf[sndlen++] = 0x84;
    ptxbuf[sndlen++] = 0x41;

    // 发送请求帧
    GPIO_485BUS(WRITE);
    if (serial_write(modbus.fd, ptxbuf, sndlen) < 0)
    {
        DBG(DBG_M_PD_MODBUS_ERR, "Modbus write error\r\n");
        return E_ERROR;
    }
    
    usleep(10000);

    GPIO_485BUS(READ);
    rcvlen = serial_read(modbus.fd, modbus.rxbuf, sizeof(modbus.rxbuf));
    if (rcvlen > 0)
    {
        DBG(DBG_M_PD_MODBUS_ERR, "Modbus read len = %d\r\n", rcvlen);
        buf_print((char *)modbus.rxbuf, rcvlen);
    }
   
    return E_NONE;
}

int32_t _modbus_get_device_type(uint8_t unit, uint8_t *typem, uint8_t *types)
{
    if (!_modbus_tcp_transaction(unit, MODBUS_DEVICE_TYPE_ADDR, MODBUS_DEVICE_TYPE_LEN))
    {
        *typem = modbus.rxbuf[9];
        *types = modbus.rxbuf[10];
        return E_NONE;
    }
    return E_ERROR;
}

int32_t _modbus_get_current(uint8_t unit, uint16_t addr, uint16_t len, uint32_t *current)
{
    uint32_t cur = 0;
    if (!_modbus_tcp_transaction(unit, addr, len))
    {
        //cur = modbus.rxbuf[9] << 24;
        //cur += modbus.rxbuf[10] << 16;
        //cur += modbus.rxbuf[11] << 8;
        //cur += modbus.rxbuf[12];
        memcpy(&cur, &modbus.rxbuf[9], sizeof(uint32_t));
    }
    *current = cur;
    return E_NONE;
}

int32_t _modbus_get_alarm(uint8_t unit, uint16_t addr, uint16_t len, uint16_t *alarm)
{
    uint16_t val = 0;
    if (!_modbus_tcp_transaction(unit, addr, len))
    {
        memcpy(&val, &modbus.rxbuf[9], sizeof(uint16_t));
    }
    *alarm = val;
    return E_NONE;
}


void _modbus_read_slot_stat(card_t *pcard)
{
    card_t *ptmp = pcard;
    for (int slot = 0; slot < PD_SLOTS_MAX; slot++)
    {
        ptmp->status = 0;
        ptmp++;
    }

    ptmp = pcard;
    gpio_val_get(gpio_dau1_idx, &ptmp->status);
    
    ptmp++;
    gpio_val_get(gpio_dau2_idx, &ptmp->status);
    
    ptmp++;
    gpio_val_get(gpio_dau3_idx, &ptmp->status);
    
    ptmp++;
    gpio_val_get(gpio_dau4_idx, &ptmp->status);
    
    ptmp++;
    gpio_val_get(gpio_dau5_idx, &ptmp->status);
    
    ptmp++;
    gpio_val_get(gpio_dau6_idx, &ptmp->status);
}

void crash() {
    int *ptr = NULL;
    *ptr = 42;  // 故意触发段错误
}

void *_modbus_send_handle()
{
    card_t *pcard = NULL;
    dau_t *dau = NULL;
    while (1)
    {
        _modbus_read_slot_stat(modbus.card);
        
        for (int slot = 0; slot < PD_SLOTS_MAX; slot++)
        {
            
            pcard = &modbus.card[slot];
            dau = &daus[slot];
            DBG(DBG_M_PD_MODBUS, "slot%d unit_id:%d status:%d\n", slot, pcard->unit_id, pcard->status);
            if (pcard->status)
            {
                sleep(1);
                if (_modbus_get_device_type(pcard->unit_id, &dau->info.type_m, &dau->info.type_s) != E_NONE)
                    continue;
                DBG(DBG_M_PD_MODBUS, "slot%d typem:%d types:%d\n", slot, dau->info.type_m, dau->info.type_s);

                if (DEVICE_IR_TYPE == dau->info.type_s && DEVICE_M_TYPE == dau->info.type_m)
                {
                    dau->state.beat_cnt = 0;
                    dau->state.is_connect = TRUE;
                    sleep(1);
                    _modbus_get_current(pcard->unit_id, 
                        MODBUS_IR_CURRENT_ADDR, MODBUS_IR_CURRENT_LEN, &pcard->current);

                    _modbus_get_alarm(pcard->unit_id, 
                        MODBUS_IR_ALARM_ADDR, MODBUS_IR_ALARM_LEN, &pcard->alarm);
                }
                else if (DEVICE_DC_TYPE == dau->info.type_s && DEVICE_M_TYPE == dau->info.type_m)
                {
                    dau->state.beat_cnt = 0;
                    dau->state.is_connect = TRUE;
                    sleep(1);
                    _modbus_get_current(pcard->unit_id, 
                        MODBUS_DC_CURRENT_ADDR, MODBUS_DC_CURRENT_LEN, &pcard->current);
                }
            }
            else
            {
                if (DEVICE_M_TYPE == dau->info.type_m && 
                    (DEVICE_IR_TYPE == dau->info.type_s || DEVICE_DC_TYPE == dau->info.type_s))
                {
                    dau->state.beat_cnt = 0;
                    dau->state.is_connect = FALSE;
                    dau->state.is_insert = FALSE;
                }
            }
        }
        sleep(5);
    }

    if (modbus.fd > 0)
    {
        close(modbus.fd);
        modbus.fd = -1;
    }
}

int32_t modbus_handle_init(void)
{
    memset(&modbus, 0, sizeof(modbus));
    for (int slot = 0; slot < PD_SLOTS_MAX; slot++)
    {
        modbus.card[slot].unit_id  = slot + 1;
    }
    modbus.fd = -1;

    cmd_install_element(COMMON_NODE, &modbus_show_cmd);
    return E_NONE;
}

int32_t modbus_handle_init_after(void)
{
    int baud_rate = 9600;
    thread_param_t param = {0};

    // 初始化串口
    int fd = serial_open("/dev/ttyS0", baud_rate);
    if (fd < 0) 
    {
        DBG(DBG_M_PD_MODBUS_ERR, "Failed to initialize serial port\n");
        return E_ERROR;
    }
    modbus.fd = fd;

    param.arg = NULL;
    param.priority = 80;
    param.log_module = LOG_MODBUS;
    snprintf(param.thread_name, THREAD_NAME_LEN, "MODBUS_SEND");
    create_thread(_modbus_send_handle, &param);
    return E_NONE;
}

#endif