#include "matador/sql/connection.hpp"

#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection_impl.hpp"

#include <stdexcept>
#include <utility>

namespace matador::sql {

connection::connection(connection_info info)
: connection_info_(std::move(info))
, logger_(stdout, "SQL")
, dialect_(backend_provider::instance().connection_dialect(info.type))
{
  connection_.reset(backend_provider::instance().create_connection(connection_info_.type, connection_info_));
}

connection::connection(const std::string& dns)
: connection(connection_info::parse(dns))
{}

connection::connection(const connection &x)
: connection_info_(x.connection_info_)
, logger_(x.logger_)
, dialect_(x.dialect_)
{
  if (x.connection_) {
    throw std::runtime_error("couldn't copy connection with valid connection impl");
  }
}

connection &connection::operator=(const connection &x) {
  connection_info_ = x.connection_info_;
  logger_ = x.logger_;
  if (x.connection_) {
    throw std::runtime_error("couldn't copy connection with valid connection impl");
  }
  return *this;
}

connection::~connection()
{
  if (connection_->is_open()) {
    connection_->close();
  }
  backend_provider::instance().destroy_connection(connection_info_.type, connection_.release());
  connection_ = nullptr;
}

void connection::open()
{
  connection_->open();
}

void connection::close()
{
  connection_->close();
}

bool connection::is_open() const
{
  return connection_->is_open();
}

const connection_info &connection::info() const
{
  return connection_info_;
}

record connection::describe(const std::string &table_name) const
{
  return std::move(connection_->describe(table_name));
}

bool connection::exists(const std::string &schema_name, const std::string &table_name) const
{
  return connection_->exists(schema_name, table_name);
}

size_t connection::execute(const std::string &sql) const
{
  logger_.debug(sql);
  return connection_->execute(sql);
}

std::unique_ptr<query_result_impl> connection::fetch(const std::string &sql) const
{
  logger_.debug(sql);
  return connection_->fetch(sql);
}

statement connection::prepare(query_context &&query) const
{
  return statement(connection_->prepare(std::move(query)), logger_);
}

const class dialect &connection::dialect() const
{
  return dialect_;
}

}