// Minimal SQLite binding, loaded at runtime (sqlite3.dll on Windows, libsqlite3.so.0 on Linux).
// Loading dynamically means the server binary has no link-time dependency on SQLite, so it can be
// cross-compiled and then just needs the distro package (libsqlite3-0) on the droplet.

SQLITE_OK         :: 0;
SQLITE_ROW        :: 100;
SQLITE_DONE       :: 101;
SQLITE_OPEN_READWRITE :: 0x00000002;
SQLITE_OPEN_CREATE    :: 0x00000004;
SQLITE_OPEN_NOMUTEX   :: 0x00008000;
SQLITE_TRANSIENT  :: cast(*void) -1;

sqlite3      :: void;
sqlite3_stmt :: void;

Sqlite_Api :: struct {
    sqlite3_open_v2:            (filename: *u8, db: **sqlite3, flags: s32, vfs: *u8) -> s32 #c_call;
    sqlite3_close_v2:           (db: *sqlite3) -> s32 #c_call;
    sqlite3_exec:               (db: *sqlite3, sql: *u8, callback: *void, arg: *void, errmsg: **u8) -> s32 #c_call;
    sqlite3_prepare_v2:         (db: *sqlite3, sql: *u8, bytes: s32, stmt: **sqlite3_stmt, tail: **u8) -> s32 #c_call;
    sqlite3_step:               (stmt: *sqlite3_stmt) -> s32 #c_call;
    sqlite3_reset:              (stmt: *sqlite3_stmt) -> s32 #c_call;
    sqlite3_finalize:           (stmt: *sqlite3_stmt) -> s32 #c_call;
    sqlite3_bind_int64:         (stmt: *sqlite3_stmt, index: s32, value: s64) -> s32 #c_call;
    sqlite3_bind_text:          (stmt: *sqlite3_stmt, index: s32, text: *u8, bytes: s32, destructor: *void) -> s32 #c_call;
    sqlite3_bind_blob:          (stmt: *sqlite3_stmt, index: s32, data: *void, bytes: s32, destructor: *void) -> s32 #c_call;
    sqlite3_column_int64:       (stmt: *sqlite3_stmt, column: s32) -> s64 #c_call;
    sqlite3_column_text:        (stmt: *sqlite3_stmt, column: s32) -> *u8 #c_call;
    sqlite3_column_blob:        (stmt: *sqlite3_stmt, column: s32) -> *void #c_call;
    sqlite3_column_bytes:       (stmt: *sqlite3_stmt, column: s32) -> s32 #c_call;
    sqlite3_errmsg:             (db: *sqlite3) -> *u8 #c_call;
    sqlite3_changes:            (db: *sqlite3) -> s32 #c_call;
    sqlite3_last_insert_rowid:  (db: *sqlite3) -> s64 #c_call;
    sqlite3_busy_timeout:       (db: *sqlite3, ms: s32) -> s32 #c_call;
    sqlite3_libversion:         () -> *u8 #c_call;
}

sql: Sqlite_Api;

load_sqlite :: () -> bool {
    #if OS == .WINDOWS {
        tf_kernel32 :: #system_library "kernel32";
        LoadLibraryA   :: (name: *u8) -> *void #foreign tf_kernel32;
        GetProcAddress :: (module: *void, name: *u8) -> *void #foreign tf_kernel32;
        lib := LoadLibraryA("sqlite3.dll");
        lookup :: GetProcAddress;
    } else {
        lib := dlopen("libsqlite3.so.0", RTLD_NOW);
        if !lib lib = dlopen("libsqlite3.so", RTLD_NOW);
        lookup :: dlsym;
    }
    if !lib {
        log_error("Could not load SQLite. On Ubuntu/Debian: sudo apt install libsqlite3-0. On Windows: put sqlite3.dll next to the server.");
        return false;
    }

    info := type_info(Sqlite_Api);
    for info.members {
        address := lookup(lib, temp_c_string(it.name));
        if !address {
            log_error("SQLite is missing %; it may be too old.", it.name);
            return false;
        }
        (cast(**void) (cast(*u8) *sql + it.offset_in_bytes)).* = address;
    }
    return true;
}

//
// Small conveniences.
//

Db :: struct {
    handle: *sqlite3;
}

db_open :: (path: string) -> Db, bool {
    db: Db;
    rc := sql.sqlite3_open_v2(temp_c_string(path), *db.handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX, null);
    if rc != SQLITE_OK {
        log_error("Could not open database %: %", path, db_error(db));
        return db, false;
    }
    sql.sqlite3_busy_timeout(db.handle, 5000);
    db_exec(db, "PRAGMA journal_mode = WAL;");
    db_exec(db, "PRAGMA synchronous = NORMAL;");
    db_exec(db, "PRAGMA foreign_keys = ON;");
    return db, true;
}

db_error :: (db: Db) -> string {
    return to_string(sql.sqlite3_errmsg(db.handle));
}

db_exec :: (db: Db, statement: string) -> bool {
    err: *u8;
    rc := sql.sqlite3_exec(db.handle, temp_c_string(statement), null, null, *err);
    if rc != SQLITE_OK {
        log_error("SQL error in \"%\": %", statement, to_string(err));
        return false;
    }
    return true;
}

Stmt :: struct {
    handle: *sqlite3_stmt;
    db: Db;
}

prepare :: (db: Db, statement: string) -> Stmt {
    s: Stmt;
    s.db = db;
    rc := sql.sqlite3_prepare_v2(db.handle, statement.data, cast(s32) statement.count, *s.handle, null);
    if rc != SQLITE_OK log_error("SQL prepare failed for \"%\": %", statement, db_error(db));
    return s;
}

bind :: (s: Stmt, index: s32, value: s64) { sql.sqlite3_bind_int64(s.handle, index, value); }
bind :: (s: Stmt, index: s32, value: string) { sql.sqlite3_bind_text(s.handle, index, value.data, cast(s32) value.count, SQLITE_TRANSIENT); }
bind_blob :: (s: Stmt, index: s32, value: string) { sql.sqlite3_bind_blob(s.handle, index, value.data, cast(s32) value.count, SQLITE_TRANSIENT); }

step :: (s: Stmt) -> bool {
    rc := sql.sqlite3_step(s.handle);
    if rc == SQLITE_ROW return true;
    if rc != SQLITE_DONE log_error("SQL step failed: %", db_error(s.db));
    return false;
}

// Runs a statement that returns no rows; returns success.
run :: (s: Stmt) -> bool {
    rc := sql.sqlite3_step(s.handle);
    if rc != SQLITE_DONE && rc != SQLITE_ROW {
        log_error("SQL failed: %", db_error(s.db));
        return false;
    }
    return true;
}

reset :: (s: Stmt) { sql.sqlite3_reset(s.handle); }
finalize :: (s: Stmt) { sql.sqlite3_finalize(s.handle); }

column_int :: (s: Stmt, column: s32) -> s64 { return sql.sqlite3_column_int64(s.handle, column); }

// Column text/blob, copied into temporary storage.
column_text :: (s: Stmt, column: s32) -> string {
    data := sql.sqlite3_column_blob(s.handle, column);
    count := sql.sqlite3_column_bytes(s.handle, column);
    result := alloc_string(count,, temp);
    if count memcpy(result.data, data, count);
    return result;
}