SqlPromise::SqlPromise(const QSqlQuery &query): m_state{std::make_shared<State>()}
{
    m_state->query = query;
}

SqlPromise *SqlPromise::executor(std::function<void (QSqlQuery&)> exec)
{
    m_state->execute = exec;
    return this;
}

SqlPromise *SqlPromise::then(std::function<void (QSqlQuery)> then)
{
    m_state->resolve = then;
    return this;
}

SqlPromise *SqlPromise::reject(ErrorHandler reject)
{
    m_state->reject = reject;
    return this;
}

void SqlPromise::execute()
{
    try {
        m_state->execute(m_state->query);
    } catch (...) {
        m_state->exception = std::current_exception();
    }
}

void SqlPromise::notify()
{
    if (m_state->exception) {
        if (m_state->reject) {
            m_state->reject(m_state->exception);
        } else {
            std::rethrow_exception(m_state->exception);
        }
    } else {
        if (m_state->resolve)
            m_state->resolve(m_state->query);
    }
}

DatabaseManager::DatabaseManager(QObject *parent): QObject(parent),
    m_context(new DBContext)
{
    connect(&m_dbThread, &QThread::finished, m_context, &DBContext::deleteLater);
    QObject::connect(this, &DatabaseManager::execute, m_context, [this](SqlPromise p){
        p.execute();
        emit this->ready(p);
    });
    QObject::connect(this, &DatabaseManager::execute, this, [](SqlPromise p){
        p.notify();
    });
}

DatabaseManager &DatabaseManager::instance()
{
    static DatabaseManager manager;
    return manager;
}

SqlPromise DatabaseManager::exec(std::function<void (QSqlQuery&)> exec)
{
    SqlPromise promise(m_context->makeQuery());
    promise.executor(exec);
    emit execute(promise);
    return promise;
}

std::function<void (QSqlQuery)> sqlErrorsChecker(std::function<void (QSqlQuery)> nextHandler,
                                                 ErrorWriterHandler reject)
{
    return [nextHandler, reject] (QSqlQuery q) {
        QSqlError lastErr = q.lastError();
        if (lastErr.type() == QSqlError::NoError) {
            if (nextHandler) nextHandler(q);
        } else {
            if (reject) {
                reject([lastErr](std::function<void(QString)> errorWriter) {
                    errorWriter(lastErr.text());
                });
            }
        }
    };
}

void executeQuery(std::function<void(QSqlQuery &)> executor,
                  std::function<void (QSqlQuery)> resolve,
                  ErrorWriterHandler reject)
{
    DatabaseManager::instance()
            .exec(executor)
            .then(sqlErrorsChecker(resolve, reject))
            ->reject([reject](std::exception_ptr ex){
        reject([ex](std::function<void(QString)> writer){
            writer("Unexpected error");
        });
    });
}