#include "database_manager.h"

#include "config.h"
#include "execute_sql_file.h"
#include <QFile>
#include <QSqlError>
#include <qsqldatabase.h>

DatabaseManager::~DatabaseManager() {
  disconnectDefaultDatabase();

  QString defaultConnectionName = QSqlDatabase::database().connectionName();
  QSqlDatabase::removeDatabase(QSqlDatabase::database().connectionName());

  qInfo() << "Database with default connection name:" << defaultConnectionName
          << "was removed";
}

DatabaseManager::CreateDatabaseResult
DatabaseManager::createDefaultDatabaseIfMissing(
    const QString &databaseFileName) {
  if (QFile::exists(databaseFileName)) {
    qInfo()
        << "Database file name already exists and will not be created again:"
        << databaseFileName;
    return CreateDatabaseResult::AlreadyExists;
  }

  if (!connectToDefaultDatabase(databaseFileName)) {
    qWarning() << "Failed to create and connect to the database";
    return CreateDatabaseResult::Error;
  }

  // Execute SQL files to initialize the database
  QStringList sqlFiles = {":/sql/create_tables.sql", ":/sql/create_indexes.sql",
                          ":/sql/create_views.sql", ":/sql/create_triggers.sql",
                          ":/sql/insert_role.sql"};

#ifndef NDEBUG
  QStringList additionalSqlFiles = {
      ":/sql/insert_genre.sql", ":/sql/insert_hall.sql",
      ":/sql/insert_movie.sql", ":/sql/insert_user.sql"};
  sqlFiles.append(additionalSqlFiles);
#endif

  QSqlDatabase defaultDatabase = QSqlDatabase::database();
  bool success = executeSqlFiles(sqlFiles, defaultDatabase);
  disconnectDefaultDatabase();

  if (success) {
    qInfo() << "Database created and initialized successfully";
    return CreateDatabaseResult::Success;
  }

  qWarning() << "Failed to execute initialization SQL files";

  if (QFile::remove(databaseFileName)) {
    qInfo() << "Database file deleted due to initialization failure:"
            << databaseFileName;
  } else {
    qWarning() << "Failed to delete database file:" << databaseFileName;
  }

  return CreateDatabaseResult::Error;
}

bool DatabaseManager::connectToDefaultDatabase(
    const QString &databaseFileName) {
  QSqlDatabase defaultDatabase = QSqlDatabase::database();

  defaultDatabase.setDatabaseName(databaseFileName);
  if (defaultDatabase.isValid() && defaultDatabase.isOpen()) {
    qInfo() << "Database is already connected";
    return true;
  }

  // Constructor does not open/close the connection
  defaultDatabase = QSqlDatabase::addDatabase(DATABASE_DRIVER);
  defaultDatabase.setDatabaseName(databaseFileName);

  if (!defaultDatabase.open()) {
    qWarning() << "Failed to connect to the database:" << databaseFileName;
    return false;
  }

  qDebug() << "Database was connected successfully: Connection name:"
           << defaultDatabase.connectionName();

  return true;
}

void DatabaseManager::disconnectDefaultDatabase() {
  QSqlDatabase defaultDatabase = QSqlDatabase::database();
  if (defaultDatabase.isOpen()) {
    defaultDatabase.close();
    qInfo() << "Database disconnected";
  }
}

bool DatabaseManager::executeSqlFiles(const QStringList &filePaths,
                                      QSqlDatabase &database) {
  ExecuteSqlFile executor(database);
  for (const QString &filePath : filePaths) {
    qInfo() << "Executing SQL file:" << filePath;
    if (!executor(filePath)) {
      qWarning() << "Failed to execute SQL file:" << filePath;
      return false;
    }
  }
  return true;
}