#ifndef QUERY_QUERY_INTERMEDIATES_HPP
#define QUERY_QUERY_INTERMEDIATES_HPP

#include "matador/sql/column.hpp"
#include "matador/sql/column_generator.hpp"
#include "matador/sql/column_name_generator.hpp"
#include "matador/sql/key_value_pair.hpp"
#include "matador/sql/query_result.hpp"
#include "matador/sql/record.hpp"

#include <string>

namespace matador::sql {

class basic_condition;
class session;
class query_builder;

class query_intermediate
{
public:
  query_intermediate(session &db, query_builder &query);

protected:
  session& db();
  query_builder& query();

private:
  session &db_;
  query_builder &query_;
};

class query_execute_finish : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  std::pair<size_t, std::string> execute();
};

class query_select_finish : public query_intermediate
{
protected:
  using query_intermediate::query_intermediate;

public:
  query_result<record> fetch_all();
  record fetch_one();
  template<typename Type>
  Type fetch_value()
  {
    auto result = fetch_all();
    return {};
  }
};

class query_limit_intermediate : public query_select_finish
{
public:
  using query_select_finish::query_select_finish;
};

class query_offset_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_limit_intermediate limit(size_t limit);
};

class query_order_direction_intermediate : public query_select_finish
{
public:
  using query_select_finish::query_select_finish;

  query_offset_intermediate offset(size_t offset);
  query_limit_intermediate limit(size_t limit);
};

class query_order_by_intermediate;

class query_group_by_intermediate : public query_select_finish
{
public:
  using query_select_finish::query_select_finish;

  query_order_by_intermediate order_by(const std::string &name);
};

class query_order_by_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_order_direction_intermediate asc();
  query_order_direction_intermediate desc();
};

class query_where_intermediate : public query_select_finish
{
public:
  using query_select_finish::query_select_finish;

  query_group_by_intermediate group_by(const std::string &name);
  query_order_by_intermediate order_by(const std::string &name);
};

class query_from_intermediate : public query_select_finish
{
public:
  using query_select_finish::query_select_finish;

  query_where_intermediate where(const basic_condition &cond);
  query_group_by_intermediate group_by(const std::string &name);
  query_order_by_intermediate order_by(const std::string &name);
};

class query_select_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_from_intermediate from(const std::string &table, const std::string &as = "");

};

class query_into_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_execute_finish values(std::initializer_list<any_type> values);
};

class query_create_intermediate : query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_execute_finish table(const std::string &table, std::initializer_list<column> columns);
  template<class Type>
  query_execute_finish table(const std::string &table)
  {
    return {db(), query().table(table, column_generator::generate<Type>())};
  }
};

class query_drop_intermediate : query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_execute_finish table(const std::string &table);
};

class query_insert_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_into_intermediate into(const std::string &table, std::initializer_list<std::string> column_names);
  template<class Type>
  query_into_intermediate into(const std::string &table)
  {
    return into(table, column_name_generator::generate<Type>());
  }
};

class query_execute_where_intermediate : public query_execute_finish
{
public:
  using query_execute_finish::query_execute_finish;

  query_execute_finish limit(int limit);
};

class query_set_intermediate : public query_execute_finish
{
public:
  using query_execute_finish::query_execute_finish;

  query_execute_where_intermediate where(const basic_condition &cond);
};

class query_update_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_set_intermediate set(std::initializer_list<key_value_pair> columns);
};

class query_delete_from_intermediate : public query_execute_finish
{
public:
  using query_execute_finish::query_execute_finish;

  query_execute_where_intermediate where(const basic_condition &cond);
};

class query_delete_intermediate : public query_intermediate
{
public:
  using query_intermediate::query_intermediate;

  query_delete_from_intermediate from(const std::string &table, const std::string &as = "");
};

}
#endif //QUERY_QUERY_INTERMEDIATES_HPP