#include <eqpalg/algs/meter_static.h>
#include <eqpalg/table_struct/fv_result_latest.h>
#include <eqpalg/table_struct/fv_upl_downl_cfg.h>
#include <eqpalg/table_struct/t_rule_cfg.h>
MeterStatic::MeterStatic(const string name, const mix_cc::json& rule_json,
                         const string ruleId)
    : TableStatic(name, rule_json, ruleId) {
  logger_.reset(new LOG("MeterStatic:" + rule_name_, AUTO_CATCH_PID));
}
MeterStatic::~MeterStatic() {}

int MeterStatic::init() {
  try {
    logger_->Debug() << "Test1!" << std::endl;
    logger_->Debug() << this->rule_name_ << " Test1!-test2" << std::endl;
    logger_->Debug() << this->rule_id_ << " Test1!-test3" << std::endl;
    TableStatic::init_config();
    logger_->Debug() << "Test2!" << std::endl;
    ///标记 group 后缀
    this->latest_alarm_time_flag_ = rule_json_.at("config_setting")
                                        .at("lastest_alarm_time")
                                        .at(1)
                                        .get<int>();
    this->logger_->Debug()
        << "latest_alarm_time_flag_[0-没有最新报警时间；1-有最新报警时间]:"
        << this->latest_alarm_time_flag_ << endl;

    this->up_down_flag_ =
        rule_json_.at("config_setting").at("up_down_flag").at(1).get<int>();
    this->logger_->Debug() << "up_down_flag_[0-没有上下限；1-有上下限]:"
                           << this->up_down_flag_ << endl;
    logger_->Debug() << "Test3! " << this->latest_alarm_time_flag_ << std::endl;
    //上下限 1
    this->meter_data_.group_name_ = this->table_name_;
    if (up_down_flag_) {
      this->meter_data_.group_name_ += "-上下限";
    }
    ///最新报警时间 0

    logger_->Debug() << "Test4!" << std::endl;
    get_ruleid();  ///<查cfg
    // logger_->Debug() << "Test2!" << std::endl;
    this->Jkey_ += this->table_key_;
    logger_->Debug() << "Test5! " << this->meter_data_.latest_alarm_time_.size()
                     << std::endl;
  } catch (const std::exception& e) {
    std::throw_with_nested(
        mix_cc::Exception(-1, "init error", BOOST_CURRENT_LOCATION));
  }
  return 0;
}

AlarmInfo MeterStatic::exec_mon() {
  AlarmInfo out_alarm{};

  if (this->get_cycled_proc()) {
    int reSult = this->mon_proc();
    this->logger_->Debug() << " update json" << endl;
  } else if (this->up_down_flag_ && this->get_clear_flag()) {
    mix_cc::json js1 = this->meter_data_.invert2json();
    this->Jvalue_ = js1.dump();
    // this->logger_->Debug() << "Jkey:" << this->Jkey_
    //                        << " this->Jvalue_ :" << this->Jvalue_ << endl;
    auto reSult = insert_memcache(this->Jkey_, this->Jvalue_);
  }

  return out_alarm;
}
int MeterStatic::mon_proc() {
  int ret = 0;
  if (!is_rules_empty_) {
    if (this->latest_alarm_time_flag_) {
      for (int i = 0; i < this->meter_data_.rule_nums_; i++) {
        this->meter_data_.latest_alarm_time_[i] =
            select_latest_alarm_by_ruleid(this->meter_data_.rule_ids_[i]);
      }
    } else {
      this->meter_data_.clear_latest_alarm_time();
    }
    if (this->up_down_flag_) {
      for (int i = 0; i < this->meter_data_.rule_nums_; i++) {
        auto reSult =
            this->select_up_down_by_ruleid(this->meter_data_.rule_ids_[i]);
        this->meter_data_.downL_[i] = reSult[0];
        this->meter_data_.upL_[i] = reSult[1];
      }
    } else {
      this->meter_data_.clear_downL();
      this->meter_data_.clear_upL();
    }
    mix_cc::json js1 = this->meter_data_.invert2json();
    this->Jvalue_ = js1.dump();
    // this->logger_->Debug() << "Jkey:" << this->Jkey_
    //                        << " this->Jvalue_ :" << this->Jvalue_ << endl;
    auto reSult = insert_memcache(this->Jkey_, this->Jvalue_);
  } else {
    this->logger_->Debug() << this->meter_data_.group_name_ << " 没有配置规则！"
                           << endl;
    return -1;
  }
  return ret;
}

int MeterStatic::get_ruleid_by_int(int num) {
  T_RULE_CFG trc;
  string grop_name = this->meter_data_.group_name_;
  auto query_list_maybe =
      exec<db2_t, T_RULE_CFG>(select(trc.ruleId(), trc.ruleName())
                                  .from(trc)
                                  .where(trc.ruleGroup() == grop_name));
  if (query_list_maybe.is_just()) {
    auto& query_list = query_list_maybe.unsafe_get_just();
    if (!query_list.empty()) {
      this->meter_data_.rule_nums_ = query_list.size();
      logger_->Info() << query_list.size() << " rules in DB where group is:"
                      << this->meter_data_.group_name_ << endl;

      for (int i = 0; i < this->meter_data_.rule_nums_; i++) {
        this->meter_data_.rule_ids_.push_back(query_list[i].ruleId);
        this->meter_data_.rule_names_.push_back(query_list[i].ruleName);
      }

      this->meter_data_.init_sort_by_name();

    } else {
      this->gb_logger_->log_error("no rule in DB where group is:" +
                                  this->meter_data_.group_name_);
      return -2;
    }
  } else {
    this->gb_logger_->log_error("db2查询失败" + this->rule_name_);
    return -1;
  }
  return 0;
}

void MeterStatic::get_ruleid() {
  get_ruleid_by_int(0);

  this->is_rules_empty_ = !this->meter_data_.rule_nums_;
}

string MeterStatic::select_latest_alarm_by_ruleid(string ruleid) {
  try {
    FV_RESULT_LATEST fvrl;

    auto query_list_maybe = exec<db2_t, FV_RESULT_LATEST>(
        select(fvrl.alarmtime()).from(fvrl).where(fvrl.ruleId() == ruleid));

    if (query_list_maybe.is_just()) {
      auto& query_list = query_list_maybe.unsafe_get_just();
      if (query_list.size() == 0) {
        return "无报警";
      }

      string quered_time =
          mix_cc::mix_time_t(query_list[0].alarmtime).to_formatted_time();
      this->logger_->Debug() << "quered_time:" << quered_time << std::endl;
      return quered_time;

    } else {
      return "无报警";
    }
  } catch (std::exception& e) {
    this->logger_->Error() << this->rule_name_ << e.what() << std::endl;
  }
  return "无报警";
}

std::array<double, 2> MeterStatic::select_up_down_by_ruleid(string ruleid) {
  FV_UPL_DOWNL_CFG fvud;
  auto query_list_maybe =
      exec<db2_t, FV_UPL_DOWNL_CFG>(select(fvud.downl(), fvud.upl())
                                        .from(fvud)
                                        .where(fvud.ruleId() == ruleid));
  if (query_list_maybe.is_just()) {
    auto& query_list = query_list_maybe.unsafe_get_just();

    return {query_list[0].downl, query_list[0].upl};

  } else {
    this->logger_->Error() << this->rule_name_
                           << " FV_UPL_DOWNL_CFG SQL查询异常" << std::endl;
    return {0, 0};
  }
}

bool MeterStatic::get_clear_flag() {
  string Jkey = string(CMemVar::Const()->UnitNo) + "_" + "up_down_flag";
  string Jkey2 = string(CMemVar::Const()->UnitNo) + "_" + "up_down_flag_id";
  auto reSult = m_memclient.Get(Jkey.c_str());
  auto reSult2 = m_memclient.Get(Jkey2.c_str());
  // this->logger_->Debug() << "Jkey:" << Jkey << " Jvalue:" << reSult << endl;
  // this->logger_->Debug() << "Jkey2:" << Jkey2 << " Jvalue2:" << reSult2 <<
  // endl;
  string Jvalue = "0";
  if (reSult == "no key" || reSult == "no value" || reSult == "1") {
    auto find_r = std::find(this->meter_data_.rule_ids_.begin(),
                            this->meter_data_.rule_ids_.end(), reSult2);
    if (find_r != this->meter_data_.rule_ids_.end()) {
      int sub_index = find_r - this->meter_data_.rule_ids_.begin();
      //
      if (this->up_down_flag_ == 1) {
        auto up_downL = this->select_up_down_by_ruleid(
            this->meter_data_.rule_ids_[sub_index]);
        this->meter_data_.downL_[sub_index] = up_downL[0];
        this->meter_data_.upL_[sub_index] = up_downL[1];
      }

      this->insert_memcache(Jkey, Jvalue);
      return true;
    } else {
      // this->insert_memcache(Jkey, Jvalue);
      this->logger_->Debug() << "ruleid: " << reSult2 << " 不存在！" << endl;
    }
  }
  return false;
}