#include "SqliteDBLink.hpp"

#include <QtCore/QStringList>
#include <QtCore/QVariant>


#include <QtSql/QSqlQuery>
#include <QtSql/QSqlRecord>

#include "Exception/SQLException.hpp"
#include "Exception/IOException.hpp"

const QString SqliteDBLink::connectionName("SqliteDBLink");


SqliteDBLink::SqliteDBLink(const QString& dbPath)
{
  if (!QSqlDatabase::contains(connectionName))
    db = QSqlDatabase::addDatabase("QSQLITE", connectionName);
  else {
    db = QSqlDatabase::database(connectionName);
  }
  db.setDatabaseName(dbPath);
  if (!db.open())
    throw
      IOException(QString("Unable to open SQLite database with path '%1'")
		  .arg(dbPath));
  QSqlQuery query(db);
  if (!query.exec(QString("SELECT * FROM files;"))) {
    query.exec("CREATE TABLE files(path VARCHAR PRIMARY KEY ASC,"
	       " size INTEGER, mtime TEXT, checksum TEXT);");
  }
  if (!query.exec(QString("SELECT * FROM files;"))) {
    throw SQLException("No database");
  }

}

SqliteDBLink::~SqliteDBLink()
{
  db.close();
}

bool SqliteDBLink::exists(const QString& path)
{
  QSqlQuery query(db);
  query.prepare("SELECT path FROM files WHERE path = :path;");
  query.bindValue(":path", path);
  if (!query.exec()) {
    throw SQLException(query);
  }
  return query.last();
}

FileDBLink::DBStatus SqliteDBLink::existsWithMtime(const QString& path,
						   const QDateTime& mtime)
{
  QSqlQuery query(db);
  query.prepare("SELECT mtime FROM files WHERE path = :path;");
  query.bindValue(":path", path);
  if (!query.exec()) {
    throw SQLException(query);
  }
  if (query.next()) {
    int dateIndex = query.record().indexOf("mtime");
    QDateTime mtimeEntry = query.value(dateIndex).toDateTime();
    if (mtimeEntry == mtime)
      return SAME;
    return MTIME_DIFFERENT;
  }
  return NONE;
}

void SqliteDBLink::addFile(const QString& path, qint64 size,
			   const QDateTime& dtime, const QByteArray& hash)
{
  addFile(DBInfo(path, size, dtime, hash));
}

bool SqliteDBLink::tryAddFile(const DBInfo& dbinfo)
{
  if (exists(dbinfo.path()))
    return false;
  QSqlQuery query(db);
  query.prepare("INSERT INTO files (path, size, mtime, checksum) "
		"VALUES (:path, :size, :mtime, :checksum)");
  query.bindValue(":path", dbinfo.path());
  query.bindValue(":size", dbinfo.size());
  query.bindValue(":mtime", dbinfo.mtime());
  query.bindValue(":checksum", dbinfo.checksum());
  if (!query.exec()) {
    throw SQLException(query);
  }
  return true;
}

void SqliteDBLink::updateFile(const QString& path,
			      qint64 size, const QDateTime& dtime,
			      const QByteArray& hash)
{
  updateFile(DBInfo(path, size, dtime, hash));
}

void SqliteDBLink::updateFile(const DBInfo& dbinfo)
{
  QSqlQuery query(db);
  query.prepare("UPDATE files "
		"SET size=:size, mtime=:mtime, checksum=:checksum "
		"WHERE path=:path");
  query.bindValue(":path", dbinfo.path());
  query.bindValue(":size", dbinfo.size());
  query.bindValue(":mtime", dbinfo.mtime());
  query.bindValue(":checksum", dbinfo.checksum());
  if (!query.exec()) {
    throw SQLException(query);
  }
}

void SqliteDBLink::addFile(const DBInfo& dbinfo)
{
  if (!tryAddFile(dbinfo)) {
    abort(); //Should throw exception
  }
}


QStringList SqliteDBLink::toStringList()
{
  abort();
  QStringList list;
  /*
  foreach(dbinf_ptr_t info, entries) {
    list << info->serialize();
  }
  */
  return list;
}

const QList<FileDBLink::dbinf_ptr_t >
SqliteDBLink::values(const QString& prefix) const
{
  QList<FileDBLink::dbinf_ptr_t > values;

  QSqlQuery query(db);

  if (prefix.size() > 0) {
    query.prepare("SELECT * FROM files WHERE path LIKE :prefix");
    query.bindValue(":prefix", QString("%1%").arg(prefix));
  }
  else {
    query.prepare("SELECT * FROM files");
  }

  if (!query.exec()) {
    throw SQLException(query);
  }

  int pathIndex = query.record().indexOf("path");
  int sizeIndex = query.record().indexOf("size");
  int dateIndex = query.record().indexOf("mtime");
  int checksumIndex = query.record().indexOf("checksum");
  while (query.next()) {
    QString path = query.value(pathIndex).toString();
    qint64 size = query.value(sizeIndex).toInt();
    QDateTime mtime = query.value(dateIndex).toDateTime();
    QByteArray checksum = query.value(checksumIndex).toByteArray();

    values <<
      FileDBLink::dbinf_ptr_t(new FileDBLink::DBInfo(path,
						     size, mtime, checksum));
  }

  return values;
}

void SqliteDBLink::deleteFileFromDB(const QString& path)
{
  QSqlQuery query(db);
  query.prepare("DELETE FROM files WHERE path = :path");
  query.bindValue(":path", path);
  if (!query.exec()) {
    throw SQLException(query);
  }
}


void SqliteDBLink::keepOnlyFromPrefix(const QString& prefix,
				      const QStringList& files)
{
  QStringList list;
  foreach(dbinf_ptr_t info, values(prefix)) {
    if (!files.contains(info->path())) {
      list << info->path();
    }
  }
  foreach(QString path, list) {
    deleteFileFromDB(path);
  }
}

const QList<FileDBLink::dbinf_ptr_t> 
SqliteDBLink::filesWithSize(qint64 size, const QString& prefix) const
{
  //This is incredibly inefficient and should be reimplemented
  return FileDBLink::filesWithSize(size, prefix);
}