#include <catch2/catch_test_macros.hpp>
#include <catch2/catch_template_test_macros.hpp>

#include <matador/sql/column.hpp>
#include <matador/sql/condition.hpp>
#include <matador/sql/session.hpp>

#include "Databases.hpp"

#include "models/product.hpp"
#include "models/airplane.hpp"
#include "models/flight.hpp"
#include "models/person.hpp"

using namespace matador::sql;
using namespace matador::test;

template<class Type>
class SessionTestFixture
{
public:
  SessionTestFixture()
    : pool_(Type::dns, 4), session_(pool_)
  {}
    ~SessionTestFixture() = default;

  matador::sql::session &session()
  { return session_; }

private:
  matador::sql::connection_pool<matador::sql::connection> pool_;
  matador::sql::session session_;
};

TEMPLATE_TEST_CASE_METHOD(SessionTestFixture, "Create table with foreign key relation", "[session]", Sqlite, Postgres) {
  auto &s = SessionTestFixture<TestType>::session();

  s.create()
    .template table<airplane>("airplane")
    .execute();

  REQUIRE(s.table_exists("airplane"));

  s.create()
         .template table<flight>("flight")
         .execute();

  REQUIRE(s.table_exists("flight"));

  s.drop().table("flight").execute();
  s.drop().table("airplane").execute();

  REQUIRE(!s.table_exists("flight"));
  REQUIRE(!s.table_exists("airplane"));
}

TEMPLATE_TEST_CASE_METHOD(SessionTestFixture, "Execute select statement with where clause", "[session]", Postgres, Sqlite) {
  auto &s = SessionTestFixture<TestType>::session();

  s.create()
    .template table<person>("person")
    .execute();

  person george{7, "george", 45};

  auto res = s.insert()
         .into("person", george)
         .execute();
  REQUIRE(res == 1);

  // fetch person as record
  auto result_record = s.template select<person>()
                        .from("person")
                        .where("id"_col == 7)
                        .fetch_all();

  for (const auto& i : result_record) {
    REQUIRE(i.size() == 3);
    REQUIRE(i.at(0).name() == "id");
    REQUIRE(i.at(0).type() == data_type_t::type_unsigned_long);
    REQUIRE(i.at(0).template as<long long>() == george.id);
    REQUIRE(i.at(1).name() == "name");
    REQUIRE(i.at(1).type() == data_type_t::type_varchar);
    REQUIRE(i.at(1).template as<std::string>() == george.name);
    REQUIRE(i.at(2).name() == "age");
    REQUIRE(i.at(2).type() == matador::sql::data_type_t::type_unsigned_int);
    REQUIRE(i.at(2).template as<long long>() == george.age);
  }

  // fetch person as person
  auto result_person = s.template select<person>()
                        .from("person")
                        .where("id"_col == 7)
                        .template fetch_all<person>();

  for (const auto& i : result_person) {
    REQUIRE(i.id == 7);
    REQUIRE(i.name == "george");
    REQUIRE(i.age == 45);
  }

  s.drop().table("person").execute();
}

TEMPLATE_TEST_CASE_METHOD(SessionTestFixture, "Execute insert statement", "[session]", Sqlite, Postgres) {
  auto &s = SessionTestFixture<TestType>::session();

  s.create()
              .table("person", {
                make_pk_column<unsigned long>("id"),
                make_column<std::string>("name", 255),
                make_column<std::string>("color", 63)
              })
              .execute();

  auto res = s.insert()
         .into("person", {"id", "name", "color"})
         .values({7, "george", "green"})
         .execute();

  REQUIRE(res == 1);

  s.drop().table("person").execute();
}

TEMPLATE_TEST_CASE_METHOD(SessionTestFixture, "Select statement with foreign key", "[session]", Sqlite, Postgres) {
  auto &s = SessionTestFixture<TestType>::session();

  s.create()
    .template table<airplane>("airplane")
    .execute();

  s.create()
    .template table<flight>("flight")
    .execute();

  std::vector<entity<airplane>> planes {
    make_entity<airplane>(1, "Airbus", "A380"),
    make_entity<airplane>(2, "Boeing", "707"),
    make_entity<airplane>(3, "Boeing", "747")
  };

  for (const auto &plane : planes) {
    auto res = s.insert().template into<airplane>("airplane").values(*plane).execute();
    REQUIRE(res == 1);
  }

  auto count = s.select({count_all()}).from("airplane").template fetch_value<int>();
  REQUIRE(count == 3);

  flight f4711{4, planes.at(1), "hans"};

  auto res = s.insert().template into<flight>("flight").values(f4711).execute();
  REQUIRE(res == 1);

  auto f = *s.template select<flight>().from("flight").template fetch_all<flight>().begin();
  REQUIRE(f.id == 4);
  REQUIRE(f.pilot_name == "hans");
  REQUIRE(f.airplane.get() != nullptr);
  REQUIRE(f.airplane->id == 2);

  s.drop().table("flight").execute();
  s.drop().table("airplane").execute();
}