#include "matador/sql/query_intermediates.hpp"
#include "matador/sql/session.hpp"

namespace matador::sql {

query_result<record> query_select_finish::fetch_all()
{
  return session_.fetch(builder_.compile());
}

record query_select_finish::fetch_one()
{
  return *session_.fetch(builder_.compile()).begin().get();
}

std::unique_ptr<query_result_impl> query_select_finish::fetch()
{
  return session_.fetch(builder_.compile().sql);
}

statement query_select_finish::prepare()
{
  return session_.prepare(builder_.compile());
}

query_intermediate::query_intermediate(session &db, query_builder &query)
: session_(db), builder_(query) {}

query_offset_intermediate query_order_direction_intermediate::offset(size_t offset)
{
  return {session_, builder_};
}

query_limit_intermediate query_offset_intermediate::limit(size_t limit)
{
  return {session_, builder_};
}

query_limit_intermediate query_order_direction_intermediate::limit(size_t limit)
{
  return {session_, builder_};
}

query_order_by_intermediate query_group_by_intermediate::order_by(const std::string &name)
{
  return {session_, builder_.order_by(name)};
}

query_order_direction_intermediate query_order_by_intermediate::asc()
{
  return {session_, builder_.asc()};
}

query_order_direction_intermediate query_order_by_intermediate::desc()
{
  return {session_, builder_.desc()};
}

query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
{
  return {session_, builder_.group_by(name)};
}

query_order_by_intermediate query_from_intermediate::order_by(const std::string &name)
{
  return {session_, builder_.order_by(name)};
}

query_group_by_intermediate query_where_intermediate::group_by(const std::string &name)
{
  return {session_, builder_.group_by(name)};
}

query_order_by_intermediate query_where_intermediate::order_by(const std::string &name)
{
  return {session_, builder_.order_by(name)};
}

query_where_intermediate query_from_intermediate::where(const basic_condition &cond)
{
  return query_where_intermediate{session_, builder_.where(cond)};
}

query_select_intermediate::query_select_intermediate(session &s, const std::vector<column>& columns)
: query_start_intermediate(s)
{
  builder_.select(columns);
}

query_from_intermediate query_select_intermediate::from(const std::string &table, const std::string &as)
{
  return {session_, builder_.from(table, as)};
}

query_insert_intermediate::query_insert_intermediate(session &s)
: query_start_intermediate(s)
{
  builder_.insert();
}

query_into_intermediate query_insert_intermediate::into(const std::string &table, std::initializer_list<std::string> column_names)
{
  return {session_, builder_.into(table, column_names)};
}

size_t query_execute_finish::execute()
{
  return session_.execute(builder_.compile().sql);
}

statement query_execute_finish::prepare()
{
  return session_.prepare(builder_.compile());
}

query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
{
  return {session_, builder_.values(values)};
}

query_create_intermediate::query_create_intermediate(session &s, table_repository &repo)
: query_start_intermediate(s)
, repository_(repo) {
  builder_.create();
}

query_execute_finish query_create_intermediate::table(const std::string &table, std::initializer_list<column> columns)
{
  return {session_, builder_.table(table, columns)};
}

query_drop_intermediate::query_drop_intermediate(session &s)
: query_start_intermediate(s)
{
  builder_.drop();
}

query_execute_finish query_drop_intermediate::table(const std::string &table)
{
  return {session_, builder_.table(table)};
}

query_execute_finish query_execute_where_intermediate::limit(int limit)
{
  return {session_, builder_.limit(limit)};
}

query_execute_where_intermediate query_set_intermediate::where(const basic_condition &cond)
{
  return {session_, builder_.where(cond)};
}

query_update_intermediate::query_update_intermediate(session &s, const std::string& table_name)
: query_start_intermediate(s)
{
  builder_.update(table_name);
}

query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
{
  return {session_, builder_.set(columns)};
}

query_execute_where_intermediate query_delete_from_intermediate::where(const basic_condition &cond)
{
  return {session_, builder_.where(cond)};
}

query_delete_intermediate::query_delete_intermediate(session &s)
: query_start_intermediate(s)
{
  builder_.remove();
}

query_delete_from_intermediate query_delete_intermediate::from(const std::string &table)
{
  return {session_, builder_.from(table)};
}

query_start_intermediate::query_start_intermediate(session &s)
: session_(s)
, builder_(s.dialect())
{}
}