#ifndef DBCACHE_HPP
#define DBCACHE_HPP

#include "SQLGenerator.hpp"
#include "ThreadSafeLookup.hpp"

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

#include <QtCore/QStringList>

template<typename Key, typename Value>
struct InsertRegulator {
  static void start() {}
  static void finish() {}
  static void next() {}
};

template<typename Key, typename Value, bool memoryMapped = false>
class DBCache
{
private:
  ThreadSafeLookup<Key, Value> memoryMap;
  QList<Key> unsyncedKeys;

  void setup(const QSqlDatabase& db, const QString& dictName)
  {
    this->dictName = dictName;
    if (!db.tables().contains(dictName)) {
      QString keyFields = SQLGenerator<Key>::createFields("key");
      QString valueFields = SQLGenerator<Value>::createFields("value");
      QString createQuery =
	QString("CREATE TABLE %1(%2, %3);")
	.arg(dictName).arg(keyFields).arg(valueFields);
      QSqlQuery query(db);
      query.exec(createQuery);
    }
    if (!db.tables().contains(dictName)) {
      throw SQLException("No databaase");
    }
    if (memoryMapped) {
      QString keyFields = SQLGenerator<Key>::fieldName("key");
      QString valueFields = SQLGenerator<Value>::fieldName("value");
      QString repopulateQuery =
	QString("SELECT %1, %2 FROM %3;")
	.arg(keyFields).arg(valueFields).arg(dictName);
      QSqlQuery query(db);
      if (!query.exec(repopulateQuery)) {
	throw SQLException(query);
      }
      InsertRegulator<Key, Value> regulator;
      regulator.start();
      while (query.next()) {
	Key key = *SQLGenerator<Key>::extract(query, "key");
	Value value = *SQLGenerator<Value>::extract(query, "value");
	memoryMap.insert(key, value);
	regulator.next();
      }
      regulator.finish();
    }
    QString queryString = QString("INSERT into %1 (%2, %3) VALUES(%4, %5);")
      .arg(dictName)
      .arg(SQLGenerator<Key>::fieldName("key"))
      .arg(SQLGenerator<Value>::fieldName("value"))
      .arg(SQLGenerator<Key>::valueString("key"))
      .arg(SQLGenerator<Value>::valueString("value"));
    insertQuery = QSqlQuery(db);
    insertQuery.prepare(queryString);
  }

  void syncInsert()
  {
    SQLGenerator<Key>::bindValues(insertQuery, unsyncedKeys, "key");
    QList<Value> values;
    foreach(Key key, unsyncedKeys) {
      values << *memoryMap.value(key);
    }
    SQLGenerator<Value>::bindValues(insertQuery, values, "value");
    if (!insertQuery.execBatch()) {
      throw SQLException(insertQuery);
    }
    insertQuery.finish();
    unsyncedKeys.clear();
  }

public:
  DBCache(const QString& dbName, const QString& dictName)
  {
    db = QSqlDatabase::addDatabase("QSQLITE", "dictName");
    db.setDatabaseName(dbName);
    if (!db.open())
      throw
	IOException(QString("Unable to open SQLite database with path '%1'")
		    .arg(dictName));
    setup(db, dictName);
  }

  DBCache(const QSqlDatabase& db, const QString& dictName)
  {
    setup(db, dictName);
  }

  boost::optional<Value> value(const Key& key) const
  {
    if (memoryMapped) {
      return memoryMap.value(key);
    }
    else {
      QString queryString = QString("SELECT %1 FROM %2 WHERE %3")
	.arg(SQLGenerator<Value>::fieldName("value"))
	.arg(dictName)
	.arg(SQLGenerator<Key>::restriction("key"));
      QSqlQuery query(db);
      query.prepare(queryString);
      SQLGenerator<Key>::bindValue(query, key, "key");
      if (!query.exec()) {
	throw SQLException(query);
      }
      query.next();
      return SQLGenerator<Value>::extract(query, "value");
    }
  }

  void insert(const Key& key, const Value& value)
  {
    if (memoryMapped) {
      memoryMap.insert(key, value);
      unsyncedKeys.append(key);
      if (unsyncedKeys.size() >= 1024) {
	syncInsert();
      }
    }
    else {
      SQLGenerator<Key>::bindValue(insertQuery, key, "key");
      SQLGenerator<Value>::bindValue(insertQuery, value, "value");
      if (!insertQuery.exec()) {
	throw SQLException(insertQuery);
      }
      insertQuery.finish();
    }

  }

private:
  QSqlDatabase db;
  QString dictName;
  QSqlQuery insertQuery;
};

#endif //DBCACHE_HPP