#include "stdint.h"
#include "string.h"

#include "mod_candataprocess.h"
#include "mod_spi.h"

#include "sys_log.h"
#include "sys_common.h"
#include "lib_iso15765.h"

#include "hal_can.h"
#include "hal_timer.h"

#define CAN_PAYLOAD_MAX_LEN     8
#define SEND_CAN_BUF_MAX_LEN    64
#define UINT32_DEFAULT_VAL      0xFFFFFFFF

static uint8_t g_s_can_index;
static uint8_t g_s_send_can_buf[SEND_CAN_BUF_MAX_LEN];

/******************ISO15765**********************************/

typedef struct {
    uint32_t     frame_id;
    iso15765_t*  process_handler;
}HANDLER_T;


static uint32_t getms()
{
    return HAL_SysGetTickMs();;
}

static void on_error(n_rslt err_type)
{
    DLOG_E("15765 parse err:%04x", err_type);
}

static uint8_t send_frame_via_can(cbus_id_type id_type, uint32_t id, cbus_fr_format fr_fmt, uint8_t dlc, uint8_t *dt)
{
    //暂时没看到啥用处.
    return 0;
}

static void parse_finish_callback(n_indn_t *info)
{
    if(0 == info->rslt)
    {
        DLOG_I("parse success.rslt:0x%x,frame_id:0x%x,msg_sz:0x%x,data:", 
                    info->rslt,
                    (info->n_ai.n_sa<<8)|(info->n_ai.n_ta),
                    info->msg_sz);

        for (int i = 0; i < info->msg_sz; i++)
        {
            printf("%02X", info->msg[i]);
        }
        printf("\r\n");
    }
    else
    {
        DLOG_I("parse fail.rslt:0x%x,frame_id:0x%x", 
                    info->rslt,
                    (info->n_ai.n_sa<<8)|(info->n_ai.n_ta));
    }
}

static iso15765_t handler0 =
{
    .addr_md = N_ADM_BMW,
    .fr_id_type = CBUS_ID_T_STANDARD,
    .clbs.send_frame = send_frame_via_can,
    .clbs.on_error = on_error,
    .clbs.get_ms = getms,
    .clbs.indn = parse_finish_callback,
    .config.stmin = 0x3,
    .config.bs = 0x0f,
    .config.n_bs = 100,
    .config.n_cr = 3
};

static iso15765_t handler1 =
{
    .addr_md = N_ADM_BMW,
    .fr_id_type = CBUS_ID_T_STANDARD,
    .clbs.send_frame = send_frame_via_can,
    .clbs.on_error = on_error,
    .clbs.get_ms = getms,
    .clbs.indn = parse_finish_callback,
    .config.stmin = 0x3,
    .config.bs = 0x0f,
    .config.n_bs = 100,
    .config.n_cr = 3
};

static iso15765_t handler2 =
{
    .addr_md = N_ADM_BMW,
    .fr_id_type = CBUS_ID_T_STANDARD,
    .clbs.send_frame = send_frame_via_can,
    .clbs.on_error = on_error,
    .clbs.get_ms = getms,
    .clbs.indn = parse_finish_callback,
    .config.stmin = 0x3,
    .config.bs = 0x0f,
    .config.n_bs = 100,
    .config.n_cr = 3
};

static iso15765_t handler3 =
{
    .addr_md = N_ADM_BMW,
    .fr_id_type = CBUS_ID_T_STANDARD,
    .clbs.send_frame = send_frame_via_can,
    .clbs.on_error = on_error,
    .clbs.get_ms = getms,
    .clbs.indn = parse_finish_callback,
    .config.stmin = 0x3,
    .config.bs = 0x0f,
    .config.n_bs = 100,
    .config.n_cr = 3
};

HANDLER_T data_process_handler_list[] = {
    {
        .frame_id = UINT32_DEFAULT_VAL,
        .process_handler = &handler0,
    },
    {
        .frame_id = UINT32_DEFAULT_VAL,
        .process_handler = &handler1,
    },
    {
        .frame_id = UINT32_DEFAULT_VAL,
        .process_handler = &handler2,
    },
    {
        .frame_id = UINT32_DEFAULT_VAL,
        .process_handler = &handler3,
    },
};

int MOD_CanIso15765ParseInit(void)
{
    //初始化15765解析句柄.
    int init_ret = N_OK;
    for (int i=0; i<sizeof(data_process_handler_list)/sizeof(HANDLER_T); i++)
    {
        init_ret = iso15765_init(data_process_handler_list[i].process_handler);
        if(N_OK != init_ret)
        {
            return -1;
        }
    }
    return N_OK;
}


void MOD_CanIso15765Parse(void)
{
    //处理队列中的数据.
    for (int i=0; i<sizeof(data_process_handler_list)/sizeof(HANDLER_T); i++)
    {
        iso15765_process(data_process_handler_list[i].process_handler);
    }
}

void MOD_CanPutDataToIso15765Parse(uint8_t* can_data, uint8_t data_len)
{
    //将can数据放入15765处理队列接口
    uint32_t can_id;
    canbus_frame_t can_frame;
    memcpy(&can_id, &can_data[1], 4);

    can_frame.id = can_id; //帧id
    can_frame.fr_format = CBUS_FR_FRM_STD; //帧格式
    can_frame.id_type = CBUS_ID_T_STANDARD; //帧类型
    can_frame.dlc = can_data[5]; //帧长度

    memset(&can_frame.dt, 0, 8);
    memcpy(&can_frame.dt, &can_data[6], can_frame.dlc); //帧数据

    DLOG_I("put can to 15765 parse,can_id:0x%x,payload_len:%d,payload:%s",
                can_id,
                can_frame.dlc ,
                SYS_Hex2str(can_frame.dt, can_frame.dlc));

}
/******************ISO15765**********************************/


/**********************************************
*  @brief:   can发送接口
*  @param:   data:指向要发送的数据组包buf
*  @param:   len:数据长度
*  @return:  发送结果
*  @warning: xxxxxxx
*  1.
**********************************************/
int MOD_CanTransferData(uint8_t* data, uint8_t len)
{
    uint8_t can_id_type = 0;
    uint32_t can_id = 0;
    uint8_t payload_len = 0;
    uint8_t payload[8] = {0};

    memset(payload, 0, 8);
    g_s_can_index = data[0];
    can_id_type = data[1];
    memcpy(&can_id, &data[2], 4);
    small_big_transfer32(&can_id);
    payload_len = data[6];
    memcpy(payload, &data[7], payload_len);

    DLOG_I("tx_can_data,index:%d,type:%d,can_id:0x%x,payload_len:%d,payload:%s", g_s_can_index, can_id_type, can_id, payload_len, 
                                SYS_Hex2str(payload, payload_len));

    return HAL_CanTxData(can_id_type, can_id, payload, payload_len);
}

/**********************************************
*  @brief:   can接收接口,处理接收到的can数据
*  @param:   data:接收到的数据缓存空间
*  @param:   data_len:收到的数据长度
*  @return:  xxxxxxx
*  @warning: xxxxxxx
*  1.
**********************************************/
void MOD_CanRxDataProcess(uint8_t* data, uint8_t data_len)
{
    uint8_t can_id_type;
    uint32_t can_id;
    uint8_t can_payload_len;
    uint8_t can_payload_buf[8];
    uint8_t tmp_len = 0;

    can_id_type = data[0];

    memset(can_payload_buf, 0, 8);
    memcpy(&can_id, &data[1], 4);

    can_payload_len = data[5];
    memcpy(can_payload_buf, &data[6], can_payload_len);

    DLOG_I("rx_can_data,type:%d,can_id:0x%x,payload_len:%d,payload:%s",
                can_id_type,
                can_id,
                can_payload_len,
                SYS_Hex2str(can_payload_buf, can_payload_len));


    tmp_len = 0;
    g_s_send_can_buf[tmp_len] = TRANSFER_GET_CAN_RSP_CMD; 
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = g_s_can_index;
		g_s_can_index ++;
		if (0x7D == g_s_can_index)
		{
			g_s_can_index = 0;
		}
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = can_id_type; 
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = (can_id>>24)&0xFF;
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = (can_id>>16)&0xFF;
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = (can_id>>8)&0xFF;
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = can_id&0xFF;
    tmp_len += 1;
    g_s_send_can_buf[tmp_len] = can_payload_len; 
    tmp_len += 1;
    memcpy(&g_s_send_can_buf[tmp_len], &can_payload_buf, can_payload_len);
    tmp_len += can_payload_len;

    MOD_SpiDataSend(BLE_CMD_TRANSFER, g_s_send_can_buf, tmp_len);
}