/++
Managing prepared statements.

Authors:
    Nicolas Sicard (biozic) and other contributors at $(LINK https://github.com/biozic/d2sqlite3)

Copyright:
    Copyright 2011-18 Nicolas Sicard.

License:
    $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
+/
module d2sqlite3.statement;

import d2sqlite3.database;
import d2sqlite3.results;
import d2sqlite3.sqlite3;
import d2sqlite3.internal.memory;
import d2sqlite3.internal.util;

import std.conv : to;
import std.exception : enforce;
import std..string : format, toStringz;
import std.typecons : Nullable;

/// Set _UnlockNotify version if compiled with SqliteEnableUnlockNotify or SqliteFakeUnlockNotify
version (SqliteEnableUnlockNotify) version = _UnlockNotify;
else version (SqliteFakeUnlockNotify) version = _UnlockNotify;

/++
A prepared statement.

This struct is a reference-counted wrapper around a `sqlite3_stmt*` pointer.
Instances of this struct are typically returned by `Database.prepare()`.
+/
struct Statement
{
    import std.meta : allSatisfy;
    import std.traits : isIntegral, isSomeChar, isBoolean, isFloatingPoint,
        isSomeString, isStaticArray, isDynamicArray, isIterable;
    import std.typecons : RefCounted, RefCountedAutoInitialize;

private:

    /// Returns $(D true) if the value can be directly bound to the statement
    enum bool isBindable(T) =
        is(T == typeof(null)) || is(T == void*) || isIntegral!T || isSomeChar!T
        || isBoolean!T || isFloatingPoint!T || isSomeString!T || isStaticArray!T
        || isDynamicArray!T || is(T == Nullable!U, U...);

    struct Payload
    {
        Database db;
        sqlite3_stmt* handle; // null if error or empty statement
        int paramCount;
        debug string sql;

        ~this() nothrow
        {
            debug ensureNotInGC!Statement(sql);
            sqlite3_finalize(handle);
        }
    }

    RefCounted!(Payload, RefCountedAutoInitialize.no) p;

    void checkResult(int result)
    {
        enforce(result == SQLITE_OK, new SqliteException(errmsg(p.handle), result));
    }

    version (_UnlockNotify)
    {
        auto sqlite3_blocking_prepare_v2(Database db, const char *zSql, int nByte,
                                         sqlite3_stmt **ppStmt, const char **pzTail)
        {
            int rc;
            while(SQLITE_LOCKED == (rc = sqlite3_prepare_v2(db.handle(), zSql, nByte, ppStmt, pzTail)))
            {
                rc = db.waitForUnlockNotify();
                if(rc != SQLITE_OK) break;
            }
            return rc;
        }
    }

package(d2sqlite3):
    this(Database db, string sql)
    {
        sqlite3_stmt* handle;
        version (_UnlockNotify)
        {
            auto result = sqlite3_blocking_prepare_v2(db, sql.toStringz, sql.length.to!int,
                &handle, null);
        }
        else
        {
            auto result = sqlite3_prepare_v2(db.handle(), sql.toStringz, sql.length.to!int,
                &handle, null);
        }
        enforce(result == SQLITE_OK, new SqliteException(errmsg(db.handle()), result, sql));
        p = Payload(db, handle);
        p.paramCount = sqlite3_bind_parameter_count(p.handle);
        debug p.sql = sql;
    }

    version (_UnlockNotify)
    {
        /// Setup and waits for unlock notify using the provided `IUnlockNotifyHandler`
        auto waitForUnlockNotify()
        {
            return p.db.waitForUnlockNotify();
        }
    }

public:
    /++
    Gets the SQLite internal _handle of the statement.
    +/
    inout(sqlite3_stmt)* handle() inout @safe pure nothrow @nogc
    {
        return p.handle;
    }

    /++
    Explicitly finalizes the prepared statement.

    After a call to `finalize()`, the `Statement` object is destroyed and cannot be used.
    +/
    void finalize()
    {
        destroy(p);
    }

    /++
    Tells whether the statement is empty (no SQL statement).
    +/
    bool empty() const @safe pure nothrow @nogc
    {
        return p.handle is null;
    }
    ///
    unittest
    {
        auto db = Database(":memory:");
        auto statement = db.prepare(" ; ");
        assert(statement.empty);
    }

    /++
    Binds values to parameters of this statement, using parameter index.

    Params:
        index = The index of the parameter (starting from 1).

        value = The bound _value. The type of value must be compatible with the SQLite
        types: it must be a boolean or numeric type, a string, an array, null,
        or a Nullable!T where T is any of the previous types.
    +/
    void bind(T)(int index, T value)
    in
    {
        assert(index > 0 && index <= p.paramCount, "parameter index out of range");
    }
    body
    {
        assert(p.handle);

        static if (is(T == typeof(null)) || is(T == void*))
            checkResult(sqlite3_bind_null(p.handle, index));

        // Handle nullable before user-provided hook as we don't want to write
        // `Nullable.null` when the value `isNull`.
        else static if (is(T == Nullable!U, U...))
        {
            if (value.isNull)
                checkResult(sqlite3_bind_null(p.handle, index));
            else
                this.bind(index, value.get);
        }

        // Check for user-defined hook
        else static if (is(typeof(value.toString((in char[]) {}))))
        {
            string str = format("%s", value);
            auto ptr = anchorMem(cast(void*) str.ptr);
            checkResult(sqlite3_bind_text64(p.handle, index, cast(const(char)*) ptr,
                                            str.length, &releaseMem, SQLITE_UTF8));
        }
        else static if (is(typeof(value.toString()) : string))
        {
            string str = value.toString();
            auto ptr = anchorMem(cast(void*) str.ptr);
            checkResult(sqlite3_bind_text64(p.handle, index, cast(const(char)*) ptr,
                                            str.length, &releaseMem, SQLITE_UTF8));
        }

        else static if (isIntegral!T || isSomeChar!T || isBoolean!T)
            checkResult(sqlite3_bind_int64(p.handle, index, value.to!long));
        else static if (isFloatingPoint!T)
            checkResult(sqlite3_bind_double(p.handle, index, value.to!double));
        else static if (isSomeString!T)
        {
            string str = value.to!string;
            auto ptr = anchorMem(cast(void*) str.ptr);
            checkResult(sqlite3_bind_text64(p.handle, index, cast(const(char)*) ptr,
                                            str.length, &releaseMem, SQLITE_UTF8));
        }
        else static if (isStaticArray!T)
            checkResult(sqlite3_bind_blob64(p.handle, index, cast(void*) value.ptr,
                                            value.sizeof, SQLITE_TRANSIENT));
        else static if (isDynamicArray!T)
        {
            const void[] arr = value;
            checkResult(sqlite3_bind_blob64(p.handle, index, anchorMem(arr.ptr),
                                            arr.length, &releaseMem));
        }
        else
            static assert(0, "Don't know how to bind an instance of type: " ~ T.stringof);
    }

    /++
    Binds values to parameters of this statement, using parameter names.

    Params:
        name = The name of the parameter, including the ':', '@' or '$' that introduced it.

        value = The bound _value. The type of value must be compatible with the SQLite
        types: it must be a boolean or numeric type, a string, an array, null,
        or a Nullable!T where T is any of the previous types.

    Warning:
        While convenient, this overload of `bind` is less performant, because it has to
        retrieve the column index with a call to the SQLite function
        `sqlite3_bind_parameter_index`.
    +/
    void bind(T)(string name, T value)
    in
    {
        assert(name.length);
    }
    body
    {
        assert(p.handle);
        auto index = sqlite3_bind_parameter_index(p.handle, name.toStringz);
        assert(index > 0, "no parameter named '%s'".format(name));
        bind(index, value);
    }

    /++
    Binds all the arguments at once in order.
    +/
    void bindAll(Args...)(Args args)
    in
    {
        assert(Args.length == this.parameterCount, "parameter count mismatch");
    }
    body
    {
        foreach (index, _; Args)
            bind(index + 1, args[index]);
    }

    /++
    Clears the bindings.

    This does not reset the statement. Use `Statement.reset()` for this.
    +/
    void clearBindings()
    {
        assert(p.handle);
        checkResult(sqlite3_clear_bindings(p.handle));
    }

    /++
    Executes the statement and return a (possibly empty) range of results.
    +/
    ResultRange execute()
    {
        return ResultRange(this);
    }

    /++
    Resets a this statement before a new execution.

    Calling this method invalidates any `ResultRange` struct returned by a previous call
    to `Database.execute()` or `Statement.execute()`.

    This does not clear the bindings. Use `Statement.clearBindings()` for this.
    +/
    void reset()
    {
        assert(p.handle);
        checkResult(sqlite3_reset(p.handle));
    }

    /++
    Binds arguments, executes and resets the statement, in one call.

    This convenience function is equivalent to:
    ---
    bindAll(args);
    execute();
    reset();
    ---
    +/
    void inject(Args...)(Args args)
        if (allSatisfy!(isBindable, Args))
    {
        bindAll(args);
        execute();
        reset();
    }

    /++
    Binds the fields of a struct in order, executes and resets the statement, in one call.
    +/
    void inject(T)(auto ref const T obj)
        if (is(T == struct))
    {
        import std.meta : Filter;
        import std.traits : FieldNameTuple;

        enum accesible(string F) = __traits(compiles, __traits(getMember, obj, F));
        enum bindable(string F) = isBindable!(typeof(__traits(getMember, obj, F)));

        alias FieldNames = Filter!(bindable, Filter!(accesible, FieldNameTuple!T));
        assert(FieldNames.length == this.parameterCount, "parameter count mismatch");
        foreach (i, field; FieldNames)
            bind(i + 1, __traits(getMember, obj, field));
        execute();
        reset();
    }

    /++
    Binds iterable values in order, executes and resets the statement, in one call.
    +/
    void inject(T)(auto ref T obj)
        if (!isBindable!T && isIterable!T)
    in
    {
        static if (__traits(compiles, obj.length))
            assert(obj.length == this.parameterCount, "parameter count mismatch");
    }
    body
    {
        static if (__traits(compiles, { foreach (string k, ref v; obj) {} }))
        {
            foreach (string k, ref v; obj) bind(k, v);
        }
        else
        {
            int i = 1;
            foreach (ref v; obj) bind(i++, v);
        }
        execute();
        reset();
    }

    /// Gets the count of bind parameters.
    int parameterCount() nothrow
    {
        assert(p.handle);
        return p.paramCount;
    }

    /++
    Gets the name of the bind parameter at the given index.

    Params:
        index = The index of the parameter (the first parameter has the index 1).

    Returns: The name of the parameter or null is not found or out of range.
    +/
    string parameterName(int index)
    in
    {
        assert(index > 0 && index <= p.paramCount, "parameter index out of range");
    }
    body
    {
        assert(p.handle);
        return sqlite3_bind_parameter_name(p.handle, index).to!string;
    }

    /++
    Gets the index of a bind parameter.

    Returns: The index of the parameter (the first parameter has the index 1)
    or 0 is not found or out of range.
    +/
    int parameterIndex(string name)
    in
    {
        assert(name.length);
    }
    body
    {
        assert(p.handle);
        return sqlite3_bind_parameter_index(p.handle, name.toStringz);
    }
}

/++
Turns $(D_PARAM value) into a _literal that can be used in an SQLite expression.
+/
string literal(T)(T value)
{
    import std..string : replace;
    import std.traits : isBoolean, isNumeric, isSomeString, isArray;

    static if (is(T == typeof(null)))
        return "NULL";
    else static if (isBoolean!T)
        return value ? "1" : "0";
    else static if (isNumeric!T)
        return value.to!string();
    else static if (isSomeString!T)
        return format("'%s'", value.replace("'", "''"));
    else static if (isArray!T)
        return "'X%(%X%)'".format(cast(Blob) value);
    else
        static assert(false, "cannot make a literal of a value of type " ~ T.stringof);
}
///
unittest
{
    assert(null.literal == "NULL");
    assert(false.literal == "0");
    assert(true.literal == "1");
    assert(4.literal == "4");
    assert(4.1.literal == "4.1");
    assert("foo".literal == "'foo'");
    assert("a'b'".literal == "'a''b'''");
    import std.conv : hexString;
    auto a = cast(Blob) hexString!"DEADBEEF";
    assert(a.literal == "'XDEADBEEF'");
}