#include "work/admin/CollectionCenter.hpp"
#include "work/admin/InternalUserDirectory.hpp"
#include "work/admin/LdapGroupSchemaSettings.hpp"
#include "work/admin/LdapImportSettings.hpp"
#include "work/admin/LdapUserDirectory.hpp"
#include "work/admin/LdapUserSchemaSettings.hpp"
#include "work/admin/LoginHistory.hpp"
#include "work/admin/Scenario.hpp"
#include "work/admin/User.hpp"
#include "work/admin/UserDirectory.hpp"
#include "work/admin/UserSession.hpp"

#include "work/jobs/Job.hpp"
#include "work/jobs/Task.hpp"
#include "work/jobs/Payload.hpp"
#include "work/jobs/IdPayload.hpp"
#include "work/jobs/IdListPayload.hpp"

#include "matador/utils/default_type_traits.hpp"
#include "matador/object/repository.hpp"

#include "matador/sql/connection.hpp"

#include "matador/query/schema.hpp"

#include "matador/orm/session.hpp"

template <> struct matador::utils::data_type_traits<work::core::UserInfo, void> {
    static basic_type type(std::size_t /*size*/) { return basic_type::UInt64; }
    static void read_value(attribute_reader &/*reader*/, const char * /*id*/, size_t /*index*/, work::core::UserInfo &/*value*/) {

    }
    static void bind_value(attribute_writer &/*binder*/, size_t /*index*/, work::core::UserInfo &/*value*/) {

    }
};

using namespace matador;
using namespace work::models;

// Proposal for polymorphic classes:
// object_ptr::as<Type> does the following checks;
//
// 1. The requested type has super class
// 2. Super class has discriminator column defined
// 3. Super class has discriminator value defined
// 4. Discriminator value is mapped to the requested type
//
// If all checks succeed, the requested is fetched from
// the database.
// schema.attach_as_base<jobs::Payload>("payloads", make_polymorph("type"));
// schema.attach<jobs::Payload, jobs::IdPayload>("id_list_payloads", make_polymorph_type("IdPayload"));
// schema.attach<jobs::Payload, jobs::IdListPayload>("id_payloads", make_polymorph_type("IdListPayload"));
// object::object_ptr<jobs::Payload> payload;
// auto result = payload.as<jobs::IdPayload>();
// if (result.is_ok()) {
//     const auto& is_payload = result.value();
//     // Use requested type
//     id_payload->id = 1;
// }
// payload.is_polymorphic();
// payload.is_polymorphic_type<jobs::IdPayload>();

int main() {
    logger::default_min_log_level(logger::log_level::LVL_DEBUG);
    logger::add_log_sink(logger::create_stdout_sink());

    // sql::connection_pool<sql::connection> pool("postgres://news:news@127.0.0.1:15432/matador", 4);
    sql::connection_pool pool("postgres://test:test123!@127.0.0.1:15442/matador", 4);

    utils::message_bus bus;
    // query::schema ses({bus, pool});
    query::schema admin_schema("Administration");

    auto result = admin_schema.attach<admin::CollectionCenter>("collection_centers")
        .and_then([&admin_schema] { return admin_schema.attach<admin::UserDirectory>("user_directories"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::LdapGroupSchemaSettings>("ldap_group_schema_settings"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::LdapImportSettings>("ldap_import_settings"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::LdapUserSchemaSettings>("ldap_user_schema_settings"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::InternalUserDirectory, admin::UserDirectory>("internal_user_directories"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::LdapUserDirectory, admin::UserDirectory>("ldap_user_directories"); } )
        .and_then([&admin_schema] { return admin_schema.attach<admin::LoginHistory>("login_histories"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::Scenario>("scenarios"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::User>("users"); })
        .and_then([&admin_schema] { return admin_schema.attach<admin::UserSession>("user_sessions"); })
        .and_then([&admin_schema] { return admin_schema.attach<jobs::Job>("jobs"); })
        .and_then([&admin_schema] { return admin_schema.attach<jobs::Payload>("payloads"); })
        .and_then([&admin_schema] { return admin_schema.attach<jobs::IdPayload, jobs::Payload>("id_list_payloads"); })
        .and_then([&admin_schema] { return admin_schema.attach<jobs::IdListPayload, jobs::Payload>("id_payloads"); })
        .and_then([&admin_schema] { return admin_schema.attach<jobs::Task>("tasks"); })
    ;
    admin_schema.dump(std::cout);

    if (!result) {
        std::cout << "error: " << result.err().message() << std::endl;
        return 0;
    }

    const auto conn = pool.acquire();
    // result = admin_schema.create(*conn);
    // if (!result) {
    //     std::cout << "error: " << result.err() << std::endl;
    //     return 0;
    // }
    // result = admin_schema.drop(*conn);
    // if (!result) {
    //     std::cout << "error: " << result.err() << std::endl;
    //     return 0;
    // }

/*
  *        const auto statement = QString( "SELECT %5.%6, %1.%2 FROM %3 %1, %4 %5 WHERE %1.%2=%5.%6 AND %7" )
  .arg( payloadTableAliasName,
  payloadSqlMetaInfo.columnName( Payload::Attributes::idAttributeId() ),
  Payload::staticSqlMetaInfo().tableName(),
  Task::staticSqlMetaInfo().tableName(),
  taskTableAliasName,
  taskSqlMetaInfo.columnName( Task::Attributes::payloadAttributeId() ),
  filter->idSelectStatement( taskTableAliasName ) );
*/

  using namespace matador::query::meta;
  using namespace matador::utils;
  const auto payloads = PAYLOAD.as( "payloads" );
  const auto tasks = TASK.as( "tasks" );
  const auto stmt1 = query:: query::select( { tasks.payload, payloads.id } )
    .from( tasks, payloads )
    .where ( payloads.id == tasks.payload )
    .str( conn->dialect() );


  /*
  const auto temporaryTable = status.addChildExc( fillTemporaryTable( idsInsidePayload ) );
  const auto lookUpTableName = temporaryTable->tableName();

  const auto& jobSqlMetaInfo = Job::staticSqlMetaInfo();
  const auto& payloadSqlMetaInfo = Payload::staticSqlMetaInfo();
  const auto& idPayloadSqlMetaInfo = IdPayload::staticSqlMetaInfo();

  const auto statement = QString( "SELECT iPT.%1 FROM %2 iPT INNER JOIN %3 pT ON iPT.%4 = pT.%5 WHERE pT.%5 IN (SELECT %6 FROM %7 WHERE %8=?) AND iPT.%1 IN (SELECT %9 FROM %10)" )
                         .arg( idPayloadSqlMetaInfo.columnName( IdPayload::Attributes::payloadIdAttributeId() ) ) // %1
                         .arg( idPayloadSqlMetaInfo.tableName() ) // %2
                         .arg( payloadSqlMetaInfo.tableName() ) // %3
                         .arg( idPayloadSqlMetaInfo.columnName( IdPayload::Attributes::idAttributeId() ) ) // %4
                         .arg( payloadSqlMetaInfo.columnName( Payload::Attributes::idAttributeId() ) ) // %5
                         .arg( jobSqlMetaInfo.columnName( Job::Attributes::payloadAttributeId() ) ) // %6
                         .arg( jobSqlMetaInfo.tableName() ) // %7
                         .arg( jobSqlMetaInfo.columnName( Job::Attributes::stateSqlAttributeId() ) ) // %8
                         .arg( lookUpColName() ) // %9
                         .arg( lookUpTableName ); // %10
  */

  query::table_column temp_id_col("ID");
  query::table temporary("TempTable", { temp_id_col } );

  const auto iPT = ID_PAYLOAD.as("iPT");
  const auto pT = PAYLOAD.as("pT");

  const auto stmt2 = query::query::select({ iPT.payload_id })
    .from( iPT )
    .join_left( pT ).on( iPT.id == pT.id )
    .where(
      in( pT.id, query::query::select({ JOB.payload }).from( JOB ).where( JOB.state == _) ) &&
      in( iPT.payload_id, query::query::select({ temp_id_col }).from( temporary ) )
    )
  .str( conn->dialect() );

      // const QString statement = QString( "SELECT %5 FROM %1 "
      //                                  "LEFT JOIN (SELECT %2, MAX(%3) AS lastSuccessfulLogin FROM %1 WHERE %4 = ? GROUP BY %2) ll "
      //                                  "ON %1.%2 = ll.%2 "
      //                                  "WHERE (lastSuccessfulLogin IS NULL OR %3 <= lastSuccessfulLogin) AND %3 < ?" )
      //                         .arg( LoginHistory::staticSqlMetaInfo().tableName() )
      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::userAttributeId() ) )
      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::timestampAttributeId() ) )
      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::failReasonSqlAttributeId() ) )
      //                         .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::idAttributeId() ) );

  const auto q = query::query::select({LOGIN_HISTORY.client, query::max(LOGIN_HISTORY.login_time).as( "lastSuccessfulLogin" ) } )
    .from( LOGIN_HISTORY )
    .where( LOGIN_HISTORY.fail_reason == _ )
    .group_by( LOGIN_HISTORY.client );
    // .as_table("ll");

  const auto stmt3 = query::query::select({ LOGIN_HISTORY.client })
    .from( LOGIN_HISTORY )
    .join_left(q/*, "ll"*/ )
    .on( LOGIN_HISTORY.client == "ll.client" )
    .where( query::is_null("lastSuccessfulLogin") && LOGIN_HISTORY.login_time < "ll.lastSuccessfulLogin" )
    .str( conn->dialect() );

  std::cout << stmt1 << std::endl;
  std::cout << stmt2 << std::endl;
  std::cout << stmt3 << std::endl;

  // const QString subQuery = QString( "SELECT MAX(%1) AS lastSuccessfulLogin, %3 FROM %2 "
  //                                 "WHERE(%4 = ? OR %4 = ? OR %4 = ?) AND %3 = ? GROUP BY %3 " );
  //
  // const QString statement = QString( "SELECT MAX(t1.%1) AS LAST_FAILED_LOGIN FROM %2 t1 LEFT JOIN"
  //                                    "(%0) t2 "
  //                                    "ON t1.%3 = t2.%3 "
  //                                    "WHERE(t2.lastSuccessfulLogin IS NULL OR t2.lastSuccessfulLogin < t1.%1) "
  //                                    "AND (t1.%4 = ? OR t1.%4 = ?) "
  //                                    "AND t1.%3 = ?" )
  //                           .arg( subQuery )
  //                           .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::timestampAttributeId() ) )
  //                           .arg( LoginHistory::staticSqlMetaInfo().tableName() )
  //                           .arg( columnFilterName )
  //                           .arg( LoginHistory::staticSqlMetaInfo().columnName( LoginHistory::Attributes::failReasonSqlAttributeId() ) );
  //
  // QSqlQuery query( sqlDatabase() );
  // if ( query.prepare( statement ) ) {
  //   query.addBindValue( LoginHistory::FailReason::NoFailReason );
  //   query.addBindValue( LoginHistory::FailReason::NoScenarioForUser );
  //   query.addBindValue( LoginHistory::FailReason::UserLockedByAdmin );
  //   query.addBindValue( columnFilterValue );
  //   query.addBindValue( LoginHistory::FailReason::WrongPassword );
  //   query.addBindValue( LoginHistory::FailReason::UnknownUserName );
  //   query.addBindValue( columnFilterValue );

  return 0;
}

/*
SELECT
  "tasks"."payload", "payloads"."id"
FROM
  "public"."tasks", "public"."payloads"
WHERE
  "payloads"."id" = "tasks"."payload"

SELECT
  "iPT"."payload_id" FROM "public"."id_payloads" "iPT"
LEFT JOIN
  "public"."payloads" "pT"
ON
  "iPT"."id" = "pT"."id"
WHERE ("pT"."id" IN (
  SELECT
    "jobs"."payload"
  FROM
    "public"."jobs"
  WHERE
    "jobs"."state" = $1
  ) AND "iPT"."payload_id" IN (
  SELECT
    "ID"
  FROM "public"."TempTable"
  )
)

SELECT
  "login_histories"."client"
FROM
  "public"."login_histories"
LEFT JOIN (
  SELECT
    "login_histories"."client", MAX(login_time) AS lastSuccessfulLogin
  FROM
    "public"."login_histories"
  WHERE
    "login_histories"."fail_reason" = $1
  GROUP BY
    "login_histories"."client"
  )
ON
  "login_histories"."client" = 'll.client'
WHERE
  ("lastSuccessfulLogin" IS NULL AND "login_histories"."login_time" < 'll.lastSuccessfulLogin')
*/