#include "hardware.hpp"

#include "adc.h"
#include "tim.h"
#include "zsdk/zcanreceiver/zcanreceiver.hpp"
#define TAG "HARD"
using namespace iflytop;

/***********************************************************************************************************************
 *                                                         EXT                                                         *
 ***********************************************************************************************************************/

static osThreadId H2O2CaptureThreadId;
static osThreadId AlarmLightThreadId;

/***********************************************************************************************************************
 *                                                        FUNC                                                         *
 ***********************************************************************************************************************/
static void c_onH2O2CaptureThread(void const* argument) { Hardware::ins().onH2O2CaptureThread(); }
static void c_onAlarmLightThread(void const* argument) { Hardware::ins().onAlarmLightThread(); }

int32_t Hardware::readSwitchGroup() {
  int32_t id = 0;
  id |= m_switch_group0.read() << 0;
  id |= m_switch_group1.read() << 1;
  id |= m_switch_group2.read() << 2;
  id |= m_switch_group3.read() << 3;
  id |= m_switch_group4.read() << 4;
}

void Hardware::setAlarmLight(bool r, bool g, bool y) {
  m_alarmLightR.write(r);
  m_alarmLightG.write(g);
  m_alarmLightY.write(y);
}

void Hardware::setAlarmLight(light_state_t state) { m_alarmLightState = state; }

void Hardware::init() {
  m_alarmLightR.initAsOutput(PD7, kxs_gpio_pullup, true, false);
  m_alarmLightG.initAsOutput(PD9, kxs_gpio_pullup, true, false);
  m_alarmLightY.initAsOutput(PD8, kxs_gpio_pullup, true, false);

  m_switch_group0.initAsInput(PE0, kxs_gpio_nopull, kxs_gpio_no_irq, false);
  m_switch_group1.initAsInput(PE1, kxs_gpio_nopull, kxs_gpio_no_irq, false);
  m_switch_group2.initAsInput(PE3, kxs_gpio_nopull, kxs_gpio_no_irq, false);
  m_switch_group3.initAsInput(PE6, kxs_gpio_nopull, kxs_gpio_no_irq, false);
  m_switch_group4.initAsInput(PE8, kxs_gpio_nopull, kxs_gpio_no_irq, false);

  id_from_machine.initAsInput(PE8, kxs_gpio_nopull, kxs_gpio_no_irq, false);

  ZLOGI(TAG, "switch group:%d id_from_machine %d", readSwitchGroup(), id_from_machine.read());

  setAlarmLight(kdisconnected);
  /**
   * @brief 探测HMP110
   */
  osDelay(2000);  // 等待传感器上电

#ifdef H2O2_SENSOR_TYPE_HMP110

  ZASSERT(huart2.Init.BaudRate == 19200);
  ZASSERT(huart2.Init.StopBits == UART_STOPBITS_2);
  m_H2o2Sensor_ModbusBlockHost.initialize(&huart2);
  m_H2o2Sensor_H2O2Adc.initialize(&hadc1, ADC_CHANNEL_10);  //
  m_H2o2Sensor_HMP110.init(&m_H2o2Sensor_ModbusBlockHost);

  if (m_H2o2Sensor_HMP110.ping(1)) {
    m_h2o2sensor_detectId = 1;
  }
  if (m_H2o2Sensor_HMP110.ping(240)) {
    m_h2o2sensor_detectId = 240;
  }
  m_H2o2Sensor_HMP110.setid(m_h2o2sensor_detectId);
  ZLOGI(TAG, "H2O2 HMP110 Sensor detect id: %d", m_h2o2sensor_detectId);

#endif

#ifdef H2O2_SENSOR_TYPE_HPP272

  ZASSERT(huart3.Init.BaudRate == 19200);
  ZASSERT(huart3.Init.StopBits == UART_STOPBITS_2);
  m_H2o2Sensor_ModbusBlockHost.initialize(&huart3);
  m_H2o2Sensor_HPP272.init(&m_H2o2Sensor_ModbusBlockHost);

  if (m_H2o2Sensor_HPP272.ping(1)) {
    m_h2o2sensor_detectId = 1;
  }
  if (m_H2o2Sensor_HPP272.ping(240)) {
    m_h2o2sensor_detectId = 240;
  }

  m_H2o2Sensor_HPP272.setid(m_h2o2sensor_detectId);
  ZLOGI(TAG, "H2O2 HPP272 Sensor detect id: %d", m_h2o2sensor_detectId);

#endif

  osThreadDef(H2O2CaptureThread, c_onH2O2CaptureThread, osPriorityNormal, 0, 1024);
  H2O2CaptureThreadId = osThreadCreate(osThread(H2O2CaptureThread), NULL);

  osThreadDef(AlarmLightThread, c_onAlarmLightThread, osPriorityNormal, 0, 1024);
  AlarmLightThreadId = osThreadCreate(osThread(AlarmLightThread), NULL);
}

/***********************************************************************************************************************
 *                                                        H2O2                                                         *
 ***********************************************************************************************************************/

bool Hardware::h2o2_sensor_is_online() {
#ifdef H2O2_SENSOR_TYPE_HMP110
  if (m_h2o2sensor_detectId <= 0) return false;
  int32_t ecode = m_H2o2Sensor_HMP110.read_cache_errorcode();
  if (ecode == -1) return false;
#endif

#ifdef H2O2_SENSOR_TYPE_HPP272
  if (m_h2o2sensor_detectId <= 0) return false;
  int32_t ecode = m_H2o2Sensor_HPP272.read_cache_errorcode();
  if (ecode == -1) return false;
#endif

  return true;
}
int32_t Hardware::h2o2_sensor_read_calibration_date(int32_t* year, int32_t* month, int32_t* day) {  //
  *year  = 1;
  *month = 2;
  *day   = 3;
  return 0;
}
int32_t Hardware::h2o2_sensor_read_sub_ic_errorcode() {  //
#ifdef H2O2_SENSOR_TYPE_HPP272
  return m_H2o2Sensor_HPP272.read_cache_errorcode();
#endif

#ifdef H2O2_SENSOR_TYPE_HMP110
  return m_H2o2Sensor_HMP110.read_cache_errorcode();
#endif
}
int32_t Hardware::h2o2_sensor_read_sub_ic_reg(int32_t add, uint16_t* val, size_t len) {  //
#ifdef H2O2_SENSOR_TYPE_HPP272
  if (m_H2o2Sensor_HPP272.read_reg(add, val, len)) {
    return 0;
  }
#endif

#ifdef H2O2_SENSOR_TYPE_HMP110
  if (m_H2o2Sensor_HMP110.read_reg(add, val, len)) {
    return 0;
  }
#endif
  return kerr_subdevice_offline;
}
int32_t Hardware::h2o2_sensor_data(report_h2o2_data_t* readdata) {
#ifdef H2O2_SENSOR_TYPE_HMP110
  int32_t                     ecode      = m_H2o2Sensor_HMP110.read_cache_errorcode();
  int32_t                     h2o2adcVal = m_H2o2Sensor_H2O2Adc.getCacheVal();
  HMP110::hmp110_sensordata_t sensordata;
  m_H2o2Sensor_HMP110.read_cache_sensor_data(&sensordata);

  // float    mv   = adcv / 4095.0 * 3.3 * 1000;
  // float    ma   = mv / 150.0;
  // float    ppm  = (ma - 4) / (20 - 4) * 2000;
  int32_t h2o2ma  = (h2o2adcVal / 4095.0 * 3.3 * 1000) / 150.0;
  int32_t h2o2ppm = (h2o2ma - 4) / (20 - 4) * 2000;

  readdata->sensor_error = ecode != 0;
  readdata->h2o2         = h2o2ppm;
  readdata->humid        = sensordata.rh;
  readdata->temp         = sensordata.temp;
  readdata->saturation   = 0;

  ZLOGI(TAG, "ecode: %d ppm:%d, rh:%d, temp:%d, df_ptemp:%d, ah:%d, mr:%d, wbt:%d, eh:%d",  //
        ecode,                                                                              //
        h2o2ppm,                                                                            //
        sensordata.rh,                                                                      //
        sensordata.temp,                                                                    //
        sensordata.df_ptemp,                                                                //
        sensordata.ah,                                                                      //
        sensordata.mr,                                                                      //
        sensordata.wet_bulb_temp,                                                           //
        sensordata.enthalpy);

  return 0;
#endif
#ifdef H2O2_SENSOR_TYPE_HPP272

  int32_t               ecode = m_H2o2Sensor_HPP272.read_cache_errorcode();
  HPP272::hpp272_data_t sensordata;
  m_H2o2Sensor_HPP272.read_cache_sensor_data(&sensordata);

  readdata->sensor_error = ecode != 0;
  readdata->h2o2         = sensordata.hydrogen_peroxide_volume / 10.0;
  readdata->humid        = sensordata.relative_humidity / 10.0;
  readdata->temp         = sensordata.temperature1 / 10.0;
  readdata->saturation   = sensordata.h2o_h2o2_rs / 10.0;

  ZLOGI(TAG, "h2o2 %d, humid %d, temp %d, sat %d",
        sensordata.hydrogen_peroxide_volume / 10,  //
        sensordata.relative_humidity / 10,         //
        sensordata.temperature1 / 10,              //
        sensordata.h2o_h2o2_rs / 10);

  return 0;
#endif
}

void Hardware::onH2O2CaptureThread() {
  while (1) {
    osDelay(1000);

#ifdef H2O2_SENSOR_TYPE_HMP110
    if (m_h2o2sensor_detectId > 0) {
      m_H2o2Sensor_H2O2Adc.updateAdcValToCache();
      m_H2o2Sensor_HMP110.updateSensorDataAndErrorcode();
    }
#endif

#ifdef H2O2_SENSOR_TYPE_HPP272
    if (m_h2o2sensor_detectId > 0) {
      m_H2o2Sensor_HPP272.updateSensorDataAndErrorcode();
    }
#endif
  }
}

void Hardware::onAlarmLightThread() {
  while (1) {
    osDelay(500);
    if (m_alarmLightState == kdisconnected) {
      static bool state;
      setAlarmLight(false, state, false);
      state = !state;
    } else if (m_alarmLightState == kconnected) {
      setAlarmLight(true, true, false);
    } else if (m_alarmLightState == kerror) {
      setAlarmLight(true, false, false);
    }
  }
}