#include "modbus_processer.hpp"

#include <stdbool.h>
#include <stdint.h>

/***********************485rx**************************/
// 接收到了多少数据
// volatile uint16_t s_modbus_uart_rx_off = 0;
// 当前是否正在处理接收到的数据
// volatile bool s_modbus_uart_rx_buf_is_processing = false;
/***********************485tx**************************/
static modbus_processer_t* g_processer;

#define GET_UINT16(uint8) (uint16_t)(((uint16_t)((uint8)[0]) << 8) + (uint8)[1])
void modbus_processer_process_data(uint8_t* rx, uint16_t len);
void modbus_processer_init(modbus_processer_t* processer) { g_processer = processer; }

void ModbusProcessRxData(uint8_t* rxraw, uint8_t length, ModbusMasterData_t* rxparsed) {
  rxparsed->functionCode = (ModbusFunctionCode)rxraw[1];
  if (rxraw[1] == ModbusOrder01 || rxraw[1] == ModbusOrder02 || rxraw[1] == ModbusOrder03 || rxraw[1] == ModbusOrder04) {
    /**
     * @brief
     *  由于是共用体，所以均给001赋值即可
     */
    rxparsed->d.O01.startbit = rxraw[2] * 256 + rxraw[3];
    rxparsed->d.O01.numbit   = rxraw[4] * 256 + rxraw[5];
  } else if (rxraw[1] == ModbusOrder0F || rxraw[1] == ModbusOrder10) {
    /**
     * @brief
     *  由于是共用体，所以均给0F赋值即可
     */
    rxparsed->d.O0F.startbit = rxraw[2] * 256 + rxraw[3];
    rxparsed->d.O0F.numbit   = rxraw[4] * 256 + rxraw[5];
    rxparsed->d.O0F.bytenum  = rxraw[6];
    rxparsed->d.O0F.bit      = &rxraw[7];
  } else {
    /**
     * @brief Not support now
     */
  }
}

#define UINT16ToUINT8(u16d, u8addbegin) \
  {                                     \
    (u8addbegin)[0] = u16d >> 8;        \
    (u8addbegin)[1] = (uint8_t)u16d;    \
  }

void ModbusCreateTx_setReg(uint8_t* txbuffer, uint8_t length, uint16_t off, uint16_t regdata) {
  if (3 + off * 2 > length - 2) {
    return;
  }
  txbuffer[3 + off * 2]     = regdata >> 8;
  txbuffer[3 + off * 2 + 1] = (uint8_t)regdata;
}

void ModbusCreateTxData(uint8_t* txbuffer, uint8_t length, uint16_t* sendlength, ModbusSlaveData_t* txdata) {
  /**
   * @brief TODO:添加txbuffer长度计算
   */
  if (length < 4) return;
  txbuffer[0]                   = txdata->deviceId;
  txbuffer[1]                   = (uint8_t)txdata->functionCode;
  *sendlength                   = 0;
  volatile uint16_t _sendlength = 0;
  volatile uint16_t i           = 0;

  if (txdata->functionCode == ModbusOrder01 || txdata->functionCode == ModbusOrder02 || txdata->functionCode == ModbusOrder03 || txdata->functionCode == ModbusOrder04) {
    /**
     * @brief 01,02 指令操作bit
     */

    // 读取多个输出状态
    //  sendLen =
    //    add(1byte)+functionCode(1byte)+addNum(1)+crc(2) = 5+numbyte
    volatile uint16_t numbyte = txdata->d.O01.bytenum;
    _sendlength               = 5 + numbyte;
    if (length < _sendlength) return;
    txbuffer[2] = txdata->d.O01.bytenum;
    if (txdata->d.O01.byte_table != nullptr) {
      for (i = 0; i < numbyte; i++) {
        txbuffer[3 + i] = txdata->d.O01.byte_table[i];
      }
    }
  } else if (txdata->functionCode == ModbusOrder0F || txdata->functionCode == ModbusOrder10) {
    // 写入多个输出
    //  sendLen = add(1byte)+functionCode(1byte)+startAdd(2)+addNum(2)+crc(2) = 8
    _sendlength = 8;
    if (length < _sendlength) return;

    UINT16ToUINT8(txdata->d.O0F.startbit, &txbuffer[2]);
    UINT16ToUINT8(txdata->d.O0F.bitnum, &txbuffer[4]);
  } else {
    /**
     * @brief Not support now
     */
  }
  // calculate  crc
  if (_sendlength > 2) {
    modbus_pack_crc_to_packet(txbuffer, _sendlength);
  }
  *sendlength = _sendlength;
}

void ModbusCreateExceptionData(uint8_t* txbuffer, uint8_t length, uint16_t* sendlength, uint8_t deviceid, uint8_t functioncode, ModbusStatus status) {
  /**
   * @brief TODO:添加txbuffer长度计算
   */
  volatile uint16_t _sendlength = 0;
  volatile uint16_t i           = 0;

  if (length < 4) return;
  txbuffer[0] = deviceid;
  txbuffer[1] = functioncode | 0x80;
  txbuffer[2] = (uint8_t)status;
  *sendlength = 0;
  // sendLen = add(1byte)+functionCode(1byte)+exception(1)+crc(2) = 4
  _sendlength = 4;
  modbus_pack_crc_to_packet(txbuffer, _sendlength);
  *sendlength = _sendlength;
  return;
}
#if 0
void modbus_processer_try_process_data(void) {
  /**
   * @brief
   * 根据modbus协议，当超过3.5个字符时间后依然没有收到数据
   */
  // bool receive_one_packet = false;  // 因为keil报警告才注释
  if (s_modbus_uart_rx_off != 0) {
    uint16_t modbus_uart_rx_off_before = s_modbus_uart_rx_off;

    g_processer->port_delay_us(g_processer->modbus_baundrate_one_packet_delay_us);

    g_processer->port_enter_critical();
    if (s_modbus_uart_rx_off == modbus_uart_rx_off_before) {
      s_modbus_uart_rx_buf_is_processing = true;
    }
    g_processer->port_exit_critical();

    if (s_modbus_uart_rx_buf_is_processing) {
      modbus_processer_process_data(g_processer->modbus_processer_rx_buf, s_modbus_uart_rx_off);
      g_processer->port_enter_critical();
      s_modbus_uart_rx_off               = 0;
      s_modbus_uart_rx_buf_is_processing = false;
      g_processer->port_exit_critical();
    }
  }
}
#endif

/***********************************************************************************************************************
 * ==================================================modbus消息处理=================================================== *
 ***********************************************************************************************************************/
 void modbus_processer_process_data(uint8_t* rx, uint16_t rxlen) {
  /**
   * @brief modbus接收完成以后在这里进行处理数据
   *
   */
  // 如果不是广播信息或者不是当前设备的信息，丢弃
  if (rx[0] != 0 && rx[0] != g_processer->modbus_device_id) {
    return;
  }
  // CRC校验失败
  if (!modbus_checkcrc16(rx, rxlen)) {
    return;
  }
  //   if(functioncode)
  static ModbusMasterData_t rxorder;
  static ModbusSlaveData_t  txorder;
  // 将接受到的数据进行组包
  ModbusProcessRxData(rx, rxlen, &rxorder);
  // static uint16_t txsendlen = 0;  // 因为keil报警告才注释
  txorder.deviceId = g_processer->modbus_device_id;
  // 功能码
  txorder.functionCode = rxorder.functionCode;

  modbus_processer_context_t context = {0};
  context.tx                         = &txorder;
  context.rx                         = &rxorder;
  g_processer->process_rx(&context);
}

/***********************************************************************************************************************
 * ======================================================Extern======================================================= *
 ***********************************************************************************************************************/

ModbusFunctionCode modbus_get_function_code(modbus_processer_context_t* context) {  //
  return context->tx->functionCode;
}
void modbus_set_tx_reg_03(modbus_processer_context_t* context, uint16_t regoff, uint16_t regdata) {
  uint16_t off = regoff - context->rx->d.O03.startreg;
  ModbusCreateTx_setReg(g_processer->modbus_processer_tx_buf, g_processer->modbus_processer_tx_buf_size, off,  //
                        regdata);
}
void modbus_set_tx_regs_03(modbus_processer_context_t* context, uint16_t regoff, uint16_t* regdata, int reglen) {
  for (int i = 0; i < reglen; i++) {
    modbus_set_tx_reg_03(context, regoff + i, regdata[i]);
  }
}

uint16_t modbus_get_reg_10(modbus_processer_context_t* context, uint16_t regoff) {
  uint16_t off  = regoff - context->rx->d.O10.startreg;
  uint8_t* data = context->rx->d.O10.reg;
  if ((off + 1) * 2 <= context->rx->d.O10.bytenum) {
    uint16_t u16 = GET_UINT16(&data[off * 2]);
    return u16;
  } else {
    uint16_t u16 = data[off * 2];
    return u16;
  }
}
uint8_t* modbus_get_buf_10(modbus_processer_context_t* context, uint16_t regoff) {
  uint16_t off  = regoff - context->rx->d.O10.startreg;
  uint8_t* data = context->rx->d.O10.reg;
  return &data[off * 2];
}
bool modbus_if_register_exists_03(modbus_processer_context_t* context, uint16_t regoff) {
  uint16_t startreg = context->rx->d.O03.startreg;
  uint16_t endreg   = context->rx->d.O03.startreg + context->rx->d.O03.numreg;
  return regoff >= startreg && regoff < endreg;
}
bool modbus_if_registers_exists_03(modbus_processer_context_t* context, uint16_t regoff, uint16_t regnum) { return (modbus_if_register_exists_03(context, regoff) && modbus_if_register_exists_03(context, regoff + regnum - 1)); }

bool modbus_if_register_exists_10(modbus_processer_context_t* context, uint16_t regoff) {
  uint16_t startreg = context->rx->d.O10.startreg;
  uint16_t endreg   = context->rx->d.O10.startreg + context->rx->d.O10.numreg;
  return regoff >= startreg && regoff < endreg;
}
void modbus_send_03(modbus_processer_context_t* context, ModbusStatus modbus_status) {
  uint16_t sendlegth = 0;
  if (modbus_status == Modbus_OK) {
    /**
     * @brief 正常
     */
    context->tx->functionCode  = context->rx->functionCode;
    context->tx->deviceId      = g_processer->modbus_device_id;
    context->tx->d.O03.bytenum = context->rx->d.O03.numreg * 2;
    context->tx->d.O03.reg     = nullptr;
    // 组成响应包
    ModbusCreateTxData(g_processer->modbus_processer_tx_buf, g_processer->modbus_processer_tx_buf_size, &sendlegth, context->tx);
    // 包组成以后发送给服务端
    g_processer->tx(g_processer->modbus_processer_tx_buf, sendlegth);
  } else {
    // LOGD("error");
    /**
     * @brief 异常
     */
    // 处理异常情况
    ModbusCreateExceptionData(g_processer->modbus_processer_tx_buf,       //
                              g_processer->modbus_processer_tx_buf_size,  //
                              &sendlegth,                                 //
                              g_processer->modbus_device_id,              //
                              context->rx->functionCode,                  //
                              modbus_status);
    // 组包完成发送应答
    g_processer->tx(g_processer->modbus_processer_tx_buf, sendlegth);
  }
}
void modbus_send_10(modbus_processer_context_t* context, ModbusStatus modbus_status) {
  uint16_t sendlegth = 0;
  if (modbus_status == Modbus_OK) {
    context->tx->functionCode   = context->rx->functionCode;
    context->tx->deviceId       = g_processer->modbus_device_id;
    context->tx->d.O10.regnum   = context->rx->d.O10.numreg;
    context->tx->d.O10.startreg = context->rx->d.O10.startreg;
    // 构造回执，并发送
    ModbusCreateTxData(g_processer->modbus_processer_tx_buf, g_processer->modbus_processer_tx_buf_size, &sendlegth, context->tx);
    g_processer->tx(g_processer->modbus_processer_tx_buf, sendlegth);
  } else {
    // 构造异常包并发送
    ModbusCreateExceptionData(g_processer->modbus_processer_tx_buf,       //
                              g_processer->modbus_processer_tx_buf_size,  //
                              &sendlegth,                                 //
                              g_processer->modbus_device_id,              //
                              context->rx->functionCode,                  //
                              modbus_status);
    g_processer->tx(g_processer->modbus_processer_tx_buf, sendlegth);
  }
}