// SPDX-FileCopyrightText: 2022 Jonah Brüchert <jbb@kaidan.im>
//
// SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL

#pragma once

class QUrl;
class QSqlDatabase;

#include <QString>
#include <QObject>
#include <QFuture>
#include <QSharedDataPointer>

#include <memory>
#include <optional>
#include <tuple>
#include <vector>

#include "threadeddatabase_p.h"

#include <futuresql_export.h>

struct DatabaseConfigurationPrivate;

///
/// Selection of database types.
/// If the required one is not included, use the DatabaseConfiguration::setType QString overload instead.
///
enum DatabaseType {
    SQLite
};

///
/// Options for connecting to a database
///
class FUTURESQL_EXPORT DatabaseConfiguration {
public:
    DatabaseConfiguration();
    DatabaseConfiguration(const DatabaseConfiguration &);
    ~DatabaseConfiguration();

    /// Set the name of the database driver. If it is included in DatabaseType, use the enum overload instead
    void setType(const QString &type);
    /// Set the type of database. If DatabaseType doesn't include the one you need, use the QString overload instead
    void setType(DatabaseType type);
    /// Get the name of the database driver
    const QString &type() const;

    /// Set the hostname
    void setHostName(const QString &hostName);
    const std::optional<QString> &hostName() const;

    /// Set the name of the database (path of the file for SQLite)
    void setDatabaseName(const QString &databaseName);
    const std::optional<QString> &databaseName() const;

    /// Set user name
    void setUserName(const QString &userName);
    const std::optional<QString> &userName() const;

    /// Set password
    void setPassword(const QString &password);
    const std::optional<QString> &password() const;

private:
    QSharedDataPointer<DatabaseConfigurationPrivate> d;
};

template <typename T>
concept FromSql = requires(T v, typename T::ColumnTypes row)
{
    typename T::ColumnTypes;
    { std::tuple(row) } -> std::same_as<typename T::ColumnTypes>;
};

namespace detail {

template <typename ...Args>
constexpr bool isQVariantConvertible = std::conjunction_v<std::is_convertible<Args, QVariant>...>;

}

struct ThreadedDatabasePrivate;

///
/// A database connection that lives on a new thread
///
class FUTURESQL_EXPORT ThreadedDatabase : public QThread {
public:
    ///
    /// \brief Connect to a database
    /// \param config Configuration of the database connection
    /// \return
    ///
    static std::unique_ptr<ThreadedDatabase> establishConnection(const DatabaseConfiguration &config);

    ///
    /// \brief Execute an SQL query on the database, ignoring the result.
    /// \param sqlQuery SQL query string to execute
    /// \param args Parameters to bind to the placeholders in the SQL Query
    /// \return
    ///
    template <typename ...Args>
    requires detail::isQVariantConvertible<Args...>
    auto execute(const QString &sqlQuery, Args... args) -> QFuture<void> {
        return db().execute(sqlQuery, args...);
    }

    ///
    /// Run the database migrations in the given directory.
    /// The directory needs to contain a subdirectory for each migration.
    /// The subdirectories need to be named so that when sorted alphabetically the migrations will be run in the correct order.
    /// Each subdirectory needs to contain a file named up.sql.
    ///
    /// \param migrationDirectory Directory which contains the migrations.
    /// \return a future that finishes when the database changes are finished
    ///
    auto runMigrations(const QString &migrationDirectory) -> QFuture<void>;

    ///
    /// Declare that the database is currently at the state of the migration in the migration subdirectory
    /// migrationName.
    ///
    /// The automatic migrations will then start with all migrations that are newer than migrationName.
    ///
    /// @warning This function should only be used for the initial switch from a different migration system, for example a custom made one.
    /// \param migrationName
    /// \return a future that finishes when the database changes are finished
    ///
    auto setCurrentMigrationLevel(const QString &migrationName) -> QFuture<void>;

    ///
    /// \brief Execute an SQL query on the database, retrieving the result.
    /// \param sqlQuery SQL Query to execute
    /// \param args Parameters to bind to the placeholders in the SQL query.
    /// \return Future of a list of lists of variants.
    ///
    /// T must provide a tuple of the column types as `using ColumnTypes = std::tuple<...>`
    /// and a, if the column types are not the same types in the same order as the attributes of the struct,
    /// a `static T fromSql(ColumnTypes tuple)` deserialization method.
    ///
    template <typename T, typename ...Args>
    requires FromSql<T> && detail::isQVariantConvertible<Args...>
    auto getResults(const QString &sqlQuery, Args... args) -> QFuture<std::vector<T>> {
        return db().getResults<T, Args...>(sqlQuery, args...);
    }

    ///
    /// \brief Like getResults, but for retrieving just one row.
    /// \param sqlQuery SQL Query to execute
    /// \param args Parameters to bind to the placeholders in the SQL query.
    ///
    template <typename T, typename ...Args>
    requires FromSql<T> && detail::isQVariantConvertible<Args...>
    auto getResult(const QString &sqlQuery, Args... args) -> QFuture<std::optional<T>> {
        return db().getResult<T, Args...>(sqlQuery, args...);
    }

    ///
    /// \brief Run a custom function on the database thread. The function is passed the internal QSqlDatabase.
    /// \param func A function that takes a QSqlDatabase
    /// \return The result of the function, wrapped in a QFuture
    ///
    template <typename Func>
    requires std::is_invocable_v<Func, const QSqlDatabase &>
    auto runOnThread(Func &&func) -> QFuture<std::invoke_result_t<Func, const QSqlDatabase &>> {
        return db().runOnThread(std::move(func));
    }

    ~ThreadedDatabase();

private:
    ThreadedDatabase();

    asyncdatabase_private::AsyncSqlDatabase &db();

    std::unique_ptr<ThreadedDatabasePrivate> d;
};

///
/// \brief Deserialize just a single value from a query result.
///
template <typename T>
struct SingleValue {
    using ColumnTypes = std::tuple<T>;

    static SingleValue fromSql(ColumnTypes tuple) {
        auto [value] = tuple;
        return SingleValue { value };
    }

    operator const T &() const {
        return value;
    }

    T value;
};