#ifndef QUERY_COLUMN_DEFINITION_HPP
#define QUERY_COLUMN_DEFINITION_HPP

#include <memory>

#include "matador/utils/basic_type_converter.hpp"
#include "matador/utils/basic_types.hpp"
#include "matador/utils/default_type_traits.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/value.hpp"

#include <vector>

namespace matador::object {

enum class null_option : uint8_t {
  NULLABLE, NOT_NULL
};

class attribute_definition {
public:
  explicit attribute_definition(const char *name); // NOLINT(*-explicit-constructor)
  explicit attribute_definition(std::string name); // NOLINT(*-explicit-constructor)

  attribute_definition(const attribute_definition&) = default;
  attribute_definition& operator=(const attribute_definition&) = default;
  attribute_definition(attribute_definition&&) noexcept = default;
  attribute_definition& operator=(attribute_definition&&) noexcept = default;

  template<typename Type>
  explicit attribute_definition(std::string name, const utils::field_attributes& attr)
  : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), attr)
  {}

  template<typename Type>
  attribute_definition(std::string name, const Type &, const utils::field_attributes& attr, null_option null_opt)
  : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), attr, null_opt)
  {}

  template<size_t SIZE>
  attribute_definition(std::string name, const char (&)[SIZE], const utils::field_attributes& attr, const null_option null_opt)
  : attribute_definition(std::move(name), utils::data_type_traits<const char*>::type(attr.size()), attr, null_opt)
  {}

  attribute_definition(std::string name, utils::basic_type type, const utils::field_attributes&, null_option null_opt, size_t index = 0);

  template<typename Type>
  attribute_definition(std::string name, const std::shared_ptr<attribute_definition> &ref_column, const utils::field_attributes& attr, null_option null_opt)
  : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), ref_column, attr, null_opt)
  {}

  attribute_definition(std::string name, utils::basic_type type, size_t index, const std::shared_ptr<attribute_definition> &ref_column, const utils::field_attributes& attr, null_option null_opt);

  [[nodiscard]] const std::string& name() const;
  [[nodiscard]] std::string full_name() const;
  [[nodiscard]] std::string table_name() const;
  [[nodiscard]] int index() const;
  [[nodiscard]] const utils::field_attributes& attributes() const;
  [[nodiscard]] bool is_nullable() const;
  [[nodiscard]] utils::basic_type type() const;
  [[nodiscard]] std::shared_ptr<attribute_definition> reference_column() const;
  [[nodiscard]] bool is_foreign_reference() const;

  [[nodiscard]] bool is_integer() const;
  [[nodiscard]] bool is_floating_point() const;
  [[nodiscard]] bool is_bool() const;
  [[nodiscard]] bool is_string() const;
  [[nodiscard]] bool is_varchar() const;
  [[nodiscard]] bool is_date() const;
  [[nodiscard]] bool is_time() const;
  [[nodiscard]] bool is_blob() const;
  [[nodiscard]] bool is_null() const;

  void type(utils::basic_type type);

  template< typename Type >
  [[nodiscard]] bool is_type_of() const {
    return std::holds_alternative<Type>(value_);
  }

  [[nodiscard]] std::string str() const;

  template<typename Type>
  void set(const Type &value, const utils::field_attributes &attr = utils::null_attributes)
  {
    attributes_ = attr;
    value_ = value;
  }

  void set(const std::string &value, const utils::field_attributes &attr)
  {
    value_ = value;
    attributes_ = attr;
  }

  void set(const char *value, const utils::field_attributes &attr)
  {
    value_ = std::string(value);
    attributes_ = attr;
  }

  template<class Type>
  std::optional<Type> as() const
  {
    return value_.as<Type>();
  }

  friend std::ostream& operator<<(std::ostream &out, const attribute_definition &col);

private:
  template<class Operator>
  void process(Operator &op)
  {
    op.on_attribute(name_.c_str(), value_, attributes_);
  }

  using data_type_index = std::vector<utils::basic_type>;

private:
  static const data_type_index data_type_index_;

  std::string name_;
  std::string table_;
  int index_{-1};
  utils::field_attributes attributes_;
  null_option null_option_{null_option::NOT_NULL};
  utils::value value_;
  std::shared_ptr<attribute_definition> reference_column_;
  // std::string ref_table_;
  // std::string ref_column_;
};

/**
 * User defined literal to have a shortcut creating a column object
 * @param name Name of the column
 * @param type
 * @param attr Length of the column name
 * @param null_opt
 * @return A column object with given name
 */
attribute_definition make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr = utils::null_attributes, null_option null_opt = null_option::NOT_NULL);

template < typename Type >
attribute_definition make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes, null_option null_opt = null_option::NOT_NULL)
{
    return make_column(name, utils::data_type_traits<Type>::type(0), attr, null_opt);
}
template <>
attribute_definition make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option null_opt);

template < typename Type >
attribute_definition make_pk_column(const std::string &name, size_t size = 0)
{
    return make_column<Type>(name, { size, utils::constraints::PRIMARY_KEY });
}

template <>
attribute_definition make_pk_column<std::string>(const std::string &name, size_t size);

template < typename Type >
attribute_definition make_fk_column(const std::string &name, size_t size, const std::shared_ptr<attribute_definition> &ref_column)
{
    return {name, utils::data_type_traits<Type>::type(size), ref_column, { size, utils::constraints::FOREIGN_KEY }};
}

template < typename Type >
[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, const std::shared_ptr<attribute_definition> &ref_column)
{
    return {name, utils::data_type_traits<Type>::type(0), 0, ref_column, { 0, utils::constraints::FOREIGN_KEY }, null_option::NOT_NULL};
}

template <>
attribute_definition make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute_definition> &ref_column);

}

#endif //QUERY_COLUMN_DEFINITION_HPP