#include "sql.hpp"
#include <cstring>
#include <cstdio>
#include <thread>
#include <chrono>
#include "values/DnaManager.hpp"

void checker()
{
  using namespace std::chrono_literals;

  sqlite3 *db;
  int rc = sql::open(DB_NAME, &db);
  if (rc)
  {
    fprintf(stderr, "Can't open database: %s\n", sql::errmsg(db));
  }

  sqlite3_stmt *get_unchecked_stmt;
  sql::prepare_v2(db, get_unchecked, -1, &get_unchecked_stmt, NULL);

  sqlite3_stmt *get_gen_stmt;
  sql::prepare_v2(db, get_gen, -1, &get_gen_stmt, NULL);

  sqlite3_stmt *get_user_table_id_stmt;
  sql::prepare_v2(db, get_user_table_id, -1, &get_user_table_id_stmt, NULL);

  sqlite3_stmt *rem_like_w_user_table_id_stmt;
  sql::prepare_v2(db, rem_like_w_user_table_id, -1, &rem_like_w_user_table_id_stmt, NULL);

  sqlite3_stmt *rem_user_table_id_stmt;
  sql::prepare_v2(db, rem_user_table_id, -1, &rem_user_table_id_stmt, NULL);

  sqlite3_stmt *set_checked_stmt;
  sql::prepare_v2(db, set_checked, -1, &set_checked_stmt, NULL);

  while (true)
  {
    int64_t user_id = 0;
    if (sql::step(get_unchecked_stmt) != SQL_DONE)
    {
      int type = sql::column_type(get_unchecked_stmt, 0);
      if (type != SQL_NULL)
      {
        user_id = sql::column_int64(get_unchecked_stmt, 0);
      }
    }
    sql::reset(get_unchecked_stmt);
    if (user_id == 0)
    {
      std::this_thread::sleep_for(60s);
      continue;
    }
    printf("Start Check\n");
    DnaManagerData data;
    data.id = user_id;
    data.randSeed = mrand::getState(data.id);
    data.queued = 0;
    data.showed = 0;
    data.generation = 0;
    data.vector.resize(NUM_PER_GEN);

    for (std::size_t i = 0; i < NUM_PER_GEN; i++)
    {
      DNA::newDna(&data.vector[i], &data.randSeed);
    }
    bool found_err = false;
    while (found_err != true)
    {
      sql::bind_int64(get_gen_stmt, 1, data.id);
      sql::bind_int64(get_gen_stmt, 2, data.generation);

      bool new_gen = false;
      while (sql::step(get_gen_stmt) != SQL_DONE)
      {
        int64_t hash = sql::column_int64(get_gen_stmt, 0);
        int64_t pos = sql::column_int64(get_gen_stmt, 1);
        int64_t liked = sql::column_int64(get_gen_stmt, 2);
        UiUnit unit = DnaManager::next(&data);
        int64_t cal_hash = mrand::computeCRC32(unit.dna, sizeof(Dna));
        if ((unit.index != pos) || (hash != cal_hash))
        {
          found_err = true;
          break;
        }
        unit.liked = (Liked)liked;
        new_gen = DnaManager::like(unit, &data);
      }

      if (!new_gen)
      {
        found_err = true;
      }

      if (!found_err)
      {
        sql::bind_int64(set_checked_stmt, 1, data.id);
        sql::bind_int64(set_checked_stmt, 2, data.generation);
        sql::step(set_checked_stmt);
        sql::reset(set_checked_stmt);
      }
      else
      {
        sql::bind_int64(get_user_table_id_stmt, 1, data.id);
        sql::bind_int64(get_user_table_id_stmt, 2, data.generation);
        int64_t user_table_id = 0;
        if (sql::step(get_user_table_id_stmt) != SQL_DONE)
        {
          int type = sql::column_type(get_user_table_id_stmt, 0);
          if (type != SQL_NULL)
          {
            user_table_id = sql::column_int64(get_user_table_id_stmt, 0);
          }
        }
        sql::reset(get_user_table_id_stmt);

        sql::bind_int64(rem_like_w_user_table_id_stmt, 1, user_table_id);
        sql::step(rem_like_w_user_table_id_stmt);
        sql::reset(rem_like_w_user_table_id_stmt);

        sql::bind_int64(rem_user_table_id_stmt, 1, user_table_id);
        sql::step(rem_user_table_id_stmt);
        sql::reset(rem_user_table_id_stmt);
      }

      if (new_gen)
      {
        DnaManager::newGen(&data);
      }

      sql::reset(get_gen_stmt);
    }
    printf("End Check\n");
  }
}