#include "init.h"
#include "chipflash.h"
#include "crc.h"
#include "soft_can.h"
#include "timer.h"
#include "math.h"


_WS_INFO ws_info = {
    ._app_bin_size = 0xFFFFFFFF,
    ._compAddr = COMP_ADDR,
    ._hardVer = HARDVER,
    ._softVer = SOFT_VER,
    ._moduleID = MODULE_ID,
    ._bootFlag = BOOT_FLAG,
};

/*软重启判断*/
static void Soft_Reset_Judge(void) {
  static uint8_t buf[8] = {0};
  flash_ops->Read_Flash(RESET_FLASH_BASE, buf, sizeof(buf));

  if (buf[0] == 0xFE) // 判断是否是软件重启
  {
    flash_ops->Erase_Flash(RESET_FLASH_BASE, RESET_FLASH_END);
  }
}

/* 读取FLASH波特率设置，0x1F4 = 500K,0x3E8 = 1000K */
static void Set_Can_Baud(void) {
  uint8_t BaudBuf[2] = {0};
  uint16_t setbaudflag = 0;
  flash_ops->Read_Flash(CAN_FLASH_BASE, BaudBuf, sizeof(BaudBuf));

  setbaudflag = BaudBuf[1];
  setbaudflag = (setbaudflag << 8) + BaudBuf[0];
  if (0x1F4 == setbaudflag) {
    MX_CAN_Init(8);
  } else if (0x3E8 == setbaudflag) {
    MX_CAN_Init(4);
  } else {
    setbaudflag = 0x3E8;
    BaudBuf[0] = setbaudflag & 0xff;
    BaudBuf[1] = (setbaudflag & 0xff00) >> 8;
    flash_ops->Erase_Flash(CAN_FLASH_BASE, CAN_FLASH_END); // 默认重写0x3E8
    flash_ops->Write_Flash(CAN_FLASH_BASE, BaudBuf, sizeof(BaudBuf));
    MX_CAN_Init(4);
  }
}

/*需要升级*/
void Write_Upgrade_Flag(void) {
  ws_info._bootFlag = BOOT_FLAG;

  flash_ops->Erase_Flash(PAR_FLASH_BASE_ADDR, PAR_FLASH_END_ADDR);

  flash_ops->Write_Flash(PAR_FLASH_BASE_ADDR, (uint8_t *)&ws_info,
                         sizeof(ws_info));
}

/*重置升级标志位*/
static void Reset_Upgrade(void) {
  flash_ops->Read_Flash(PAR_FLASH_BASE_ADDR, (uint8_t *)&ws_info,
                        sizeof(ws_info));
  /*merge的时候合并冲突把这个标志位覆盖成了不存在升级！！引以为戒！*/
#if OFF_SEL == 1
  if (ws_info._bootFlag != NOEXIST_UPGRADE_FLAG)
#elif OFF_SEL == 2
  if (ws_info._bootFlag != UNUPGRADE)
#else
  if (ws_info._bootFlag != UNUPGRADE)
#endif
  {
#if OFF_SEL == 1
    ws_info._bootFlag = NOEXIST_UPGRADE_FLAG;
#elif OFF_SEL == 2
    ws_info._bootFlag = UNUPGRADE;
#else
    ws_info._bootFlag = UNUPGRADE;
#endif
    ws_info._app_bin_size = 0xFFFFFFFF, ws_info._compAddr = COMP_ADDR,
    ws_info._hardVer = HARDVER, ws_info._softVer = SOFT_VER,
    ws_info._moduleID = MODULE_ID,

    flash_ops->Erase_Flash(PAR_FLASH_BASE_ADDR, PAR_FLASH_END_ADDR);
    ws_info._crcCheck = Get_Crc16((uint8_t *)&ws_info, sizeof(ws_info) - 2);
    flash_ops->Write_Flash(PAR_FLASH_BASE_ADDR, (uint8_t *)&ws_info,
                           sizeof(ws_info));
  }
}

static void Load_Param(void) {
  uint32_t v_check;
  uint32_t tmp_g;
  float tmp_k;
  uint8_t sensor_num_c = 0;
  WEIGHING_DEVICE *device = Get_Device_Handle();
  flash_ops->Read_Flash(VALUE_FLASH_Check_Addr, (uint8_t *)&v_check,
                        sizeof(v_check));

  if (Value_Check == v_check) {
    flash_ops->Read_Flash(SENSOR_NUM_RECORD_BASE, (uint8_t *)&sensor_num_c,
                          sizeof(sensor_num_c));
    if (sensor_num_c <= SENSOR_NUM) {
      device->sensor_num_mask = sensor_num_c;
    }

    for (sensor_num_c = 0; sensor_num_c < SENSOR_NUM; sensor_num_c++) {
      struct SENSOR *sensor = device->sensor[sensor_num_c];
      if (sensor_num_c == device->sensor_num_mask) {
        sensor->base_k = 0;
        continue;
      }

      
      flash_ops->Read_Flash(GROSSWEIGHT1_FLASH_BASE +
                                sensor_num_c * ONE_WORD_SIZE,
                            (uint8_t *)&tmp_g, sizeof(tmp_g));

      if (tmp_g != 0xFFFFFFFF && tmp_g != 0) {
        device->sensor[sensor_num_c]->GrossWeight = tmp_g;
      }
    }

    flash_ops->Read_Flash(K1_VALUE_FLASH_BASE,(uint8_t *)&tmp_k, sizeof(tmp_k));
    device->correct_k = tmp_k;
    flash_ops->Read_Flash(K1_VALUE_FLASH_BASE,(uint8_t *)&tmp_g, sizeof(tmp_k));
    if(tmp_g == 0xFFFFFFFF)
    {
      device->correct_k = 1;
    }

  }
}

static void Record_First_InitValue(void) {
  WEIGHING_DEVICE *device = Get_Device_Handle();
  for (uint8_t sensor_num_c = 0; sensor_num_c < SENSOR_NUM; sensor_num_c++) {
    if (sensor_num_c == device->sensor_num_mask) {
      continue;
    }

    struct SENSOR *sensor = device->sensor[sensor_num_c];
    flash_ops->Read_Flash(
        SENSOR1_INIT_VALUE_BASE + sensor_num_c * ONE_WORD_SIZE,
        (uint8_t *)&sensor->raw_init_value, sizeof(sensor->raw_init_value));

    if (sensor->raw_init_value == 0xFFFFFFFF) {
      sensor->raw_init_value = sensor->GrossWeight;
      flash_ops->Write_Flash(
          SENSOR1_INIT_VALUE_BASE + sensor_num_c * ONE_WORD_SIZE,
          (uint8_t *)&sensor->raw_init_value, sizeof(sensor->raw_init_value));
    }
  }
}

static void Get_Warn_Licence(void) {
  float read_tmp = 0;
  WEIGHING_DEVICE *device = Get_Device_Handle();
  for (uint8_t sensor_num_c = 0; sensor_num_c < SENSOR_NUM; sensor_num_c++) {
    struct SENSOR *sensor = device->sensor[sensor_num_c];
    
    if (sensor_num_c == device->sensor_num_mask) {
      continue;
    }
    
    flash_ops->Read_Flash(SENSOR1_INIT_VALUE_BASE +
                              sensor_num_c * ONE_PARAM_SIZE,
                          (uint8_t *)&read_tmp, sizeof(read_tmp));
    
    if(read_tmp < MIN_K || read_tmp > MAX_K)
        sensor->base_k = 112.0f;
    else
        sensor->base_k = read_tmp;   

    // if (read_tmp <= 0x7FB000) {
    //   sensor->init_flag = lower;
    // }
    // if (read_tmp >= 0x803000) {
    //   sensor->init_flag = higher;
    // }
    // if (read_tmp >= 0x7FB000 && read_tmp <= 0x803000) {
    //   sensor->init_flag = equal;
    // }
  }
}

static void Read_Params(void) {
  WEIGHING_DEVICE *device = Get_Device_Handle();
  device->_ops->get_allgrossweight();
  delay_us(200);
  Record_First_InitValue();
  Get_Warn_Licence(); //读基础K
  Load_Param();
  /*防止异常*/
  for (uint8_t sensor_num_c = 0; sensor_num_c < SENSOR_NUM; sensor_num_c++) {
    if (sensor_num_c == device->sensor_num_mask) {
      continue;
    }
    struct SENSOR *sensor = device->sensor[sensor_num_c];
    // if (sensor->K.f < MIN_K || sensor->K.f > MAX_K || sensor->K.i[0] == 0xff) {
    //   sensor->K.f = 112.0f;
    // }
  }
}

void Device_Init(void) {
  WEIGHING_DEVICE *device = Get_Device_Handle();

  Reset_Upgrade();

  Set_Can_Baud();

  CAN_Init(CANTX_ID);

  device->_ops->filter_init();

  Read_Params();

  Soft_Reset_Judge();
  // 主动发送K值
  Set_Ack_Status(ack_e1); 
}