/*
Copyright Contributors to the libdnf project.

This file is part of libdnf: https://github.com/rpm-software-management/libdnf/

Libdnf is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.

Libdnf is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with libdnf.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef LIBDNF5_UTILS_SQLITE3_SQLITE3_HPP
#define LIBDNF5_UTILS_SQLITE3_SQLITE3_HPP

#include "libdnf5/common/exception.hpp"

#include <sqlite3.h>

#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>


namespace libdnf5::utils {

class SQLite3Error : public Error {
public:
    using Error::Error;
    const char * get_domain_name() const noexcept override { return "libdnf5::utils"; }
    const char * get_name() const noexcept override { return "SQLite3Error"; }
};

class SQLite3SQLError : public SQLite3Error {
public:
    /// @param error_code The `error_code` of the error.
    /// @param format The format string for the message.
    /// @param args The format arguments.
    template <typename... Ss>
    explicit SQLite3SQLError(int error_code, BgettextMessage format, Ss &&... args)
        : SQLite3Error(format, std::forward<Ss>(args)...),
          error_code(error_code) {}

    const char * what() const noexcept override;

    const char * get_name() const noexcept override { return "SQLite3SQLError"; }

    /// @return The SQLite3 error code of the error.
    int get_error_code() const noexcept { return error_code; }

    /// @return The error message associated with the SQLite3 error code.
    const char * get_error_message() const noexcept { return sqlite3_errstr(error_code); }

protected:
    int error_code;
};


/// An error class that will log the SQL statement in its constructor.
class SQLite3StatementSQLError : public SQLite3SQLError {
public:
    using SQLite3SQLError::SQLite3SQLError;
    const char * get_name() const noexcept override { return "SQLite3StatementSQLError"; }
};


class SQLite3 {
public:
    struct Blob {
        size_t size;
        const void * data;
    };

    class Statement {
    public:
        enum class StepResult { DONE, ROW, BUSY };

        Statement(const Statement &) = delete;
        Statement & operator=(const Statement &) = delete;

        Statement(SQLite3 & db, const char * sql) : db(db) {
            auto result = sqlite3_prepare_v2(db.db, sql, -1, &stmt, nullptr);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_compilation_failed, std::string(sql));
            }
        };

        Statement(SQLite3 & db, const std::string & sql) : db(db) {
            auto result = sqlite3_prepare_v2(db.db, sql.c_str(), static_cast<int>(sql.length()) + 1, &stmt, nullptr);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_compilation_failed, sql);
            }
        };

        void bind(int pos, int val) {
            auto result = sqlite3_bind_int(stmt, pos, val);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_int_failed, get_expanded_sql());
            }
        }

        void bind(int pos, std::int64_t val) {
            auto result = sqlite3_bind_int64(stmt, pos, val);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_int64_failed, get_expanded_sql());
            }
        }

        void bind(int pos, std::uint32_t val) {
            // SQLite doesn't support storing unsigned ints, for 32 bit unsigned bind,
            // we can just use the 64 bit version, it all converts to a single
            // signed INTEGER type in the DB
            auto result = sqlite3_bind_int64(stmt, pos, static_cast<int64_t>(val));
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_uint32_failed, get_expanded_sql());
            }
        }

        void bind(int pos, double val) {
            auto result = sqlite3_bind_double(stmt, pos, val);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_double_failed, get_expanded_sql());
            }
        }

        void bind(int pos, bool val) {
            auto result = sqlite3_bind_int(stmt, pos, val ? 1 : 0);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_bool_failed, get_expanded_sql());
            }
        }

        void bind(int pos, const char * val) {
            auto result = sqlite3_bind_text(stmt, pos, val, -1, SQLITE_TRANSIENT);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_text_failed, get_expanded_sql());
            }
        }

        void bind(int pos, const std::string & val) {
            auto result = sqlite3_bind_text(stmt, pos, val.c_str(), -1, SQLITE_TRANSIENT);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_text_failed, get_expanded_sql());
            }
        }

        void bind(int pos, const Blob & val) {
            auto result = sqlite3_bind_blob(stmt, pos, val.data, static_cast<int>(val.size), SQLITE_TRANSIENT);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_blob_failed, get_expanded_sql());
            }
        }

        void bind(int pos, const std::vector<unsigned char> & val) {
            auto result = sqlite3_bind_blob(stmt, pos, val.data(), static_cast<int>(val.size()), SQLITE_TRANSIENT);
            if (result != SQLITE_OK) {
                throw SQLite3StatementSQLError(result, msg_bind_blob_failed, get_expanded_sql());
            }
        }

        template <typename... Args>
        Statement & bindv(Args &&... args) {
            using Pass = int[];
            int pos{0};
            (void)Pass{(bind(++pos, args), 0)...};
            return *this;
        }

        StepResult step() {
            auto result = sqlite3_step(stmt);
            switch (result) {
                case SQLITE_DONE:
                    return StepResult::DONE;
                case SQLITE_ROW:
                    return StepResult::ROW;
                case SQLITE_BUSY:
                    return StepResult::BUSY;
                default:
                    throw SQLite3StatementSQLError(result, msg_eval_failed, get_expanded_sql());
            }
        }

        int get_column_count() const { return sqlite3_column_count(stmt); }

        const char * get_column_database_name(int idx) const { return sqlite3_column_database_name(stmt, idx); }

        const char * get_column_table_name(int idx) const { return sqlite3_column_table_name(stmt, idx); }

        const char * get_column_origin_name(int idx) const { return sqlite3_column_origin_name(stmt, idx); }

        const char * get_column_name(int idx) const { return sqlite3_column_name(stmt, idx); }

        const char * get_sql() const { return sqlite3_sql(stmt); }

        const std::string get_expanded_sql() {
#if SQLITE_VERSION_NUMBER < 3014000
            // sqlite3_expanded_sql was added in sqlite 3.14; return sql instead
            return get_sql();
#else
            char * expanded_sql = sqlite3_expanded_sql(stmt);
            if (!expanded_sql) {
                throw SQLite3Error(msg_insufficient_memory);
            }
            std::string result(expanded_sql);
            sqlite3_free(expanded_sql);
            return result;
#endif
        }

        /// Reset prepared query to its initial state, ready to be re-executed.
        /// All the bound values remain untouched - retain their values.
        /// Use clearBindings if you need to reset them as well.
        void reset() { sqlite3_reset(stmt); }

        void clear_bindings() { sqlite3_clear_bindings(stmt); }

        template <typename T>
        T get(int idx) {
            return get(idx, Identity<T>{});
        }

        int64_t last_insert_rowid() { return db.last_insert_rowid(); }

        SQLite3 & get_db() const { return db; }

        ~Statement() { sqlite3_finalize(stmt); };

    protected:
        template <typename T>
        struct Identity {
            typedef T type;
        };

        /*template<typename TL>
        TL get(size_t, identity<TL>)
        {
            static_assert(sizeof(TL) == 0, "Not implemented");
        }*/

        int get(int idx, Identity<int> /*unused*/) { return sqlite3_column_int(stmt, idx); }

        uint32_t get(int idx, Identity<uint32_t> /*unused*/) {
            return static_cast<uint32_t>(sqlite3_column_int64(stmt, idx));
        }

        int64_t get(int idx, Identity<int64_t> /*unused*/) { return sqlite3_column_int64(stmt, idx); }

        double get(int idx, Identity<double> /*unused*/) { return sqlite3_column_double(stmt, idx); }

        bool get(int idx, Identity<bool> /*unused*/) { return sqlite3_column_int(stmt, idx) != 0; }

        const char * get(int idx, Identity<const char *> /*unused*/) {
            return reinterpret_cast<const char *>(sqlite3_column_text(stmt, idx));
        }

        std::string get(int idx, Identity<std::string> /*unused*/) {
            auto ret = reinterpret_cast<const char *>(sqlite3_column_text(stmt, idx));
            return ret ? ret : "";
        }

        Blob get(int idx, Identity<Blob> /*unused*/) {
            return {static_cast<size_t>(sqlite3_column_bytes(stmt, idx)), sqlite3_column_blob(stmt, idx)};
        }

        SQLite3 & db;
        sqlite3_stmt * stmt{};

    private:
        static const BgettextMessage msg_compilation_failed;
        static const BgettextMessage msg_bind_int_failed;
        static const BgettextMessage msg_bind_int64_failed;
        static const BgettextMessage msg_bind_uint32_failed;
        static const BgettextMessage msg_bind_double_failed;
        static const BgettextMessage msg_bind_bool_failed;
        static const BgettextMessage msg_bind_text_failed;
        static const BgettextMessage msg_bind_blob_failed;
        static const BgettextMessage msg_eval_failed;
        static const BgettextMessage msg_insufficient_memory;
    };

    class Query : public Statement {
    public:
        Query(SQLite3 & db, const char * sql) : Statement{db, sql} { map_cols_name(); }
        Query(SQLite3 & db, const std::string & sql) : Statement{db, sql} { map_cols_name(); }

        int get_column_index(const std::string & col_name) {
            auto it = cols_name_to_index.find(col_name);
            if (it == cols_name_to_index.end())
                throw SQLite3Error(msg_column_not_found, col_name);
            return it->second;
        }

        using Statement::get;

        template <typename T>
        T get(const std::string & col_name) {
            return get(get_column_index(col_name), Identity<T>{});
        }

    private:
        void map_cols_name() {
            for (int idx = 0; idx < get_column_count(); ++idx) {
                const char * name = get_column_name(idx);
                if (name)
                    cols_name_to_index[name] = idx;
            }
        }

        std::map<std::string, int> cols_name_to_index{};

        static const BgettextMessage msg_column_not_found;
    };

    SQLite3(const SQLite3 &) = delete;
    SQLite3 & operator=(const SQLite3 &) = delete;

    explicit SQLite3(const std::string & db_path) : path{db_path}, db{nullptr} { open(); }

    ~SQLite3() { close(); }

    const std::string & get_path() const { return path; }

    void open();
    void close();
    bool is_open() { return db != nullptr; };

    void exec(const char * sql) {
        auto result = sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
        if (result != SQLITE_OK) {
            throw SQLite3SQLError(result, msg_statement_exec_failed, std::string(sql));
        }
    }

    int changes() { return sqlite3_changes(db); }

    int64_t last_insert_rowid() { return sqlite3_last_insert_rowid(db); }

    std::string get_error() const { return sqlite3_errmsg(db); }

    void backup(const std::string & output_file);
    void restore(const std::string & input_file);

protected:
    std::string path;

    sqlite3 * db;

private:
    static const BgettextMessage msg_statement_exec_failed;
};


using SQLite3Ptr = std::shared_ptr<SQLite3>;

}  // namespace libdnf5::utils

#endif  // LIBDNF5_UTILS_SQLITE3_SQLITE3_HPP
