#ifndef QUERY_QUERY_PARTS_HPP
#define QUERY_QUERY_PARTS_HPP

#include "matador/query/query_part_visitor.hpp"
#include "matador/query/criteria.hpp"

#include "matador/query/internal/column_value_pair.hpp"
#include "matador/query/query_part.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table.hpp"

#include "matador/object/attribute.hpp"
#include "matador/object/constraint.hpp"

#include "matador/utils/placeholder.hpp"

#include <memory>

namespace matador::query::internal {

class query_alter_part final : public query_part {
public:
  query_alter_part();

  void accept(query_part_visitor &visitor) override;
};

class query_alter_table_part final : public query_part {
public:
  explicit query_alter_table_part(class table tab);

  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const class table& table() const;

private:
  query::table table_;
};

class query_add_key_constraint_part final : public query_part {
public:
  explicit query_add_key_constraint_part(std::string  name);
  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const std::string& name() const;
private:
  std::string name_;
};

class query_drop_key_constraint_part final : public query_part {
public:
  explicit query_drop_key_constraint_part(std::string  name);
  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const std::string& name() const;
private:
  std::string name_;
};

class query_add_foreign_key_constraint_part final : public query_part {
public:
  explicit query_add_foreign_key_constraint_part( const std::vector<column>& columns);
  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const std::vector<column>& columns() const;
private:
  std::vector<column> columns_;
};

class query_add_foreign_key_reference_part final : public query_part {
public:
  explicit query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns);
  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const class table& table() const;
  [[nodiscard]] const std::vector<column>& columns() const;

private:
  query::table table_;
  std::vector<column> columns_;
};

class query_add_primary_key_constraint_part final : public query_part {
public:
  explicit query_add_primary_key_constraint_part( const std::vector<column>& columns);
  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const std::vector<column>& columns() const;
private:
  std::vector<column> columns_;
};

class query_drop_foreign_key_constraint_part final : public query_part {
public:
    query_drop_foreign_key_constraint_part();
    void accept(query_part_visitor &visitor) override;
};

/**
 * Represents the SQL SELECT part
 */
class query_select_part final : public query_part
{
public:
  explicit query_select_part(std::vector<column> columns);
  void accept(query_part_visitor &visitor) override;

  [[nodiscard]] const std::vector<column>& columns() const;

private:
  std::vector<column> columns_;
};

/**
 * Represents the SQL FROM part
 */
class query_from_part final : public query_part
{
public:
  explicit query_from_part(class table tab);

  [[nodiscard]] const class table& table() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
};

class query_join_part final : public query_part
{
public:
  explicit query_join_part(class table tab);

  [[nodiscard]] const class table& table() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
};

class query_on_part final : public query_part
{
public:
  template < class Condition >
  explicit query_on_part(const Condition &cond)
    : query_part(sql::dialect_token::On)
    , condition_(new Condition(cond)) {}
  explicit query_on_part(std::unique_ptr<abstract_criteria> &&cond);

  [[nodiscard]] const abstract_criteria& condition() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::unique_ptr<abstract_criteria> condition_;
};

class query_where_part final : public query_part
{
public:
  template < class Condition >
  explicit query_where_part(const Condition &cond)
  : query_part(sql::dialect_token::Where)
  , condition_(new Condition(cond)) {}
  explicit query_where_part(std::unique_ptr<abstract_criteria> &&cond);

  [[nodiscard]] const abstract_criteria& condition() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::unique_ptr<abstract_criteria> condition_;
};

class query_table_name_part : public query_part
{
protected:
  explicit query_table_name_part(sql::dialect_token token, std::string table_name);

protected:
  std::string table_name_;
};

class query_group_by_part final : public query_part
{
public:
  explicit query_group_by_part(class column  col);

  [[nodiscard]] const class column& column() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class column column_;
};

class query_order_by_part final : public query_part
{
public:
  explicit query_order_by_part(class column  col);

  [[nodiscard]] const class column& column() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class column column_;
};

class query_order_by_asc_part final : public query_part
{
public:
  query_order_by_asc_part();

private:
  void accept(query_part_visitor &visitor) override;
};

class query_order_by_desc_part final : public query_part
{
public:
  query_order_by_desc_part();

private:
  void accept(query_part_visitor &visitor) override;
};

class query_offset_part final : public query_part
{
public:
  explicit query_offset_part(size_t offset);

  [[nodiscard]] size_t offset() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  size_t offset_;
};

class query_limit_part final : public query_part
{
public:
  explicit query_limit_part(size_t limit);

  [[nodiscard]] size_t limit() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  size_t limit_;
};

class query_insert_part final : public query_part
{
public:
  query_insert_part();

private:
  void accept(query_part_visitor &visitor) override;
};

class query_into_part final : public query_part
{
public:
  query_into_part(class table tab, std::vector<column> columns);

  [[nodiscard]] const class table& table() const;
  [[nodiscard]] const std::vector<column>& columns() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
  std::vector<column> columns_;
};
/**
 * Represents the SQL VALUES part
 */
class query_values_part final : public query_part
{
public:
  explicit query_values_part(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values);

  [[nodiscard]] const std::vector<std::variant<utils::placeholder, utils::database_type>>& values() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::vector<std::variant<utils::placeholder, utils::database_type>> values_;
};

class query_update_part final : public query_part
{
public:
  explicit query_update_part(class table tab);

  [[nodiscard]] const class table& table() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
};

class query_set_part final : public query_part
{
public:
  explicit query_set_part(const std::vector<internal::column_value_pair>& key_value_pairs);

  [[nodiscard]] const std::vector<internal::column_value_pair>& column_values() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::vector<internal::column_value_pair> key_value_pairs_;
};

class query_delete_part final : public query_part
{
public:
  query_delete_part();

private:
  void accept(query_part_visitor &visitor) override;
};

class query_delete_from_part final : public query_part
{
public:
  explicit query_delete_from_part(class table tab);

  [[nodiscard]] const class table& table() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
};

class query_create_part final : public query_part
{
public:
  query_create_part();

private:
  void accept(query_part_visitor &visitor) override;
};

class query_create_table_part final : public query_part
{
public:
  explicit query_create_table_part(class table tab);

  [[nodiscard]] const class table& table() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
};

class query_create_table_columns_part final : public query_part {
public:
  explicit query_create_table_columns_part(const std::list<object::attribute> &columns);

 [[nodiscard]] const std::list<object::attribute>& columns() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::list<object::attribute> columns_;
};

class query_create_table_constraints_part final : public query_part {
public:
  explicit query_create_table_constraints_part(const std::list<class object::constraint> &constraints);

  [[nodiscard]] const std::list<class object::constraint>& constraints() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::list<class object::constraint> constraints_;
};

class query_create_schema_part final : public query_part {
public:
  explicit query_create_schema_part(std::string schema);

  [[nodiscard]] const std::string& schema() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::string schema_;
};

class query_drop_part final : public query_part
{
public:
  query_drop_part();

private:
  void accept(query_part_visitor &visitor) override;
};

class query_drop_table_part final : public query_part
{
public:
  explicit query_drop_table_part(class table tab);

  [[nodiscard]] const class table& table() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  class table table_;
};

class query_drop_schema_part final : public query_part {
public:
  explicit query_drop_schema_part(std::string schema_);

  [[nodiscard]] const std::string& schema() const;

private:
  void accept(query_part_visitor &visitor) override;

private:
  std::string schema_;
};

}
#endif //QUERY_QUERY_PARTS_HPP