#include <eqpalg/data_handler/frame.h>
#include <eqpalg/table_struct/t_rule_sample_mgr.h>

namespace data_handler {

int load_table() {}

template <class DataPolicy>
Frame<DataPolicy>::Frame(const std::string& ruleId, size_t dims)
    : rule_id_(ruleId),
      rs_mgr_(ruleId, dims),
      data_mgr_(ruleId, dims),
      logger_("DataStorage[" + ruleId + "]") {}

/**
 * @brief 载入数据，如果有历史数据,则is_first_sampling 是false
 * @return int
 */
template <class DataPolicy>
int Frame<DataPolicy>::load() {
  //①步长c_r_ ②分布数据data_ ③解压缩之后的数据量dump_size_ ④scale_
  //同时将is_first_sampling的值置为false
  if (this->data_mgr_.load() == -3) {
    this->is_have_info_ = false;
  } else {
    this->is_have_info_ = true;
  }
  // 获取数据特征值 running_stats
  this->rs_mgr_.load();
  using namespace mix_cc::sql;
  T_RULE_SAMPLE_MGR rule_sample_mgr;
  auto sql_statement = select(rule_sample_mgr.lastCronTime())
                           .from(rule_sample_mgr)
                           .where(rule_sample_mgr.ruleId() == this->rule_id_);
  auto data_maybe = mix_cc::sql::exec<db2_t, T_RULE_SAMPLE_MGR>(sql_statement);
  if (data_maybe.is_nothing()) {
    last_cron_time_ = system_clock::now();

    return -1;
  }
  // 查询是否为空
  auto data = data_maybe.unsafe_get_just();
  if (data.size() != 1) {
    // 2021-10-28 insert
    // auto insert_result =
    auto insert_result = mix_cc::sql::exec<db2_t, size_t>(
        insert_into(rule_sample_mgr)
            .set(rule_sample_mgr.ruleId() = this->rule_id_,
                 rule_sample_mgr.lastCronTime() =
                     mix_cc::mix_time_t(system_clock::now())));
    last_cron_time_ = system_clock::now();
    return -1;
  }
  last_cron_time_ = data[0].lastCronTime.to_chrono_time();
  return 0;
}

template <class DataPolicy>
bool Frame<DataPolicy>::is_first_sampling() {
  /**
   * 以下三种情况均被视为第一次采样
   * 可能db2有数据，但本地文件没有，则重新训练；
   * 可能本地文件没有数据，但db2有，则重新训练
   * 可能db2和本地文件都没有数据，则第一次训练
   */
  return (data_mgr_.is_first_sampling() || rs_mgr_.is_first_sampling());
}

/**
 * @brief 如果is_first_sampling 是true 执行
 * @return int
 */
template <class DataPolicy>
int Frame<DataPolicy>::first_sampling_bath(const SampleWindow& input_data,
                                           TimePoint tp) {
  rs_mgr_.first_sampling(
      input_data);  ///<  均值方差之类的统计信息写入二进制文件
  // 保存至 db2
  data_mgr_.first_sampling_batch(input_data, tp, rs_mgr_.get_running_stats());
  //
  //设置周期
  last_cron_time_ = system_clock::now();
  T_RULE_SAMPLE_MGR rule_sample_mgr;
  auto sql_statement = update(rule_sample_mgr)
                           .set(rule_sample_mgr.lastCronTime() =
                                    mix_cc::mix_time_t(system_clock::now()))
                           .where(rule_sample_mgr.ruleId() == this->rule_id_);
  auto effect_maybe = mix_cc::sql::exec<db2_t, size_t>(sql_statement);
  if (effect_maybe.is_just()) {
    return 0;
  }
  return -1;
}

template <class DataPolicy>
int Frame<DataPolicy>::store(const SamplePoint& data_array) {
  this->data_mgr_.store(data_array);
  this->rs_mgr_.store(data_array);
  return 0;
}

template <class DataPolicy>
int Frame<DataPolicy>::commit() {
  this->data_mgr_.commit();
  this->rs_mgr_.commit();
  return 0;
}

template <class DataPolicy>
Rs Frame<DataPolicy>::get_running_stats() {
  return this->rs_mgr_.get_running_stats();
}

template <class DataPolicy>
SampleWindow Frame<DataPolicy>::get_extracted_data() {
  return this->data_mgr_.extract();
}

template <class DataPolicy>
int Frame<DataPolicy>::put_data_to_rs(const SampleWindow& input_data) {
  // logger_.Info("int Frame<DataPolicy>::put_data_to_rs(const SampleWindow&
  // input_data) {");
  return this->data_mgr_.put_data_to_rs(input_data);
}

template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_variances() {
  return this->data_mgr_.get_rs_variances();
}
template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_means() {
  return this->data_mgr_.get_rs_means();
}

template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_kurtosis() {
  return this->data_mgr_.get_rs_kurtosis();
}

template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_skewness() {
  return this->data_mgr_.get_rs_skewness();
}

template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_stddev() {
  return this->data_mgr_.get_rs_stddev();
}

template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_max() {
  return this->data_mgr_.get_rs_max();
}

template <class DataPolicy>
vector<double> Frame<DataPolicy>::get_rs_min() {
  return this->data_mgr_.get_rs_min();
}

}  // namespace data_handler


template class data_handler::Frame<data_handler::policy::ApproximateData>;