#include "table_info_sqlite.h"

#include <QDebug>
#include <QMetaType>
#include <QSqlError>

TableInfoSQLite::TableInfoSQLite() : databaseTableName_("") {}

TableInfoSQLite::TableInfoSQLite(const QString &databaseTableName)
    : databaseTableName_(databaseTableName) {
  loadColumnInfo();
}

void TableInfoSQLite::loadColumnInfo() {
  QSqlDatabase defaultDatabase = QSqlDatabase::database();

  if (!defaultDatabase.isValid()) {
    qCritical() << "TableInfoSQLite::loadColumnInfo: Database is invalid";
  }

  if (!defaultDatabase.isOpen()) {
    qCritical() << "TableInfoSQLite::loadColumnInfo: Database is not open";

    databaseTableName_.clear();
    columnNames_.clear();
    columnTypes_.clear();
    isPrimaryKey_.clear();

    return;
  }

  QSqlQuery query(defaultDatabase);
  query.prepare(QString("PRAGMA table_info(%1)").arg(databaseTableName_));

  if (!query.exec()) {
    qWarning() << "Failed to get table info: Error:" << query.lastError().text()
               << "Database table name:" << databaseTableName_;

    return;
  }

  while (query.next()) {
    columnNames_.append(query.value("name").toString());
    columnTypes_.append(query.value("type").toString());
    isPrimaryKey_.append(query.value("pk").toInt() > 0);
  }
}

QString TableInfoSQLite::databaseTableName() const noexcept {
  return databaseTableName_;
}

QString
TableInfoSQLite::foreignKeyTable(const QString &columnName) const noexcept {
  if (databaseTableName_.isEmpty()) {
    qWarning() << "TableInfoSQLite::foreignKeyTable: No table name set";
    return QString();
  }

  QSqlDatabase defaultDatabase = QSqlDatabase::database();
  if (!defaultDatabase.isOpen()) {
    qCritical() << "TableInfoSQLite::foreignKeyTable: Database is not open";
    return QString();
  }

  QSqlQuery query(defaultDatabase);
  query.prepare(QString("PRAGMA foreign_key_list(%1)").arg(databaseTableName_));

  if (!query.exec()) {
    qWarning() << "Failed to get foreign key info:" << query.lastError().text();
    return QString();
  }

  while (query.next()) {
    QString fkColumn = query.value("from").toString();
    QString referencedTable = query.value("table").toString();

    if (fkColumn == columnName) {
      return referencedTable;
    }
  }

  return QString();
}

QStringList TableInfoSQLite::columnNames() const noexcept {
  return QStringList(columnNames_.begin(), columnNames_.end());
}

bool TableInfoSQLite::isPrimaryKey(const QString &columnName) const noexcept {
  int index = columnIndex(columnName);
  if (index == -1) {
    return false;
  }
  return isPrimaryKey_.at(index);
}

qint32 TableInfoSQLite::columnIndex(const QString &columnName) const noexcept {
  return columnNames_.indexOf(columnName);
}

QString TableInfoSQLite::columnName(qint32 columnIndex) const noexcept {
  if (columnIndex < 0 || columnIndex >= columnNames_.size()) {
    return QString();
  }
  return columnNames_.at(columnIndex);
}

QMetaType::Type
TableInfoSQLite::columnMetaType(const QString &columnName) const noexcept {
  int index = columnIndex(columnName);
  if (index == -1) {
    return QMetaType::UnknownType;
  }

  QString typeName = columnTypes_.at(index).toLower();

  if (typeName.contains("int")) {
    return QMetaType::Int;
  } else if (typeName.contains("double") || typeName.contains("real") ||
             typeName.contains("float")) {
    return QMetaType::Double;
  } else if (typeName.contains("date") || typeName.contains("time")) {
    return QMetaType::QDateTime;
  } else if (typeName.contains("bool")) {
    return QMetaType::Bool;
  } else if (typeName.contains("blob")) {
    return QMetaType::QByteArray;
  } else {
    return QMetaType::QString;
  }
}

void TableInfoSQLite::setDatabaseTableName(
    const QString &databaseTableName) noexcept {
  databaseTableName_ = databaseTableName;
  loadColumnInfo();
}