#include <eqpalg/data_handler/approximate_data.h>
// 预定义 首次采样的样本容量最小值
#define CAL_STEP_MIN_SIZE 100
namespace data_handler {
  namespace policy {
    /**
     * @brief Construct a new Approximate Data object
     * @param  ruleId           My Param doc
     */

    ApproximateData::ApproximateData(const std::string& ruleId, size_t dims)
      : Base(ruleId, dims), gb_logger_(std::make_unique<GbLogger>(ruleId)) {
      c_r_.resize(dims);
      rs_.resize(dims);
    }

    /**
     * @brief 向T_RULE_SAMPLE_1D_INFO插入步长信息
     * 检查数据量：小样本的不计算步长
     * 规定样本数量大于100计算样本
     * 如果info插入，则保存本次样本first_runing_info至db2
     * @param  first_runing_infoMy Param doc
     * @param  tp               My Param doc
     * @return int
     */
    int ApproximateData::first_sampling_batch(const InData& first_runing_info,
      TimePoint tp, Rs running_state) {
      if (first_runing_info.empty() ||
        running_state[0].current_n() <= CAL_STEP_MIN_SIZE) {
        if (running_state[0].current_n() <= CAL_STEP_MIN_SIZE) {
          this->gb_logger_->log_error(this->rule_id_ + ":已累积的样本数量：" +
            std::to_string(running_state[0].current_n()) +
            "<" + std::to_string(CAL_STEP_MIN_SIZE) +
            ",不更新T_RULE_SAMPLE_1D_INFO");
        }
        return -1;
      }
      this->rs_ = running_state;
      // 组距 组数的确定
      for (size_t i = 0; i < rs_.size(); i++) {
        auto cell_range = (rs_[i].max() - rs_[i].min()) / 50;
        // if (cell_range > 100) {
        //   cell_range = 100;
        // } else if (cell_range > 10) {
        //   cell_range = 10;
        // } else if (cell_range > 1) {
        //   cell_range = 1;
        // } else if (cell_range > 0.1) {
        //   cell_range = 0.1;
        // } else {
        //   cell_range = 0.01;
        // }
        if (cell_range > 0.001) {
          c_r_[i] = cell_range;
        }
        else {
          this->gb_logger_->log_error(this->rule_id_ +
            "当前rs=" + std::to_string(cell_range) +
            " 过小！info将被置为0.001");
          c_r_[i] = 0.001;
        }
      }

      // 插入
      fplus::maybe<std::size_t> approx_info_ret =
        mix_cc::fp::nothing<std::size_t>();
      //更新
      fplus::maybe<std::size_t> update_info_ret =
        mix_cc::fp::nothing<std::size_t>();
      if (dims_ == 1) {
        // update info
        T_RULE_SAMPLE_1D_INFO tci;
        // 查当前ruleid 是否已经存在
        auto info_maybe = exec<db2_t, T_RULE_SAMPLE_1D_INFO>(
          select(tci.Range1())
          .from(tci)
          .where(tci.RuleId() == this->rule_id_));
        if (info_maybe.is_just()) {
          auto& info = info_maybe.unsafe_get_just();
          if (!info.empty()) {
            // cellrange变化了就更新
            if (c_r_[0] != info[0].Range1)
              // update 数据库的数据
            {
              update_info_ret =
                exec<db2_t, size_t>(update(tci)
                  .set(tci.Range1() = c_r_[0])
                  .where(tci.RuleId() == this->rule_id_));
              if (update_info_ret.is_nothing()) {
                DEBUG_PRINT_MIX_CC("INFO信息数据更新异常");
                return -1;
              }
            }

          }
          else {
            // 如果没有当前 ruleid的range，就插入
            approx_info_ret = exec<db2_t, size_t>(insert_into(tci).set(
              tci.RuleId() = rule_id_, tci.Range1() = c_r_[0], tci.Spare1() = 1));
            if (approx_info_ret.is_nothing()) {
              DEBUG_PRINT_MIX_CC("INFO信息数据插入异常");
              return -1;
            }
            if (approx_info_ret.unsafe_get_just() == 0) {
              DEBUG_PRINT_MIX_CC("插入数据量异常");
              return -2;
            }
          }
        }
        else {
          return -1;
        }
        // } else {

        // }

      }
      else if (dims_ == 2) {
        T_RULE_SAMPLE_2D_INFO tci;

        // 查询当前ruleid 是否已经存在
        auto info_maybe = exec<db2_t, T_RULE_SAMPLE_2D_INFO>(
          select(tci.Range1(), tci.Range2())
          .from(tci)
          .where(tci.RuleId() == this->rule_id_));
        if (info_maybe.is_just()) {
          auto& info = info_maybe.unsafe_get_just();
          if (!info.empty()) {
            // cellrange变化了就更新
            if (c_r_[0] != info[0].Range1 || c_r_[1] != info[0].Range2)
              // update 数据库的数据
            {
              update_info_ret = exec<db2_t, size_t>(
                update(tci)
                .set(tci.Range1() = c_r_[0], tci.Range2() = c_r_[1])
                .where(tci.RuleId() == this->rule_id_));
              if (update_info_ret.is_nothing()) {
                DEBUG_PRINT_MIX_CC("INFO信息数据更新异常");
                return -1;
              }
            }

          }
          else {
            // 如果没有当前 ruleid的range，就插入
            approx_info_ret = exec<db2_t, size_t>(insert_into(tci).set(
              tci.RuleId() = rule_id_, tci.Range1() = c_r_[0],
              tci.Range2() = c_r_[1], tci.Spare1() = 1,
              tci.Spare2() = 1));
            if (approx_info_ret.is_nothing()) {
              DEBUG_PRINT_MIX_CC("INFO信息数据插入异常");
              return -1;
            }
            if (approx_info_ret.unsafe_get_just() == 0) {
              DEBUG_PRINT_MIX_CC("插入数据量异常");
              return -2;
            }
          }
        }
        else {
          return -1;
        }

      }
      else if (dims_ == 3) {
        T_RULE_SAMPLE_3D_INFO tci;
        // 查询当前ruleid 是否已经存在
        auto info_maybe = exec<db2_t, T_RULE_SAMPLE_3D_INFO>(
          select(tci.Range1(), tci.Range2(), tci.Range3())
          .from(tci)
          .where(tci.RuleId() == this->rule_id_));
        if (info_maybe.is_just()) {
          auto& info = info_maybe.unsafe_get_just();
          if (!info.empty()) {
            // cellrange变化了就更新
            if (c_r_[0] != info[0].Range1 || c_r_[1] != info[0].Range2 ||
              c_r_[2] != info[0].Range3)
              // update 数据库的数据
            {
              update_info_ret = exec<db2_t, size_t>(
                update(tci)
                .set(tci.Range1() = c_r_[0], tci.Range2() = c_r_[1],
                  tci.Range3() = c_r_[2])
                .where(tci.RuleId() == this->rule_id_));
              if (update_info_ret.is_nothing()) {
                DEBUG_PRINT_MIX_CC("INFO信息数据更新异常");
                return -1;
              }
            }

          }
          else {
            // 如果没有当前 ruleid的range，就插入
            approx_info_ret = exec<db2_t, size_t>(insert_into(tci).set(
              tci.RuleId() = rule_id_, tci.Range1() = c_r_[0],
              tci.Range2() = c_r_[1], tci.Range3() = c_r_[2], tci.Spare1() = 1,
              tci.Spare2() = 1, tci.Spare3() = 1));
            if (approx_info_ret.is_nothing()) {
              DEBUG_PRINT_MIX_CC("INFO信息数据插入异常");
              return -1;
            }
            if (approx_info_ret.unsafe_get_just() == 0) {
              DEBUG_PRINT_MIX_CC("插入数据量异常");
              return -2;
            }
          }
        }
        else {
          return -1;
        }
      }
      // 保证cron第一次能store，但mon第一次不能store
      this->is_first_sampling_ = false;
      for (const auto& x : first_runing_info) {
        this->store(x);
      }
      // commit失败将返回int 2
      // 只有 commit 成功才将this->is_first_sampling_置为false
      // 否则置为true
      auto commit_result = this->commit();
      if (commit_result == 2) {
        this->is_first_sampling_ = true;
      }
      return 0;
    }

    /**
     * @brief 从数据库载入分布信息
     * @return int
     */

    int ApproximateData::load() {
      this->dump_size_ = 0;  ///< 解压缩之后的数据量
      this->scale_ = 0;      ///< 数据缩放比例
      this->data_.clear();   ///< 重新载入前，情况data_
      // db2数据info + 统计的数据载入
      // ①步长c_r_ ②分布数据data_ ③解压缩之后的数据量dump_size_
      if (dims_ == 1) {
        // 一维数据载入
        T_RULE_SAMPLE_1D_INFO ti;  ///< 步长信息
        auto info_maybe = exec<db2_t, T_RULE_SAMPLE_1D_INFO>(
          select(ti.Range1(), ti.Spare1())
          .from(ti)
          .where(ti.RuleId() == this->rule_id_));
        if (info_maybe.is_just()) {
          auto& info = info_maybe.unsafe_get_just();
          if (!info.empty()) {
            this->c_r_[0] = info[0].Range1;
          }
          else {
            this->gb_logger_->log_error(
              this->rule_id_ +
              ":load时，T_RULE_SAMPLE_1D_INFO没有记录");
            return -3;
          }
        }
        else {
          this->gb_logger_->log_error(this->rule_id_ + ":load时，db2查询错误！");
          return -1;
        }

        Dim1Table tc;
        auto query_list_maybe =
          exec<db2_t, Dim1Table>(select(tc.Flag(), tc.Count(), tc.X1())
            .from(tc)
            .where(tc.RuleId() == this->rule_id_));
        if (query_list_maybe.is_just()) {
          auto& query_list = query_list_maybe.unsafe_get_just();
          for (const auto& x : query_list) {
            this->data_.insert(
              std::make_pair(SamplePointWR({ x.X1 }, c_r_), x.Count));
            this->dump_size_ += x.Count;
          }
        }
        else {
          return -1;
        }

      }
      else if (dims_ == 2) {
        // 二维数据载入
        T_RULE_SAMPLE_2D_INFO di;
        auto info_maybe = exec<db2_t, T_RULE_SAMPLE_2D_INFO>(
          select(di.Range1(), di.Range2(), di.Spare1(),
            di.Spare2())
          .from(di)
          .where(di.RuleId() == this->rule_id_));
        if (info_maybe.is_just()) {
          auto& info = info_maybe.unsafe_get_just();
          if (!info.empty()) {
            this->c_r_[0] = info[0].Range1;
            this->c_r_[1] = info[0].Range2;
          }
          else {
            this->gb_logger_->log_error(
              this->rule_id_ +
              ":load时，T_RULE_SAMPLE_2D_INFO没有记录");
            return -3;
          }
        }
        else {
          this->gb_logger_->log_error(this->rule_id_ + ":load时，db2查询错误！");
          return -1;
        }
        Dim2Table dc;
        auto query_list_maybe =
          exec<db2_t, Dim2Table>(select(dc.Flag(), dc.Count(), dc.X1(), dc.X2())
            .from(dc)
            .where(dc.RuleId() == this->rule_id_));
        if (query_list_maybe.is_just()) {
          auto& query_list = query_list_maybe.unsafe_get_just();
          for (const auto& x : query_list) {
            this->data_.insert(
              std::make_pair(SamplePointWR({ x.X1, x.X2 }, c_r_), x.Count));
            this->dump_size_ += x.Count;
          }
        }
        else {
          return -1;
        }

      }
      else if (dims_ == 3) {
        // 三维数据载入
        T_RULE_SAMPLE_3D_INFO ti;
        auto info_maybe = exec<db2_t, T_RULE_SAMPLE_3D_INFO>(
          select(ti.Range1(), ti.Range2(), ti.Range3(), ti.Spare1(), ti.Spare2(), ti.Spare3())
          .from(ti)
          .where(ti.RuleId() == this->rule_id_));
        if (info_maybe.is_just()) {
          auto& info = info_maybe.unsafe_get_just();
          if (!info.empty()) {
            c_r_[0] = info[0].Range1;
            c_r_[1] = info[0].Range2;
            c_r_[2] = info[0].Range3;
          }
          else {
            this->gb_logger_->log_error(
              this->rule_id_ +
              ":load时，T_RULE_SAMPLE_3D_INFO没有记录");
            return -3;
          }
        }
        else {
          this->gb_logger_->log_error(this->rule_id_ + ":load时，db2查询错误！");
          return -1;
        }
        Dim3Table tc;
        auto query_list_maybe = exec<db2_t, Dim3Table>(
          select(tc.Flag(), tc.Count(), tc.X1(), tc.X2(), tc.X3())
          .from(tc)
          .where(tc.RuleId() == this->rule_id_));
        if (query_list_maybe.is_just()) {
          auto& query_list = query_list_maybe.unsafe_get_just();
          for (const auto& x : query_list) {
            this->data_.insert(
              std::make_pair(SamplePointWR({ x.X1, x.X2, x.X3 }, c_r_), x.Count));
            this->dump_size_ += x.Count;
          }
        }
      }
      // 计算缩放比列，刷is_first_sampling_为false，
      if (dump_size_ != 0) {
        this->scale_ = (double)k_dest_dump_size / (double)dump_size_;
        this->is_first_sampling_ = false;
      }
      if (data_.size() > 100000) {
        gb_logger_->log_error("data size is " + std::to_string(data_.size()));
      }
      if (dump_size_ * scale_ > 100000) {
        gb_logger_->log_error("dump size is " +
          std::to_string(dump_size_ * scale_));
      }

      return 0;
    }

    /**
     * @brief 把存储的数据提交到数据库中
     * @return int
     */

    int ApproximateData::commit() {
      if (this->insert_list_.empty() || this->update_list_.empty()) {
        return 2;
      }
      auto last_update_time = system_clock::now();
      fplus::maybe<std::size_t> maybe_ret = mix_cc::fp::nothing<std::size_t>();
      if (dims_ == 1) {
        // 1维数据提交
        Dim1Table tc;
        for (auto x : this->insert_list_) {
          exec<db2_t, size_t>(insert_into(tc).set(
            tc.RuleId() = this->rule_id_, tc.X1() = x.first.value[0].get_center(),
            tc.Count() = x.second, tc.Flag() = 1));
        }
        for (auto x : this->update_list_) {
          exec<db2_t, size_t>(update(tc)
            .set(tc.Count() = x.second)
            .where(tc.RuleId() == this->rule_id_,
              tc.X1() == x.first.value[0].get_center()));
        }
      }
      else if (dims_ == 2) {
        // 2维数据提交
        Dim2Table tc;
        for (auto x : this->insert_list_) {
          exec<db2_t, size_t>(insert_into(tc).set(
            tc.RuleId() = this->rule_id_, tc.X1() = x.first.value[0].get_center(),
            tc.X2() = x.first.value[1].get_center(), tc.Count() = x.second,
            tc.Flag() = 1));
        }
        for (auto x : this->update_list_) {
          exec<db2_t, size_t>(update(tc)
            .set(tc.Count() = x.second)
            .where(tc.RuleId() == this->rule_id_,
              tc.X1() == x.first.value[0].get_center(),
              tc.X2() == x.first.value[1].get_center()));
        }
      }
      else if (dims_ == 3) {
        // 3维数据提交
        Dim3Table tc;
        for (auto x : this->insert_list_) {
          exec<db2_t, size_t>(insert_into(tc).set(
            tc.RuleId() = this->rule_id_, tc.X1() = x.first.value[0].get_center(),
            tc.X2() = x.first.value[1].get_center(),
            tc.X3() = x.first.value[2].get_center(), tc.Count() = x.second,
            tc.Flag() = 1));
        }
        for (auto x : this->update_list_) {
          exec<db2_t, size_t>(update(tc)
            .set(tc.Count() = x.second)
            .where(tc.RuleId() == this->rule_id_,
              tc.X1() == x.first.value[0].get_center(),
              tc.X2() == x.first.value[1].get_center(),
              tc.X3() == x.first.value[2].get_center()));
        }
      }
      this->update_list_.clear();
      this->insert_list_.clear();
      gb_logger_->log_info("样本保存完成");
      return 0;
    }

    /**
     * @brief 存储指定数据(通过数据点和步长信息，生成的压缩数据)
     * @param  value            My Param doc
     * @return int
     */

    int ApproximateData::store(const SamplePoint& i_value) {
      // 对cron的第一次和非第一次开放，mon的非第一次开放
      // if (this->is_first_sampling()) {
      //   return 2;
      // }
      SamplePointWR value{ i_value, c_r_ };  ///< 数据点->[left,right]
      auto iter_data = this->data_.find(value);
      // 如果数据找得到
      if (iter_data != this->data_.end()) {
        iter_data->second++;
        // 如果在update找得到，更新update
        auto iter_update = this->update_list_.find(value);
        if (iter_update != this->update_list_.end()) {
          iter_update->second = iter_data->second;
        }
        else {
          // 否则插入update
          update_list_[value] = iter_data->second;
        }
      }
      else {
        this->data_[value] = 1;
        this->insert_list_.insert(std::make_pair(value, 1));
      }
      return 0;
    }

    /**
     * @brief 提取数据的大致分布特征
     * @warning 建议使用该方法对数据进行操作
     * @return int
     */

    ApproximateData::OutData ApproximateData::extract() {
      try {
        // 初始化随机器
        std::random_device r;
        std::seed_seq seed2{ r(), r(), r(), r(), r(), r(), r() };
        std::mt19937 e2(seed2);
        // 把数据精简之后存储在数据中
        OutData ret_data;  ///< 解压后的样本数据，其实是正态随机数
        for (const auto& x : this->data_) {
          int count =
            std::ceil(scale_ * x.second);  //根据该条记录的频次 得到解压到数据

        // 设置分布信息为正态分布
          std::vector<std::normal_distribution<>> normal_dist;
          normal_dist.reserve(dims_);
          for (size_t i = 0; i < dims_; i++) {
            // 正态分布：均值-分布信息数据中点 标准差-分布信息数据长度
            // 如 [a,b] : 均值 （a+b）/2    标准差  b-a
            normal_dist.emplace_back(std::normal_distribution<>{
              x.first.value[i].get_center(), x.first.value[i].get_distance()});
          }
          if (count > 0) {
            for (int j = 0; j < count; j++) {
              SamplePoint tmp{};
              for (size_t i = 0; i < dims_; i++) {
                tmp.push_back(normal_dist[i](e2));  ///< 正态随机数 作为解压出的数据
              }
              ret_data.emplace_back(tmp);
            }
          }
          else {
            // 如果缩放成0个，则只取一个
            SamplePoint tmp{};
            for (size_t i = 0; i < dims_; i++) {
              tmp.push_back(normal_dist[i](e2));
            }
            ret_data.emplace_back(tmp);
          }
        }
        return ret_data;
      }
      catch (const std::exception& e) {
        std::throw_with_nested(
          mix_cc::Exception(-1, "decompress data error", BOOST_CURRENT_LOCATION));
      }
      return {};
    }
    //

    int ApproximateData::put_data_to_rs(const SampleWindow& input_data) {
      // rs_.resize(dims_);
      // gb_logger_->log_error(this->rule_id_ +
      //                       "开始运行ApproximateData::put_data_to_rs");
      try {
        for (const auto& x : input_data) {
          for (size_t i = 0; i < x.size(); i++) {
            rs_[i].add(x[i]);  // decide range info
          }
        }
        return 1;
      }
      catch (...) {
        gb_logger_->log_error(this->rule_id_ +
          "ApproximateData::put_data_to_rs运行失败");
        return -1;
      }
    }
    vector<double> ApproximateData::get_rs_means() {
      vector<double> rs_means(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_means[i] = this->rs_[i].mean();
      }
      return rs_means;
    }
    vector<double> ApproximateData::get_rs_variances() {
      vector<double> rs_variances(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_variances[i] = this->rs_[i].variance();
      }
      return rs_variances;
    }
    vector<double> ApproximateData::get_rs_stddev() {
      vector<double> rs_stddev(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_stddev[i] = this->rs_[i].stddev();
      }
      return rs_stddev;
    }
    vector<double> ApproximateData::get_rs_kurtosis() {
      vector<double> rs_kurtosis(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_kurtosis[i] = this->rs_[i].ex_kurtosis();
      }
      return rs_kurtosis;
    }
    vector<double> ApproximateData::get_rs_skewness() {
      vector<double> rs_skewness(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_skewness[i] = this->rs_[i].skewness();
      }
      return rs_skewness;
    }

    vector<double> ApproximateData::get_rs_max() {
      vector<double> rs_max(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_max[i] = this->rs_[i].max();
      }
      return rs_max;
    }

    vector<double> ApproximateData::get_rs_min() {
      vector<double> rs_min(3, 0);
      for (int i = 0; i < this->rs_.size(); i++) {
        rs_min[i] = this->rs_[i].min();
      }
      return rs_min;
    }

  }  // namespace policy
}  // namespace data_handler