/*
  CAN总线上的设
  将所有CAN总线上挂载的设抽象成一设进行配和控制
*/

/* Includes ----------------------------------------------------------------- */
#include "can.h"

#include <stdbool.h>
#include <string.h>

#include "bsp\can.h"
#include "bsp\buzzer.h"
#include "component\user_math.h"

/* Private define ----------------------------------------------------------- */

/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
/* Private variables -------------------------------------------------------- */
static CAN_RawRx_t raw_rx1;
static CAN_RawRx_t raw_rx2;
static CAN_RawTx_t raw_tx;

static osThreadId_t thread_alert;
static CAN_t *gcan;
static bool inited = false;

// /* Private function  -------------------------------------------------------- */
static void CAN_CAN1RxFifoMsgPendingCallback(void) {
    BSP_Buzzer_Start();
  HAL_CAN_GetRxMessage(BSP_CAN_GetHandle(BSP_CAN_1), CAN_RX_FIFO0,
                       &raw_rx1.rx_header, raw_rx1.rx_data);
  osMessageQueuePut(gcan->msgq_raw, &raw_rx1, 0, 0);
}

/**
 * @brief  CAN2接收FIFO1消息挂起回调函数
 * @param  None
 */
static void CAN_CAN2RxFifoMsgPendingCallback(void) {
    BSP_Buzzer_Start();
  HAL_CAN_GetRxMessage(BSP_CAN_GetHandle(BSP_CAN_2), CAN_RX_FIFO1,
                       &raw_rx2.rx_header, raw_rx2.rx_data);
  osMessageQueuePut(gcan->msgq_raw, &raw_rx2, 0, 0);
}

// /* Exported functions ------------------------------------------------------- */
int8_t CAN_Init(CAN_t *can, const CAN_Params_t *param) {
  if (can == NULL) return DEVICE_ERR_NULL;
  if (inited) return DEVICE_ERR_INITED;
  if ((thread_alert = osThreadGetId()) == NULL) return DEVICE_ERR_NULL;

  can->msgq_raw = osMessageQueueNew(32, sizeof(CAN_RawRx_t), NULL);

  can->param = param;

  CAN_FilterTypeDef can_filter = {0};

  can_filter.FilterBank = 0;
  can_filter.FilterIdHigh = 0;
  can_filter.FilterIdLow = 0;
  can_filter.FilterMode = CAN_FILTERMODE_IDMASK;
  can_filter.FilterScale = CAN_FILTERSCALE_32BIT;
  can_filter.FilterMaskIdHigh = 0;
  can_filter.FilterMaskIdLow = 0;
  can_filter.FilterActivation = ENABLE;
  can_filter.SlaveStartFilterBank = 14;
  can_filter.FilterFIFOAssignment = CAN_RX_FIFO0;

  HAL_CAN_ConfigFilter(BSP_CAN_GetHandle(BSP_CAN_1), &can_filter);
  HAL_CAN_Start(BSP_CAN_GetHandle(BSP_CAN_1));
  BSP_CAN_RegisterCallback(BSP_CAN_1, HAL_CAN_RX_FIFO0_MSG_PENDING_CB,
                           CAN_CAN1RxFifoMsgPendingCallback);
  HAL_CAN_ActivateNotification(BSP_CAN_GetHandle(BSP_CAN_1),
                               CAN_IT_RX_FIFO0_MSG_PENDING);

  can_filter.FilterBank = 14;
  can_filter.FilterFIFOAssignment = CAN_RX_FIFO1;

  HAL_CAN_ConfigFilter(BSP_CAN_GetHandle(BSP_CAN_2), &can_filter);
  HAL_CAN_Start(BSP_CAN_GetHandle(BSP_CAN_2));
  BSP_CAN_RegisterCallback(BSP_CAN_2, HAL_CAN_RX_FIFO1_MSG_PENDING_CB,
                           CAN_CAN2RxFifoMsgPendingCallback);
  HAL_CAN_ActivateNotification(BSP_CAN_GetHandle(BSP_CAN_2),
                               CAN_IT_RX_FIFO1_MSG_PENDING);

  gcan = can;
  inited = true;
  return DEVICE_OK;
}

// bool CAN_CheckFlag(CAN_t *can, uint32_t flag) {
//   if (can == NULL) return false;
//   return (can->recive_flag & flag) == flag;
// }

// int8_t CAN_ClearFlag(CAN_t *can, uint32_t flag) {
//   if (can == NULL) return DEVICE_ERR_NULL;
//   can->recive_flag &= ~flag;
//   return DEVICE_OK;
// }

// #include "device\can.h"
// #include "bsp\buzzer.h"
// #include <stdio.h>

// 定义测试用的 CAN 消息
#define TEST_CAN_ID 0x123
#define TEST_CAN_DATA {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}

void CAN_Test(void) {
    CAN_t can;
    CAN_Params_t can_param = {
        .sick = BSP_CAN_1,
    };

    // 初始化 CAN
    if (CAN_Init(&can, &can_param) != DEVICE_OK) {
        printf("CAN 初始化失败！\n");
        return;
    }

    // 配置发送消息
    CAN_RawTx_t tx_msg;
    tx_msg.tx_header.StdId = TEST_CAN_ID;
    tx_msg.tx_header.RTR = CAN_RTR_DATA;
    tx_msg.tx_header.IDE = CAN_ID_STD;
    tx_msg.tx_header.DLC = 8;
    uint8_t test_data[8] = TEST_CAN_DATA;
    memcpy(tx_msg.tx_data, test_data, sizeof(test_data));

    // 发送消息
    if (HAL_CAN_AddTxMessage(BSP_CAN_GetHandle(BSP_CAN_1), &tx_msg.tx_header, tx_msg.tx_data, &can.mailbox.sick) != HAL_OK) {
        return;
    }

    // 等待接收消息
    CAN_RawRx_t rx_msg;
    while (osMessageQueueGet(can.msgq_raw, &rx_msg, NULL, osWaitForever) == osOK) {
        for (int i = 0; i < rx_msg.rx_header.DLC; i++) {
        }

        // 验证接收数据是否正确
        if (rx_msg.rx_header.StdId == TEST_CAN_ID && memcmp(rx_msg.rx_data, test_data, sizeof(test_data)) == 0) {
        } else {
        }
        break;
    }
}