#include <eqpalg/stat_tools/frame.h>
#include <eqpalg/define/public.h>
extern ProcessType glob_process_type;  ///< 区分3个进程，主要是mon与cron
namespace stat_tools {

Frame::Frame(std::string ruleId, std::string rule_name, size_t dims,
             TestMode test_mode, TimePoint time_begin, TimePoint time_end,
             double padding_low, double padding_up, bool no_down_limit)
    : gb_logger_(std::string("stat_tools::frame:") + ruleId),
      rule_id_(ruleId),
      rule_name_(rule_name),
      dims_(dims),
      test_mode_(test_mode),
      data_frame_(ruleId, dims),
      dist_frame_(ruleId, dims),
      regression_frame_(ruleId, dims),
      padding_low_(padding_low),
      padding_up_(padding_up) {
  this->legal_range_.resize(dims);
  //  初始化基本判定条件
  this->time_begin_ = time_begin;
  this->time_end_ = time_end;
  this->no_down_limit_ = no_down_limit;
  // //
  // gb_logger_.log_info(
  //               string("兰超 no_down_limit == ") +
  //               std::to_string(no_down_limit_) );
}

int Frame::set_archive_interval(std::chrono::system_clock::duration interval) {
  // 设置保存周期
  this->archive_interval_ = interval;
  return 0;
}

int Frame::set_prob(double p) {
  // 设置置信区间/偏差值/概率
  if (p <= 0) {
    // 该数值不能小于等于0
    throw(mix_cc::Exception(-1, "sample stat_tools prob is zero or neg",
                            BOOST_CURRENT_LOCATION));
  }
  this->p_ = p;
  return 0;
}

/**
 * @brief 加载数据：1.db2的统计数据；2.本地文件的特征数据
 * abs_diff: 使用本地文件的 均值 得到合法区间
 * percent_diff：使用本地文件的 均值 得到合法区间
 * cron的调用目的为查看db2是否有info信息：ApproximateData::load()
 * @return int
 */
int Frame::load_data() {
  try {
    //  载入数据
    //  判定数据模式
    auto test_mode = static_cast<TestMode>(test_mode_);
    switch (test_mode) {
      // 绝对值差值
      case TestMode::abs_diff: {
        // 如果db2已存在步长信息 载入数据 ①步长c_r_ ②分布数据data_
        // ③解压缩之后的数据量dump_size_ ④scale_
        // 同时将is_first_sampling的值置为false 获取 数据特征值 running_stats
        this->data_frame_.load();
        // 如果不是第一次采样，即算法中已经含有样本
        if (glob_process_type == ProcessType::kMon &&
            (!this->data_frame_.is_first_sampling())) {
          auto running_stats = data_frame_.get_running_stats();
          for (size_t i = 0; i < running_stats.size(); i++) {
            // 得到均值
            auto mean = running_stats[i].mean();
            // 根据均值计算
            legal_range_[i] = mix_cc::float_range_t(mean - p_, mean + p_);
            // 设置标记，运行执行 小于50个样本不诊断
            if (running_stats[0].current_n() > 50) {
              is_ready_to_detect_ = true;
            } else {
              this->gb_logger_.log_info(this->rule_id_ +
                                        "累积的样本不足50个，不进行诊断");
            }

            // 打印信息
            gb_logger_.log_info(
                string("index:") + std::to_string(i) + ":" +
                std::string("绝对差,合法区间为:[") +
                std::to_string(legal_range_[i].get_left()) + "," +
                std::to_string(legal_range_[i].get_right()) + "]");
          }
        }
      } break;

      case TestMode::percent_diff: {
        // 百分比差值 同上
        this->data_frame_.load();
        if (glob_process_type == ProcessType::kMon &&
            (!this->data_frame_.is_first_sampling())) {
          auto running_stats = data_frame_.get_running_stats();
          for (size_t i = 0; i < running_stats.size(); i++) {
            auto mean = running_stats[i].mean();
            double abs_value = 0.01;  ///< mean==0的情况
            if (mean) {
              abs_value = std::abs(mean) * this->p_;  ///< 百分比的差值
            }
            legal_range_[i] =
                mix_cc::float_range_t(mean - abs_value, mean + abs_value);
            if (running_stats[0].current_n() > 50) {
              is_ready_to_detect_ = true;
            } else {
              this->gb_logger_.log_info(this->rule_id_ +
                                        "累积的样本不足50个，不进行诊断");
            }
            gb_logger_.log_info(
                string("index:") + std::to_string(i) + ":" +
                std::string("百分比,合法区间为:[") +
                std::to_string(legal_range_[i].get_left()) + "," +
                std::to_string(legal_range_[i].get_right()) + "]");
          }
        }
      } break;

      case TestMode::normal_dist_diff: {
        // 正态置信，同上
        this->data_frame_.load();
        if (glob_process_type == ProcessType::kMon &&
            (!this->data_frame_.is_first_sampling())) {
          auto extracted_data =
              data_frame_.get_extracted_data();  ///< 解压出db2的数据分布信息
          auto running_stats =
              data_frame_.get_running_stats();  ///< 读取本地文件的数据特征
          // 自动检测数据分布类型，内置正态分布、偏态分布、t分布
          // 计算置信区间
          this->dist_frame_.auto_detect_distribution(running_stats,
                                                     extracted_data);
          if (this->dist_frame_.is_distribution_valid()) {
            legal_range_ = this->dist_frame_.get_range();
            if (running_stats[0].current_n() > 100) {
              is_ready_to_detect_ = true;
            } else {
              this->gb_logger_.log_info(this->rule_id_ +
                                        "累积的样本不足100个，不进行诊断");
            }
            for (size_t i = 0; i < dims_; i++) {
              gb_logger_.log_info(
                  string("index:") + std::to_string(i) + ":" +
                  std::string("正态分布,合法区间为:[") +
                  std::to_string(legal_range_[i].get_left()) + "," +
                  std::to_string(legal_range_[i].get_right()) + "]");
            }
          }
        }
      } break;
      // case TestMode::degrad: {
      //   this->data_frame_2_.load();

      // } break;
      case TestMode::regression: {
        this->data_frame_.load();
        if (glob_process_type == ProcessType::kMon &&
            (!this->data_frame_.is_first_sampling())) {
          // 获得数据
          auto extracted_data = data_frame_.get_extracted_data();
          // 根据数据拟合多项式
          regression_frame_.load(extracted_data);
          if (regression_frame_.valid()) {
            // 如果数据可用，则有效
            is_ready_to_detect_ = true;
          } else {
            is_ready_to_detect_ = false;
          }
        }
      } break;
      // case TestMode::oneClassSvm: {
      //   this->data_frame_.load();
      //   if (!this->data_frame_.is_first_sampling()) {
      //     // 获得数据
      //     auto extracted_data = data_frame_.get_extracted_data();
      //     // 根据数据拟合多项式
      //     // oneClassSvm_frame_.load(extracted_data);
      //     if (oneClassSvm_frame_.valid()) {
      //       // 如果数据可用，则有效
      //       is_ready_to_detect_ = true;
      //     } else {
      //       is_ready_to_detect_ = false;
      //     }
      //   }
      // } break;
      default:
        break;
    }
    // 检验范围是否有效
    if (glob_process_type == ProcessType::kMon) {
      for (auto& legal_rang_item : legal_range_) {
        if (!legal_rang_item.valid()) {
          this->is_ready_to_detect_ = false;
          this->gb_logger_.log_info(this->rule_id_ + "区间无效，不进行诊断");

          // } else {
          //   legal_rang_item.set_left(legal_rang_item.get_left() -
          //   padding_low_);
          //   legal_rang_item.set_right(legal_rang_item.get_right() +
          //   padding_up_);
        }
      }

      // 结束
      // 如果不设置下范围（即针对 设定-实际-偏差值 类型的算法实例）
      if (this->no_down_limit_) {
        for (size_t i = 0; i < dims_; i++) {
          // 把每个维度的下范围更改为double的最小值
          legal_range_[i].set_left(std::numeric_limits<double>::min());
        }
      }
    }
    // debug
    // if(rule_name_=="一氧化碳报警分析")
    // {
    //   int i =1;
    // }
    // is_data_loaded_ = true;
  } catch (const std::exception& e) {
    std::throw_with_nested(
        mix_cc::Exception(-1, "stat tools load error", BOOST_CURRENT_LOCATION));
  }
  return 0;
}

/**
 * @brief 把数据持久化保存
 * @return int
 */
int Frame::commit() {
  try {
    // 如果数据达到提交条件，则把数据变更保存到数据库中
    this->data_frame_.commit();
    // gb_logger_.log_info("提交执行完成");

  } catch (const std::exception& e) {
    gb_logger_.log_error(std::string("样本保存异常\n") + e.what());
  }

  return 0;
}

/**
 * @brief 处理cron经过筛选后的数据
 * 1.检查db2是否有info信息，没有则检查rs样本是否超过100个，超过就计算并插入info信息
 * 2.检查样本方差是否为零，累积rs；为零则抛弃该次数据
 * 3.db2若有info信息，则想db2插入样本，同时累积rs
 * @param  input_data       My Param doc
 * @param  tp               My Param doc
 * @return true
 * @return false
 */
bool Frame::cron_sampling_data(const SampleWindow& input_data, TimePoint tp) {
  // if (this->test_mode_ >= TestMode::normal_dist_diff) {
  this->load_data();  ///< 检测db2中是否有步长信息；检测本地文件（~/stat_data）是否有当前算法

  if (!input_data.empty()) {
    //没有info的情况
    if (!this->data_frame_.look_have_info()) {
      auto reSult = this->data_frame_.first_sampling_bath(input_data, tp);
      if (reSult == -1) return false;
    }
    //有info的情况
    else {
      auto num_data = input_data.size();
      for (size_t i = 0; i < num_data; i++) {
        this->data_frame_.store(input_data[i]);
        this->commit();
      }
    }
  }
  return true;
  // }
  // return false;
}

/**
 * @brief 是否是第一次采样
 * @tparam dims_
 * @return true
 * @return false
 */
bool Frame::is_first_sampling() {
  return this->data_frame_.is_first_sampling();
}

/**
 * @brief 保存报警
 * @tparam dims_
 * @param  sample           My Param doc
 * @param  time_stamp       My Param doc
 * @return int
 */

int Frame::save_alarm(SamplePoint sample, TimePoint time_stamp) {
  if (time_stamp - last_alarm_time_ < minutes(5)) {
    return 0;
  }
  last_alarm_time_ = time_stamp;  // 2021-10-27
  // auto task_ret = std::async([this, &sample, &time_stamp]() {
  this->save_alarm_impl(sample, time_stamp);
  // });
  return 0;
}

/**
 * @brief 存储数据到到内存临时表中
 * @tparam dims_
 * @param  sample           My Param doc
 * @param  time_stamp       My Param doc
 * @return int
 */

int Frame::store_data(SamplePoint sample, TimePoint time_stamp) {
  // for
  this->tmp_store_time_ = time_stamp;
  this->data_frame_.store(sample);
  if (this->ready_to_commit()) {
    this->commit();
  }
  return 0;
}

/**
 * @brief 检测报警
 * @tparam dims_
 * @param  sample           My Param doc
 * @param  time_stamp       My Param doc
 * @return StatAlarm
 */

StatAlarm Frame::auto_detect_and_save(SamplePoint sample,
                                      TimePoint time_stamp) {
  // this->store_data(sample, time_stamp);  ///<保存样本
  if (this->is_ready_to_detect_) {
    return is_alarmed_impl(sample);  ///<报警检测
  }
  return {};
}

/**
 * @brief 保存报警的数据到异常数据表中
 * @param  sample_test      My Param doc
 * @param  time_stamp       My Param doc
 * @return int
 */

int Frame::save_alarm_impl(SamplePoint sample_test, TimePoint time_stamp) {
  // T_RULE_SAMPLE_1D_RAW dim1;
  // auto count = mix_cc::sql::exec<db2_t,size_t>(insert_into(dim1).set(
  //     dim1.ruleId() = this->rule_id_,
  //     dim1.lastUpdate() = mix_cc::mix_time_t(tmp_store_time_),
  //     dim1.x1() = sample_test[0], dim1.flag() = 2));
  // if (count != 1) {
  //   throw(mix_cc::Exception(-10, "alarm save error",
  //   BOOST_CURRENT_LOCATION));
  // }
  return 0;
}

/**
 * @brief 检测数据是否应该被保存
 * @return true
 * @return false
 */

bool Frame::ready_to_commit() {
  if (is_first_save_) {
    is_first_save_ = false;
    last_save_time_ = this->tmp_store_time_;
  }
  if (this->tmp_store_time_ - last_save_time_ > this->archive_interval_) {
    last_save_time_ = this->tmp_store_time_;
    return true;
  }
  return false;
}

/**
 * @brief 检查数据是否发生报警
 * @param  sample           My Param doc
 * @return StatAlarm
 */

StatAlarm Frame::is_alarmed_impl(SamplePoint sample) {
  StatAlarm stat_alarm;
  switch (static_cast<TestMode>(test_mode_)) {
    case TestMode::abs_diff:
      stat_alarm = absolute_diff_alarm(sample);
      break;
    case TestMode::percent_diff:
      stat_alarm = percentage_diff_alarm(sample);
      break;
    case TestMode::normal_dist_diff:
      stat_alarm = normal_dist_diff_alarm(sample);
      break;
    // case TestMode::degrad:
    //   stat_alarm = degrad_diff_alarm_special();
    //   break;
    case TestMode::regression:
      stat_alarm = regression_diff_alarm(sample);
      break;
    // case TestMode::oneClassSvm:
    //   stat_alarm = one_class_svm_diff_alarm(sample);
    //   break;
    default:
      return StatAlarm{};
      break;
  }
  return stat_alarm;
}

/**
 * @brief 绝对差
 * @param  x                My Param doc
 * @return StatAlarm
 */

StatAlarm Frame::absolute_diff_alarm(SamplePoint sample_test) {
  std::ostringstream oss;
  StatAlarm stat_alarm;
  for (size_t i = 0; i < dims_; i++) {
    bool this_alarmed = !mix_cc::is_in_range(legal_range_[i], sample_test[i]);
    if (this_alarmed) {
      stat_alarm.alarmed = true;
      stat_alarm.value.push_back(sample_test[i]);
      stat_alarm.range.push_back(legal_range_[i]);
      auto rs = data_frame_.get_running_stats()[i];
      oss << " 报警触发 实际值: " << sample_test[i] << " 绝对误差:" << p_
          << " 基准值:" << rs.mean() << " 区间:[" << legal_range_[i].get_left()
          << "," << legal_range_[i].get_right() << "]";
    }
  }
  stat_alarm.alarm_str = oss.str();
  return stat_alarm;
}

/**
 * @brief 百分比
 * @param  x                My Param doc
 * @return StatAlarm
 */

StatAlarm Frame::percentage_diff_alarm(SamplePoint sample_test) {
  std::ostringstream oss;
  StatAlarm stat_alarm;
  for (size_t i = 0; i < dims_; i++) {
    bool this_alarmed = !mix_cc::is_in_range(legal_range_[i], sample_test[i]);
    if (this_alarmed) {
      stat_alarm.alarmed = true;
      stat_alarm.value.push_back(sample_test[i]);
      stat_alarm.range.push_back(legal_range_[i]);
      auto rs = data_frame_.get_running_stats()[i];
      oss << " 报警触发 实际值: " << sample_test[i] << " 百分比误差:" << p_
          << " 基准值:" << rs.mean() << " 区间:[" << legal_range_[i].get_left()
          << "," << legal_range_[i].get_right() << "]";
    }
  }
  stat_alarm.alarm_str = oss.str();
  return stat_alarm;
}

/**
 * @brief 正态分布
 * @param  x                My Param doc
 * @return StatAlarm
 */

StatAlarm Frame::normal_dist_diff_alarm(SamplePoint sample_test) {
  std::ostringstream oss;
  StatAlarm stat_alarm;
  for (size_t i = 0; i < dims_; i++) {
    bool this_alarmed = !mix_cc::is_in_range(legal_range_[i], sample_test[i]);
    if (this_alarmed) {
      stat_alarm.alarmed = true;
      stat_alarm.value.push_back(sample_test[i]);
      stat_alarm.range.push_back(legal_range_[i]);
      auto rs = data_frame_.get_running_stats()[i];
      oss << " 报警触发 实际值: " << sample_test[i] << " 置信概率:" << p_
          << " 平均值:" << rs.mean() << " 标准差:" << rs.stddev()
          << " 置信区间:[" << legal_range_[i].get_left() << ","
          << legal_range_[i].get_right() << "]";
    }
  }
  stat_alarm.alarm_str = oss.str();
  return stat_alarm;
}
StatAlarm Frame::get_task_normal_info(SampleWindow samples) {
  // gb_logger_.log_info(
  //     "开始执行：StatAlarm Frame::get_task_normal_info(SampleWindow
  //     samples)");
  std::ostringstream oss;
  StatAlarm stat_alarm;
  // gb_logger_.log_info("开始执行：this->data_frame_.put_data_to_rs(samples);");
  this->data_frame_.put_data_to_rs(samples);
  // gb_logger_.log_info("执行结束：this->data_frame_.put_data_to_rs(samples);");
  auto samples_mean = this->data_frame_.get_rs_means();
  auto samples_variance = this->data_frame_.get_rs_variances();
  auto samples_stddev = this->data_frame_.get_rs_stddev();
  auto samples_max = this->data_frame_.get_rs_max();
  auto samples_min = this->data_frame_.get_rs_min();
  auto samples_kurtosis = this->data_frame_.get_rs_kurtosis();
  auto samples_skewness = this->data_frame_.get_rs_skewness();
  std::vector<std::vector<double>> param_dist{
      samples_mean, samples_variance, samples_stddev,  samples_max,
      samples_min,  samples_skewness, samples_kurtosis};
  this->dist_param_ = param_dist;
  for (size_t i = 0; i < dims_; i++) {
    stat_alarm.alarmed = true;
    auto rs = data_frame_.get_running_stats()[i];
    oss << "统计的样本数量：" << samples.size()
        << " 统计均值: " << samples_mean[i] << " 方差:" << samples_variance[i]
        << " 标准差：" << samples_stddev[i] << " 数值范围：[" << samples_min[i]
        << "," << samples_max[i] << "] 偏度：" << samples_skewness[i]
        << " 峰度：" << samples_kurtosis[i] << " 置信区间:["
        << samples_mean[i] - 3 * samples_stddev[i] << ","
        << samples_mean[i] + 3 * samples_stddev[i] << "]";
  }
  stat_alarm.alarm_str = oss.str();
  return stat_alarm;
}

/**
 * @brief 回归检验
 * @param  sample_test      My Param doc
 * @return StatAlarm
 */

StatAlarm Frame::regression_diff_alarm(SamplePoint sample_test) {
  StatAlarm stat_alarm;
  double predict_val = regression_frame_.predict(sample_test);
  mix_cc::float_range_t legal_range;
  // 测试值
  if (predict_val > 0) {
    legal_range =
        mix_cc::range_t(predict_val * (1 - p_), predict_val * (1 + p_));

  } else if (predict_val < 0) {
    legal_range =
        mix_cc::range_t(predict_val * (1 + p_), predict_val * (1 - p_));
  } else {
    legal_range = mix_cc::range_t(-5 * p_, 5 * p_);
  }
  if (dims_ == 2) {
    if (!mix_cc::is_in_range(legal_range, sample_test[1])) {
      std::ostringstream oss;
      stat_alarm.range.push_back(legal_range);
      stat_alarm.value.push_back(sample_test[1]);
      oss << " 数值拟合异常,输入值x:" << sample_test[0]
          << " 预测值y:" << predict_val << " 实际值y:" << sample_test[1]
          << " 理想区间[" << legal_range.get_left() << ","
          << legal_range.get_right() << "]" << std::endl;
      stat_alarm.alarmed = true;
      stat_alarm.alarm_str = oss.str();
    }
  } else if (dims_ == 3) {
    if (!mix_cc::is_in_range(legal_range, sample_test[2])) {
      std::ostringstream oss;
      stat_alarm.range.push_back(legal_range);
      stat_alarm.value.push_back(sample_test[2]);
      oss << " 数值拟合异常,输入值x1:" << sample_test[0]
          << ",输入值x2:" << sample_test[1] << " 预测值y:" << predict_val
          << " 实际值y:" << sample_test[2] << " 理想区间["
          << legal_range.get_left() << "," << legal_range.get_right() << "]"
          << std::endl;
      stat_alarm.alarmed = true;
      stat_alarm.alarm_str = oss.str();
    }
  }
  return stat_alarm;
}

//  StatAlarm Frame::degrad_diff_alarm_special() {
//   StatAlarm stat_alarm;
//   auto data = this->data_frame_2_.get_extracted_data();
//   if (last_alarm_time_ != data.rbegin()->second.sample_date) {
//     if (data.size() > 2) {
//       last_alarm_time_ = data.rbegin()->second.sample_date;
//       auto p1 = *data.rbegin();
//       auto p2 = *(data.rbegin()++);
//       if (std::abs((p1.second.avg - p2.second.avg) / p2.second.avg) > p_) {
//         std::ostringstream oss;
//         oss << "设备劣化情况异常，可能出现了劣化" << std::endl;
//         stat_alarm.alarmed = true;
//         stat_alarm.alarm_str = oss.str();
//       }
//     }
//   }
//   return stat_alarm;
// }

/**
 * @brief oneClassSvm
 */

// StatAlarm Frame::one_class_svm_diff_alarm(SamplePoint sample_test) {
//   StatAlarm svm_alarm;
//   // 如果没有满足检测条件，则返回
//   if (!this->is_ready_to_detect_) {
//     return svm_alarm;
//   }

//   double predict_val = oneClassSvm_frame_.predict(sample_test);

//   if (dims_ == 2) {
//     if (predict_val < oneClassSvm_frame_.standard_error) {
//       std::ostringstream oss;
//       oss << " one class svm 判断数值异常,点(x,y)=(" << sample_test[0] << "
//       ,"
//           << sample_test[1] << ")的svm结果为" << predict_val
//           << " ,小于设定的允许最小值 " << oneClassSvm_frame_.standard_error
//           << std::endl;
//       svm_alarm.alarmed = true;
//       svm_alarm.alarm_str = oss.str();
//     }
//   } else if (dims_ == 3) {
//     if (predict_val < oneClassSvm_frame_.standard_error) {
//       std::ostringstream oss;
//       oss << " one class svm 判断数值异常,点(x,y,z)=(" << sample_test[0] << "
//       ,"
//           << sample_test[1] << " ," << sample_test[2] << ")的svm结果为"
//           << predict_val << " ,小于设定的允许最小值 "
//           << oneClassSvm_frame_.standard_error << std::endl;
//       svm_alarm.alarmed = true;
//       svm_alarm.alarm_str = oss.str();
//     }
//   }

//   return svm_alarm;
// }

}  // namespace stat_tools