Sqlite.alusus

import "Srl/Console.alusus";
import "Srl/Array.alusus";
import "Srl/String.alusus";
import "Srl/Memory.alusus";
import "libsqlite3.so.0";
/*
    Linux .so | .so.0
    Mac OS .dylib
    Windows .lib
*/

module Sqlite {
    class Record {
        use Srl;
        def keys: Array[String];
        def values: Array[String];

        handler this~init() {}
        handler this~init(record: ref[Record]) {
            this.keys = record.keys;
            this.values = record.values;
        }

        handler this~terminate() {
            this.keys~terminate();
            this.values~terminate();
        }

        handler this(key: CharsPtr): String {
            @shared def dummy: String;
            def arrInd: int = 0;
            for , arrInd<this.keys.getLength(), arrInd++
                if this.keys(arrInd) == key
                    return this.values(arrInd)
            return dummy;
        }

        handler this.set(key: CharsPtr, value: CharsPtr): Record {
            def kstr: String = key;
            def vstr: String = value;
            this.keys.add(kstr);
            this.values.add(vstr);
            return this;
        }

        handler this.remove(key: CharsPtr): Bool {
            def arrInd: int = 0;
            for , arrInd<this.keys.getLength(), arrInd++
                if this.keys(arrInd) == key
                   return this.remove(arrInd)
            return false;
        }

        handler this.remove(index: Int): Bool {
            this.keys.remove(index);
            this.values.remove(index);
            return true;
        }

        handler this.clear(): Bool {
            this.keys.clear();
            this.values.clear();
            return true;
        }

        handler this.getLength(): Int {
            return this.keys.getLength();
        }
    }

    class _Db {}
    def DbHandle: alias ptr[_Db];

    class Db {
        use Srl;
        def db: DbHandle = 0;

        handler this~init() {
        }

        handler this~init(filename: CharsPtr) {
            open(filename, this.db);
        }

        handler this~terminate() {
            if this.db != 0 close(this.db);
        }

        handler this.exec(sql: CharsPtr): Array[Record] {
            def errmsg: CharsPtr;
            def recordArray: Array[Record];
            Sqlite.exec(this.db, sql, _customizedCallback~ptr, recordArray~ptr, errmsg);
            return recordArray;
        }

        handler this.exec(sql: CharsPtr, errmsg: ref[CharsPtr]): Array[Record] {
            def recordArray: Array[Record];
            Sqlite.exec(this.db, sql, _customizedCallback~ptr, recordArray~ptr, errmsg);
            return recordArray;
        }

        handler this = CharsPtr {
            if this.db != 0 close(this.db);
            open(value, this.db);
        }

        func _customizedCallback(
            data: ptr, argc: Int, argv: ptr[array[CharsPtr]], azColName: ptr[array[CharsPtr]]
        ): Int {
            def i: Int = 0;
            def record: Record;
            for , i < argc, i++ {
                record.set(azColName~cnt(i), argv~cnt(i));
            }
            data~cast[ptr[Array[Record]]]~cnt.add(record);
            return 0;
        }
    }

    @expname[sqlite3_open]
    func open(filename: CharsPtr, dbh: ref[DbHandle]): Int;

    @expname[sqlite3_exec]
    func exec(
        sqlite: DbHandle, sql: CharsPtr, 
        cb: ptr[func(data: ptr, argc: Int, argv: ptr[array[CharsPtr]], azColName: ptr[array[CharsPtr]]): Int],
        data: ptr,
        errmsg: ref[CharsPtr]
    ): Int;

    @expname[sqlite3_close]
    func close(sqlite: DbHandle): Int;

    @expname[sqlite3_libversion]
    func version(): CharsPtr;
}