#include <eqpm/eqp_status.h>
#include <eqpm/jsonReader.hpp>
#include <eqpm/table_struct/FV_DSC_PDI_DATA.h>
#include <eqpm/table_struct/FV_RESULT_JOIN_EQPID.h>
#include <mix_cc/sql.h>
#include <mix_cc/sql/database/db2_t.h>
namespace {

typedef char CoilID[32];
double limit_precision(double data, int precision) {
  double factor = std::pow(10, precision);
  return std::round(data * factor) / factor;
}
float limit_precision(float data, int precision) {
  float factor = std::pow(10, precision);
  return std::round(data * factor) / factor;
}

string double2str(double data, int precision) {
  std::stringstream ss;
  ss << std::fixed << std::setprecision(precision) << data;
  return ss.str();
}
string float2str(float data, int precision) {
  std::stringstream ss;
  ss << std::fixed << std::setprecision(precision) << data;
  return ss.str();
}

} // namespace

EqpStatus::EqpStatus() {
  logger_ = std::make_unique<LOG>("EqpStatus");
  init();
  p_btel = new BinaryTele(1002, "T_LOV_TELEITEM");
  update_alarm_info();
  update_coil_info();
}
EqpStatus::~EqpStatus() {}
void EqpStatus::init() {
  /*数据模板*/
  string file_path = "/users/dsc/code/eqpm/json/eqp_status.json";
  if (!JsonHelper::jsonReader(file_path, eqp_status_json_)) {
    logger_->Error() << "文件读取失败" << endl;
  }
  string config_file_path = "/users/dsc/code/eqpm/json/eqp_status_config.json";
  if (!JsonHelper::jsonReader(config_file_path, eqp_status_config_json_)) {
    logger_->Error() << "文件读取失败" << endl;
  }
}

string EqpStatus::get_eqp_status() { return eqp_status_json_.dump(); }

void EqpStatus::dispose(int event_no, const ::Ice::ByteSeq &seq,
                        ::Ice::Int length) {

  p_btel->ReBuild(event_no, (char *)&seq[0]);
  int p_btel_size = p_btel->size();
  // p_btel->Print();
  // logger_->Debug() << eqp_status_config_json_.dump() << std::endl;
  /*------status_data------*/
  mix_cc::json &status_data = eqp_status_json_["status_data"];
  mix_cc::json &status_data_conf = eqp_status_config_json_["status_data"];
  for (auto & [ key, value ] : status_data_conf.items()) {
    float now_value = p_btel->operator[]((int)(value.get<int>() - 1));
    status_data[key] = float2str(
        (int)now_value * p_btel->operator[]((int)(value.get<int>() - 1)).factor,
        1);
    if (tolower(p_btel->operator[]((int)(value.get<int>() - 1)).type[0]) ==
        'b') {
      bool bv = p_btel->operator[]((int)(value.get<int>() - 1));
      status_data[key] = std::to_string(bv);
    }
  }
  /*-----tension-----*/

  if (eqp_status_json_.contains("tension") &&
      eqp_status_json_["tension"].is_array() &&
      eqp_status_config_json_.contains("tension") &&
      eqp_status_config_json_["tension"].is_array()) {
    mix_cc::json &tension_data = eqp_status_json_["tension"];
    mix_cc::json &tension_data_conf = eqp_status_config_json_["tension"];
    int td_size = tension_data.size();
    int tdc_size = tension_data_conf.size();
    if (td_size == tdc_size && td_size == 2) {
      for (int i = 0; i < td_size; i++) {
        mix_cc::json &tdi = tension_data[i];
        mix_cc::json &tdci = tension_data_conf[i];
        int tdi_size = tdi.size();
        int tdci_size = tdci.size();
        if (tdi_size == tdci_size) {
          for (int j = 0; j < tdi_size; j++) {
            float now_value = p_btel->operator[]((int)(tdci[j].get<int>() - 1));
            tdi[j] = float2str(
                now_value *
                    p_btel->operator[]((int)(tdci[j].get<int>() - 1)).factor,
                2);
            // logger_->Debug() << "i:" << i << ",j:" << j
            //                  << ",value:" << now_value << std::endl;
          }
        } else {
          logger_->Error() << "tdi_size == tdci  ERROR"
                           << ",tdi_szie:" << tdi_size
                           << ",tdci_size:" << tdci_size << std::endl;
        }
      }
    } else {
      logger_->Error() << "tdi_size == tdci ERROR"
                       << ",td_size:" << td_size << ",tdc_size:" << tdc_size
                       << std::endl;
    }
  }

  /*-----cpc----*/
  mix_cc::json &cpc_data = eqp_status_json_["cpc"];
  mix_cc::json &cpc_data_conf = eqp_status_config_json_["cpc"];
  int cpc_size = cpc_data.size();
  int cpcc_size = cpc_data_conf.size();
  if (cpc_size == cpcc_size && cpcc_size == 3) {
    for (int i = 0; i < cpc_size; i++) {
      mix_cc::json &cpci = cpc_data[i];
      mix_cc::json &cpcci = cpc_data_conf[i];
      int cpci_size = cpci.size();
      int cpcci_size = cpcci.size();
      if (cpci_size == cpcci_size && cpci_size == 10) {
        for (int j = 0; j < cpci_size; j++) {
          int indexj_cpc = (int)(cpcci[j].get<int>() - 1);
          if (p_btel->operator[](indexj_cpc).length == 2) {
            float now_value = p_btel->operator[](indexj_cpc);
            // if (indexj_cpc == 117) {
            if (indexj_cpc <= 117 && indexj_cpc >= 110) {
              now_value = (short)now_value & 1;
              logger_->Debug() << "now_value:" << now_value << endl;
            }
            cpci[j] = float2str(
                (float)now_value *
                    p_btel->operator[]((int)(cpcci[j].get<int>() - 1)).factor,
                1);
          } else {
            bool now_value = p_btel->operator[](indexj_cpc);
            cpci[j] = (int)now_value;
          }
        }
      } else {
        logger_->Debug() << " cpci_size :" << cpci_size
                         << ", cpcci_size:" << cpcci_size << std::endl;
      }
    }
  } else {
    logger_->Debug() << " cpc_size :" << cpc_size << ",cpcc_size:" << cpcc_size
                     << std::endl;
  }

  /*---------TR-----------*/
  mix_cc::json &TR_data = eqp_status_json_["TR"];
  mix_cc::json &TR_data_conf = eqp_status_config_json_["TR"];
  int TR_size = TR_data.size();
  int TRc_size = TR_data_conf.size();
  if (TR_size == TRc_size && TR_size == 6) {
    /*-----coildid-----*/
    int start = TR_data_conf[0][0].get<int>() - 1;
    int end = TR_data_conf[0][1].get<int>() - 1;
    int char_len = (end - start + 1) * 2;
    CoilID tr_coild_id;
    int bg = 0;
    for (int i = 0; i < start; i++) {
      bg += p_btel->operator[](i).length;
    }
    memset(&tr_coild_id, 0, sizeof(CoilID));
    memcpy(&tr_coild_id, (char *)&seq[0] + bg, char_len);
    // logger_->Debug() << "bg:" << bg << ",char_len:" << char_len
    //                  << ",tr_coild_id:" << tr_coild_id << std::endl;
    TR_data[0] = std::string(tr_coild_id);
    /*-----其他数据*/
    for (int j = 1; j < TR_size; j++) {
      int indexj = (int)(TR_data_conf[j].get<int>() - 1);
      float now_value = p_btel->operator[](indexj);
      if (j < 3) {
        TR_data[j] =
            float2str(now_value * p_btel->operator[](indexj).factor, 2);
      } else {
        TR_data[j] =
            float2str(now_value * p_btel->operator[](indexj).factor, 0);
      }

      // logger_->Debug() << "indexj:" << indexj << ",value:" << now_value
      //                  << std::endl;
    }
  }
  /*-------POR-------*/
  mix_cc::json &por_data = eqp_status_json_["POR"];
  mix_cc::json &por_data_conf = eqp_status_config_json_["POR"];
  int POR_size = por_data.size();
  int PORc_size = por_data_conf.size();
  if (POR_size == PORc_size && POR_size == 2) {
    for (int i = 0; i < POR_size; i++) {
      mix_cc::json &pori_data = por_data[i];
      mix_cc::json &pori_data_conf = por_data_conf[i];
      int pori_size = pori_data.size();
      int porci_size = pori_data_conf.size();
      if (pori_size == porci_size && pori_size == 5) {
        /*---------coild_id--*/
        int start = pori_data_conf[0][0].get<int>() - 1;
        int end = pori_data_conf[0][1].get<int>() - 1;

        int char_len = (end - start + 1) * 2;
        CoilID por_coild_id;
        int bg = 0;
        for (int j = 0; j < start; j++) {
          bg += p_btel->operator[](j).length;
        }
        // for (int k = 0; k < char_len / 2; k++) {
        //   short vl = p_btel->operator[](start + k);
        //   logger_->Debug() << "start:" << start + 1
        //                    << ",now index:" << start + 1 + k
        //                    << ",coidid int data:" << vl << std::endl;
        // }
        memset(&por_coild_id, 0, sizeof(CoilID));
        memcpy(&por_coild_id, (char *)&seq[0] + bg , char_len);
        // logger_->Debug() << "bg:" << bg << ",char_len:" << char_len
        //                  << ",por_coild_id:" << por_coild_id << std::endl;
        pori_data[0] = std::string(por_coild_id);
        /*-----其他数据*/
        for (int k = 1; k < pori_size; k++) {
          float now_value =
              p_btel->operator[]((int)(pori_data_conf[k].get<int>() - 1));
          pori_data[k] = (int)now_value;
        }
        int mt = pori_data[pori_size - 1].get<int>() / 60;
        int sed = pori_data[pori_size - 1].get<int>() % 60;
        string rm = std::to_string(mt) + ":" + std::to_string(sed);
        pori_data[pori_size - 1] = rm;
      } else {
        logger_->Debug() << "pori_size:" << pori_size
                         << ",porci_size:" << porci_size << std::endl;
      }
    }

  } else {
    logger_->Debug() << "POR_size:" << POR_size << ",PORc_size:" << PORc_size
                     << std::endl;
  }
}

void EqpStatus::update_alarm_info() {
  logger_->Debug() << "update_alarm_info()" << std::endl;
  mix_cc::json &eqp_status = eqp_status_json_["eqp_status"];
  mix_cc::json &eqpid = eqp_status["eqpid"];
  mix_cc::json &isAlarm = eqp_status["isAlarm"];
  int epqid_size = eqpid.size();
  short statuscode1 = 100;
  short statuscode2 = 200;
  for (int i = 0; i < epqid_size; i++) {
    string eqpidi = eqpid[i].get<string>();
    // int res = select_alarm_count(eqpidi, 0);

    int res1 = select_alarm_count(eqpidi, statuscode1);
    logger_->Debug() << "first---eqpid:" << eqpidi << ",未处理报警数量："
                     << res1 << std::endl;

    int res2 = select_alarm_count(eqpidi, statuscode2);
    logger_->Debug() << "second--eqpid:" << eqpidi << ",未处理报警跟踪数量："
                     << res2 << std::endl;
    int isAlarmNow = res2 == 0 ? 0 : 2;
    isAlarm[i] = res1 == 0 ? isAlarmNow : 1;
  }

  // for (int i = 0; i < epqid_size; i++) {
  //   string eqpidi = eqpid[i].get<string>();
  //   int res = select_alarm_count(eqpidi, 0);
  //   logger_->Debug() << "eqpid:" << eqpidi << ",报警数量：" << res <<
  //   std::endl; isAlarm[i] = res == 0 ? res : 1;
  // }
}

int EqpStatus::select_alarm_count(string eqpid, int dealresult) {
  FV_RESULT_JOIN_EQPID frje;
  auto min_time =
      mix_cc::mix_time_t(chrono::system_clock::now() - chrono::days(3));
  auto sql_statement =
      select(frje.ruleid())
          .from(frje)
          .where(frje.eqpid().like(eqpid + "%"), frje.alarmtime() > min_time,
                 frje.dealresult() == dealresult, frje.rank() == 1);
  logger_->Debug() << "sql_str:" << sql_statement.get_command() << std::endl;
  auto sql_rsult_maybe = exec<db2_t, FV_RESULT_JOIN_EQPID>(sql_statement);
  if (sql_rsult_maybe.is_just()) {
    auto sql_rsult = sql_rsult_maybe.unsafe_get_just();
    if (sql_rsult.empty()) {
      logger_->Debug() << "FV_RESULT_JOIN_EQPID  未查到数据，设备id:" << eqpid
                       << ",dealresult:" << dealresult << std::endl;
      return 0;
    } else {
      logger_->Debug() << "FV_RESULT_JOIN_EQPID  查询到数据数量："
                       << sql_rsult.size() << "，设备id:" << eqpid
                       << ",dealresult:" << dealresult << std::endl;
      return sql_rsult.size();
    }
  } else {
    logger_->Error() << "EqpStatus::update_alarm_info()查询失败！" << std::endl;
    return 0;
  }
  return 0;
}

int EqpStatus::select_alarm_count(string eqpid, short statuscode) {
  FV_RESULT_JOIN_EQPID frje;
  auto min_time =
      mix_cc::mix_time_t(chrono::system_clock::now() - chrono::days(3));
  auto sql_statement =
      select(frje.ruleid())
          .from(frje)
          .where(frje.eqpid().like(eqpid + "%"), frje.alarmtime() > min_time,
                 frje.statuscode() == statuscode, frje.rank() == 1);
  logger_->Debug() << "sql_str:" << sql_statement.get_command() << std::endl;
  auto sql_rsult_maybe = exec<db2_t, FV_RESULT_JOIN_EQPID>(sql_statement);
  if (sql_rsult_maybe.is_just()) {
    auto sql_rsult = sql_rsult_maybe.unsafe_get_just();
    if (sql_rsult.empty()) {
      logger_->Debug() << "FV_RESULT_JOIN_EQPID  未查到数据，设备id:" << eqpid
                       << ",statuscode:" << statuscode << std::endl;
      return 0;
    } else {
      logger_->Debug() << "FV_RESULT_JOIN_EQPID  查询到数据数量："
                       << sql_rsult.size() << "，设备id:" << eqpid
                       << ",statuscode:" << statuscode << std::endl;
      return sql_rsult.size();
    }
  } else {
    logger_->Error() << "EqpStatus::update_alarm_info()查询失败！" << std::endl;
    return 0;
  }
  return 0;
}

void EqpStatus::update_coil_info() {
  FV_DSC_PDI_DATA fdpd;
  auto sql_statement =
      select(fdpd.entid(), fdpd.extid(), fdpd.hentry(), fdpd.exthickave(),
             fdpd.width(), fdpd.weightcoil(), fdpd.diameterinside(),
             fdpd.diameteroutside(), fdpd.steelgrade())
          .from(fdpd);
  auto sql_rsult_maybe = exec<db2_t, FV_DSC_PDI_DATA>(sql_statement);
  if (sql_rsult_maybe.is_just()) {
    auto sql_rsult = sql_rsult_maybe.unsafe_get_just();
    if (sql_rsult.empty()) {
      logger_->Debug() << "FV_DSC_PDI_DATA  未查到数据，设备id:" << std::endl;
      return;
    } else {
      mix_cc::json &js1 = this->eqp_status_json_["steel_coil_info"]["data"];
      int rt_size = sql_rsult.size();
      logger_->Debug() << "FV_DSC_PDI_DATA  查询到数据数量：" << rt_size
                       << std::endl;
      for (int i = 0; i < rt_size; i++) {
        js1[i][0] = sql_rsult[i].entid;
        js1[i][1] = sql_rsult[i].extid;
        js1[i][2] = sql_rsult[i].hentry;
        js1[i][3] = sql_rsult[i].exthickave;
        js1[i][4] = sql_rsult[i].width;
        js1[i][5] = sql_rsult[i].weightcoil;
        js1[i][6] = sql_rsult[i].diameterinside;
        js1[i][7] = sql_rsult[i].diameteroutside;
        js1[i][8] = sql_rsult[i].steelgrade;
      }
    }
  } else {
    logger_->Error() << "EqpStatus::update_coil_info()查询失败！" << std::endl;
    return;
  }
}