#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)
{
    //iso15765中can发送接口
    uint8_t can_id_type = 0;
    uint32_t can_id = 0;
    uint8_t payload_len = 0;
    uint8_t payload[8] = {0};
    uint8_t ret = 0;

    can_id_type = id_type;
    can_id = id;
    payload_len = dlc>8?8:dlc;
    memset(payload, 0, 8);
    memcpy(payload, dt, payload_len);
    DLOG_I("send can data:%d,data:%s", payload_len, SYS_Hex2str(payload, payload_len));

    ret = HAL_CanTxData(can_id_type, can_id, payload, payload_len);
    return 0;
}

static void parse_finish_callback(n_indn_t *info)
{
    DLOG_I("parse finish");
    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 n_req_t g_s_can_frame =
{
    .n_ai.n_pr = 0x06,
    .n_ai.n_sa = 0x12,
    .n_ai.n_ta = 0xdf,
    .n_ai.n_ae = 0x00,
    .n_ai.n_tt = N_TA_T_PHY,
    .fr_fmt = CBUS_FR_FRM_STD,
    .msg = {0x22, 0xf1, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09},
    .msg_sz = 0x0d,
};

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)
{
    //初始化iso15765解析句柄.
    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));

    // //开始往队列中放入数据
    // uint8_t find_frame_id_flag = 0;
    // for(int i=0; i<sizeof(data_process_handler_list)/sizeof(HANDLER_T); i++)
    // {
    //     //先找下这个id有没有在列表里面,如果在的话就放进去,如果不在的话就重新找新的放入
    //     if(data_process_handler_list[i].frame_id == can_frame.id)
    //     {
    //         LOG_D("find frame_id");
    //         find_frame_id_flag = 1;
    //         iso15765_enqueue(data_process_handler_list[i].process_handler, &can_frame);
    //     }
    // }
    // if(0 == find_frame_id_flag)
    // {
    //     //这个frame_id不在之前发过的历史列表里面,那找个新的放进去
    //     for(int j=0; j<sizeof(data_process_handler_list)/sizeof(HANDLER_T); j++)
    //     {
    //         if(UINT32_DEFAULT_VAL == data_process_handler_list[j].frame_id)
    //         {
    //             LOG_D("not find frame_id, now set %d", j);
    //             data_process_handler_list[j].frame_id = can_frame.id;
    //             iso15765_enqueue(data_process_handler_list[j].process_handler, &can_frame);
    //             break;
    //         }
    //     }
    // }

}
/******************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);

    // iso15765库
    g_s_can_frame.msg_sz = len>I15765_MSG_SIZE?I15765_MSG_SIZE:len;
    memset(&g_s_can_frame.msg, 0, I15765_MSG_SIZE);
    memcpy(&g_s_can_frame.msg, data, g_s_can_frame.msg_sz);
    
    DLOG_I("send can data to iso15765,size:%d,data:%S", g_s_can_frame.msg_sz, SYS_Hex2str(g_s_can_frame.msg, g_s_can_frame.msg_sz));

    iso15765_send(&handler1, &g_s_can_frame); //使用这个接口将数据发送到协议库
}

/**********************************************
*  @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);
}