#include <eqpalg/algs/dist_interval_alg.h>
#include <eqpalg/table_struct/t_rule_cfg.h>
#include <eqpalg/table_struct/t_rule_dist_interval.h>
#include <eqpalg/table_struct/t_rule_record_time.h>
#include <mix_cc/sql.h>
#include <fstream>  

DistInterval::~DistInterval() {}
int DistInterval::init() {
  int ret = 0;
  act_started_ = false;
  try {
    Exp::init();
    this->reload_config_vars();
    sample_stat_ = std::make_unique<stat_tools::Frame>(
        rule_id_, rule_name_, dims_, test_mode_,
        std::chrono::system_clock::now() - 1h, std::chrono::system_clock::now(),
        0, 0, 0);
    // // 目前暂时使用小时作为归档的单位间隔
    // sample_stat_->set_archive_interval(hours(archive_interval_day_));
    this->sample_stat_->set_prob(this->judge_diff_);
    // this->sample_stat_->load_data();
    this->last_select_db2_time_ = std::chrono::system_clock::now();
  } catch (const std::exception& e) {
    logger_->Info() << "数据载入错误 :" << rule_name_ << endl;  // 测试
    std::throw_with_nested(
        mix_cc::Exception(-1, "数据载入发生异常", BOOST_CURRENT_LOCATION));
    ret = -1;
  }
  return ret;
}

int DistInterval::reload_config_vars() {
  try {
    if (rule_json_.at("action_condition").contains("interval_source")) {
      this->interval_source_ = rule_json_.at("action_condition")
                                   .at("interval_source")
                                   .at(1)
                                   .get<int>();
      gb_logger_->log_info(rule_name_ + "interval_source_:" +
                           std::to_string(this->interval_source_));
    }
    if (rule_json_.at("action_condition").contains("interval_input")) {
      this->dist_interval_input_ = rule_json_.at("action_condition")
                                       .at("interval_input")
                                       .at(1)
                                       .get<std::string>();
      gb_logger_->log_info(rule_name_ +
                           "interval_input:" + this->dist_interval_input_);
    }
    if (rule_json_.at("alarm_option").contains("value")) {
      auto tmp_exp =
          rule_json_.at("alarm_option").at("value").at(1).get<std::string>();
      exp_str_ = get_macro_replaced_exp(tmp_exp);
      if (exp_result_ == nullptr) {
        exp_result_ =
            std::make_unique<mix_cc::matheval::Expression>(exp_str_, &mm_vars);
        logger_->Debug() << exp_str_ << ":" << exp_result_->evaluate() << endl;
      } else {
        logger_->Info() << "指针已经初始化完成" << exp_str_ << ":"
                        << exp_result_->evaluate() << endl;
      }
    }
    if (rule_json_.at("alarm_option").contains("sample_is_infinite_mode")) {
      this->is_no_down_limit_ =
          static_cast<bool>(rule_json_.at("alarm_option")
                                .at("sample_is_infinite_mode")
                                .at(1)
                                .get<int>());
    }
    test_mode_ = static_cast<stat_tools::TestMode>(
        rule_json_.at("alarm_option").at("mode").at(1).get<int>());
    judge_diff_ = rule_json_.at("alarm_option").at("diff").at(1).get<double>();
    error_str_ =
        rule_json_.at("alarm_option").at("error").at(1).get<std::string>();
    logger_->Debug()
        << "modejudge(0: absolute difference, 1: error percentage (%), 2: "
           "normal value signal (%),3. dtw curve distance(%), 4.poly fit(%)"
        << static_cast<int>(test_mode_) << " samplediff:" << judge_diff_
        << endl;
  } catch (std::exception& e) {
    logger_->Error() << "表达式-样本取样异常,表达式为: " << exp_str_
                     << std::endl;
    throw_with_nested(
        mix_cc::Exception(-1, "表达式样本载入错误", BOOST_CURRENT_LOCATION));
  }
  return 0;
}

AlarmInfo DistInterval::exec_mon() {
  AlarmInfo out_alarm;
  // 刷新当前时间
  this->refresh_now_time();
  if (!is_to_detect_ ||
      (std::chrono::system_clock::now() - this->last_select_db2_time_) > 5min) {
    is_to_detect_ = get_is_to_detect();
    update_show_interval();
    this->last_select_db2_time_ = std::chrono::system_clock::now();
  }
  if (this->is_to_detect_) {
    switch (data_source_) {
      case DataSource::IHDB:
      case DataSource::MEMORY: {
        // 刷新内存对应的变量数据
        refresh_exp_vars_mem();
        query_time_range_.set_left(query_time_range_.get_right() -
                                   delay_time_);  // 2021-10-27 刷新报警开始时间
        auto o_value = this->cron_proc_sample();
        if (o_value.has_value()) {
          if (this->is_no_down_limit_) {
            if (o_value.value()[0] > this->dist_right_) {
              // 报警
              auto alarm_time_range = query_time_range_;
              alarm_time_range.set_left(alarm_time_range.get_right() -
                                        this->delay_time_);
              auto msg = rule_name_ + " " + error_str_ + " 当前值为" +
                         std::to_string(o_value.value()[0]) + " 3σ区间为[" +
                         std::to_string(this->dist_left_) + "," +
                         std::to_string(this->dist_right_) + "]";
              return utility::build_alarm_info(MsgLevel::ERROR, rule_id_,
                                               rule_name_, "DistInterval", msg,
                                               alarm_time_range);
            }
          } else {
            if (o_value.value()[0] < this->dist_left_ ||
                o_value.value()[0] > this->dist_right_) {
              // 报警
              auto alarm_time_range = query_time_range_;
              alarm_time_range.set_left(alarm_time_range.get_right() -
                                        this->delay_time_);
              auto msg = rule_name_ + " " + error_str_ + " 当前值为" +
                         std::to_string(o_value.value()[0]) + " 3σ区间为[" +
                         std::to_string(this->dist_left_) + "," +
                         std::to_string(this->dist_right_) + "]";
              return utility::build_alarm_info(MsgLevel::ERROR, rule_id_,
                                               rule_name_, "DistInterval", msg,
                                               alarm_time_range);
            }
          }
        }  // if (o_value.has_value())
        break;
      }
      default:
        break;
    }  // switch (data_source_) {
  }    // if (this->get_is_to_detect()) {
  return {};
}
bool DistInterval::get_is_to_detect() {
  if (this->interval_source_) {
    T_RULE_DIST_INTERVAL trdi;
    // 查询 ruleid 是否存在
    auto info_maybe = exec<db2_t, T_RULE_DIST_INTERVAL>(
        select(trdi.dist_left(), trdi.dist_right())
            .from(trdi)
            .where(trdi.ruleId() == this->rule_id_));
    // 如果存在
    if (info_maybe.is_just()) {
      auto& info = info_maybe.unsafe_get_just();
      if (!info.empty()) {
        this->dist_left_ = info[0].dist_left;
        this->dist_right_ = info[0].dist_right;
        return true;
      } else {
        return false;
      }
    } else {
      gb_logger_->log_info("db2查询失败" + rule_name_);
      return false;
    }
  } else {
    auto lr = this->intervalToDouble(this->dist_interval_input_);
    if (lr.empty()) {
      gb_logger_->log_info("区间读取或转换错误" + rule_name_);
      return false;
    } else {
      this->dist_left_ = lr[0];
      this->dist_right_ = lr[1];
      return true;
    }
  }
}

int DistInterval::update_show_interval() {
  if (this->is_to_detect_) {
    std::string msg = "[" + std::to_string(this->dist_left_) + "," +
                      std::to_string(this->dist_right_) + "]";
    T_RULE_CFG trc;
    auto update_rusult =
        exec<db2_t, size_t>(update(trc)
                                .set(trc.remark() = msg)
                                .where(trc.ruleId() == this->rule_id_));

    if (update_rusult.is_nothing()) {
      gb_logger_->log_info("区间显示 更新失败:" + rule_name_);
      return -1;
    }
    return 1;
  } else {
    return -1;
  }
}

AlarmInfo DistInterval::exec_normal_task(mix_cc::time_range_t time_range) {
  gb_logger_->log_info("exec_normal_task:" + rule_name_);
  gb_logger_->log_info(
      "开始时间:" +
      mix_cc::mix_time_t(time_range.get_left()).to_formatted_time());
  gb_logger_->log_info(
      "结束时间:" +
      mix_cc::mix_time_t(time_range.get_right()).to_formatted_time());
  SampleWindow tmp_data;

  //刷一遍mmvar
  TimeDur f_delay_time = 5 * delay_time_;
  auto time_end = time_range.get_right();
  auto time_start = time_range.get_left();
  query_interval_time_ = std::chrono::duration_cast<std::chrono::milliseconds>(
      time_end - time_start);
  this->query_time_range_.set_left(time_start - 2 * f_delay_time);
  this->query_time_range_.set_right(time_start - f_delay_time);

  // 目的在于刷pv变量 query_interval_time_   start       end
  this->now_time_ = time_start;
  refresh_ihd_cache(this->delay_time_);  //刷 queried_time_,query_time_range_
  {
    gb_logger_->log_info(
        "ihd查询开始时间1:" +
        mix_cc::mix_time_t(query_time_range_.get_left()).to_formatted_time());
    gb_logger_->log_info(
        "ihd查询结束时间1:" +
        mix_cc::mix_time_t(query_time_range_.get_right()).to_formatted_time());
    gb_logger_->log_info("ihd查询的时间间隔:" +
                         std::to_string(delay_time_.count()));
    gb_logger_->log_info("ihd查询的数据量:" +
                         std::to_string(queried_data_.rows()));
  }
  for (auto i = 0; i < queried_data_.rows(); i++) {
    refresh_exp_vars_ihd(i);
  }                            // 刷 mmvar
  this->now_time_ = time_end;  // 防止出问题，没有实际用处

  refresh_ihd_cache(this->delay_time_);  //
  {                                      // 日志
    gb_logger_->log_info(
        "ihd查询开始时间2:" +
        mix_cc::mix_time_t(query_time_range_.get_left()).to_formatted_time());
    gb_logger_->log_info(
        "ihd查询结束时间2:" +
        mix_cc::mix_time_t(query_time_range_.get_right()).to_formatted_time());
    gb_logger_->log_info("ihd查询的时间间隔:" +
                         std::to_string(delay_time_.count()));
    gb_logger_->log_info("ihd查询的数据量:" +
                         std::to_string(queried_data_.rows()));
  }
  try {
    for (auto i = 0; i < queried_data_.rows(); i++) {
      refresh_exp_vars_ihd(i);
      // gb_logger_->log_info("开始运行：this->cron_proc_sample()");
      auto o_value = this->cron_proc_sample();  ///< 数据筛选
      // gb_logger_->log_info("运行结束：this->cron_proc_sample()");
      if (o_value.has_value()) {
        tmp_data.push_back(o_value.value());  ///< 筛选后的数据
      }
    }
  } catch (...) {
    gb_logger_->log_info(this->rule_name_ + ":cron_proc_sample()运行失败");
  }
  // gb_logger_->log_info("运行结束：this->cron_proc_sample()");
  // gb_logger_->log_info("this->test_mode_:"+to_string(static_cast<int>(this->test_mode_)
  // ));

  StatAlarm alarm_info;
  try {
    // gb_logger_->log_info(" try {");
    alarm_info = this->sample_stat_->get_task_normal_info(tmp_data);
    //保存至本地 方便分析
    {
      //写文件
      ofstream outFile;
      string dir = "/users/dsc/download_csv/";
      // TimePoint now_time_to_write = std::chrono::system_clock::now();
      outFile.open(
          dir + rule_name_ +
              "data.csv",
          ios::out);
      outFile << "time" << endl;
      int i = 0;
      while (i < tmp_data.size()) {
        outFile << tmp_data[i++][0] << endl;
      }
    }


  } catch (...) {
    logger_->Error() << "get_task_normal_info执行错误: " << this->rule_name_
                     << std::endl;
  }
  if (alarm_info) {
    gb_logger_->log_info("exec_normal_task:" + rule_name_ +
                         alarm_info.alarm_str);
    auto dist_param = this->sample_stat_->get_dist_param();
    if (dist_param[2][0] != 0) {
      // 方差不为零，存数据库
      if (this->test_mode_ == stat_tools::TestMode::normal_dist_diff) {
        this->dist_left_ = dist_param[0][0] - 3 * dist_param[2][0];
        this->dist_right_ = dist_param[0][0] + 3 * dist_param[2][0];
      } else if (this->test_mode_ == stat_tools::TestMode::abs_diff) {
        this->dist_left_ = dist_param[0][0] - this->judge_diff_;
        this->dist_right_ = dist_param[0][0] + this->judge_diff_;
      } else if (this->test_mode_ == stat_tools::TestMode::percent_diff) {
        auto abs_m = std::abs(dist_param[0][0]);
        this->judge_diff_ = std::abs(this->judge_diff_);
        while (this->judge_diff_ > 1) {
          this->judge_diff_ * 0.1;
        }
        this->dist_left_ = dist_param[0][0] - abs_m * this->judge_diff_;
        this->dist_right_ = dist_param[0][0] + abs_m * this->judge_diff_;
      }
      // dist_param = {samples_mean, samples_variance, samples_stddev,
      // samples_max,
      //   samples_min,  samples_skewness, samples_kurtosis}
      T_RULE_DIST_INTERVAL trdi;
      // 更新表
      fplus::maybe<std::size_t> update_info_ret =
          mix_cc::fp::nothing<std::size_t>();
      // 插入
      fplus::maybe<std::size_t> approx_info_ret =
          mix_cc::fp::nothing<std::size_t>();
      // 查询 ruleid 是否存在
      auto info_maybe = exec<db2_t, T_RULE_DIST_INTERVAL>(
          select(trdi.train_end_time())
              .from(trdi)
              .where(trdi.ruleId() == this->rule_id_));

      if (info_maybe.is_just()) {
        auto& info = info_maybe.unsafe_get_just();
        if (!info.empty()) {
          update_info_ret = exec<db2_t, size_t>(
              update(trdi)
                  .set(trdi.dist_mean() = dist_param[0][0],
                       trdi.update_time() =
                           mix_cc::mix_time_t(system_clock::now()),
                       trdi.train_start_time() =
                           mix_cc::mix_time_t(time_range.get_left()),
                       trdi.train_end_time() =
                           mix_cc::mix_time_t(time_range.get_right()),
                       trdi.dist_variance() = dist_param[1][0],
                       trdi.dist_stddev() = dist_param[2][0],
                       trdi.dist_skewness() = dist_param[5][0],
                       trdi.dist_kurtosis() = dist_param[6][0],
                       trdi.dist_left() = this->dist_left_,
                       trdi.dist_right() = this->dist_right_)
                  .where(trdi.ruleId() == this->rule_id_));
          if (update_info_ret.is_nothing()) {
            gb_logger_->log_info("trdi表更新失败:" + rule_name_);
            DEBUG_PRINT_MIX_CC("统计特征表信息数据更新异常");
            return {};
          }
          // 不存在 insert
        } else {
          // 如果没有当前 ruleid的range，就插入
          approx_info_ret = exec<db2_t, size_t>(insert_into(trdi).set(
              trdi.ruleId() = this->rule_id_,
              trdi.update_time() = mix_cc::mix_time_t(system_clock::now()),
              trdi.train_start_time() =
                  mix_cc::mix_time_t(time_range.get_left()),
              trdi.train_end_time() =
                  mix_cc::mix_time_t(time_range.get_right()),
              trdi.dist_mean() = dist_param[0][0],
              trdi.dist_variance() = dist_param[1][0],
              trdi.dist_stddev() = dist_param[2][0],
              trdi.dist_skewness() = dist_param[5][0],
              trdi.dist_kurtosis() = dist_param[6][0],
              trdi.dist_left() = this->dist_left_,
              trdi.dist_right() = this->dist_right_));
          if (approx_info_ret.is_nothing()) {
            gb_logger_->log_info("trdi表插入失败:" + rule_name_);
            DEBUG_PRINT_MIX_CC("INFO信息数据插入异常");
            return {};
          }
        }

      } else {
        gb_logger_->log_info("trdi表查询失败:" + rule_name_);
        return {};
      }
      gb_logger_->log_info("task" + rule_name_ + "准备创建info信息报警");
      query_time_range_.set_left(std::chrono::system_clock::now());
      query_time_range_.set_right(query_time_range_.get_left() +
                                  this->delay_time_);
      return utility::build_alarm_info(MsgLevel::INFO, rule_id_, rule_name_,
                                       "EXPSMP", alarm_info.alarm_str,
                                       query_time_range_);
    } else {
      query_time_range_.set_left(std::chrono::system_clock::now());
      query_time_range_.set_right(query_time_range_.get_left() +
                                  this->delay_time_);
      return utility::build_alarm_info(MsgLevel::ERROR, rule_id_, rule_name_,
                                       "EXPSMP", alarm_info.alarm_str,
                                       query_time_range_);
    }

  }  // info
  else {
    gb_logger_->log_info(" alarm_info.alarm_str获取失败:" + rule_name_);
    return {};
  }
}

/**
 * @brief interval To double
 */
vector<double> DistInterval::intervalToDouble(string& str) {
  if (*str.begin() == '[') {
    str.erase(str.begin());
  }
  if (*(str.end() - 1) == ']') {
    str.erase(str.end() - 1);
  }
  for (size_t i = 0; i < str.size(); i++) {
    if (str[i] == ' ') {
      str.erase(str.begin() + i);
    }
  }
  string::iterator itr;
  for (itr = str.begin(); *itr != ','; itr++) {
  }
  string str1(str.begin(), itr);
  string str2(itr + 1, str.end());
  istringstream iss1(str1);
  double num1;
  iss1 >> num1;
  istringstream iss2(str2);
  double num2;
  iss2 >> num2;
  return {num1, num2};
}