import ctypes
import csv
from csv import DictReader
import io
import tempfile
import time


class DictReader:

    def get_column_types(self):
        types = []
        for column in self.columns:
            name = column.split("(")[0]
            type = column.split("(")[1]
            type = type.split(")")[0]
            if type == "integer":
                types.append(int)
            if type == "text":
                types.append(str)
        return types

    def get_column_names(self):
        names = []
        for column in self.columns:
            name = column.split("(")[0]
            names.append(name)
        return names

    def __init__(self, data):
        self.result = 0
        if type(data) == int:
            self.data = ""
        else:
            self.data = data.decode()
        self.rows = [row.split(";")[:-1] for row in self.data.split("\n")]

        self.columns = self.rows[0]
        self.rows.pop(0)
        if type(data) == str:
            self.result = len(self.rows)
        else:
            self.result = data
        self.column_types = self.get_column_types()
        for row in self.rows:
            for index, field in enumerate(row):
                row[index] = self.column_types[index](field)
        self.column_names = self.get_column_names()

    def __iter__(self):
        return self.rows.__iter__()


libc = ctypes.CDLL("libc.so.6")


class Sorm:

    def __init__(self):
        self.lib = ctypes.CDLL("./sorm.so")
        self.sormq = self.lib.sormq
        self.sormq.argtypes = [ctypes.c_int, ctypes.c_char_p]
        self.sormq.restype = ctypes.c_char_p

        self.sormc = self.lib.sormc
        self.sormc.argtypes = [ctypes.c_char_p]
        self.sormc.restype = ctypes.c_int

        self.sormd = self.lib.sormd
        self.sormd.argtypes = [ctypes.c_int]
        self.sormd.restype = None

        self.sormm = self.lib.sormm
        self.sormm.argtypes = [ctypes.c_int]
        self.sormm.restype = ctypes.c_char_p


class SormDb(Sorm):

    def __init__(self, path):
        super().__init__()
        self.path = path
        self.conn = None

    def c(self):
        if not self.conn:
            self.conn = self.sormc(self.path.encode())
        return self.conn

    def __enter__(self):
        self.c()
        return self

    def __exit__(self, *args, **kwargs):
        self.d()

    def q(self, sql, *args) -> DictReader:
        ctypes_list = []
        for arg in args:
            if type(arg) == int:
                ctypes_list.append(ctypes.c_int)
            if type(arg) == str:
                ctypes_list.append(ctypes.c_char_p)
        self.sormq.argtypes = [ctypes.c_int, ctypes.c_char_p] + ctypes_list
        if not sql.lower().startswith("select"):
            self.sormq.restype = ctypes.c_int
        else:
            self.sormq.restype = ctypes.c_char_p
        params = tuple(
            [self.conn, sql.encode()]
            + list(arg.encode() if type(arg) == str else arg for arg in args)
        )
        result = DictReader(self.sormq(*params))
        self.m = self.sormm(self.conn).decode()
        return result

    def d(self):
        if not self.conn:
            return
        self.sormd(self.conn)
        self.conn = None


# Load the shared library
lib = ctypes.CDLL("./sorm.so")

free = libc.free
free.argtypes = [ctypes.c_void_p]
free.restype = None


rsomm = lib.sormm
rsomm.argtypes = [ctypes.c_int]
rsomm.restype = ctypes.c_char_p

disconnect = lib.sormd
disconnect.argtypes = [ctypes.c_int]

start = time.time()
for x in range(1):

    with SormDb("db.sqlite3") as db:

        for x in range(1):
            # db.q("BEGIN TRANSACTION")
            # for x in range(100000):
            #    db.q("INSERT INTO pony (name,age) VALUES (?s,?d);","Python Pony",1337)
            # db.q("COMMIT")
            result = db.q(
                "SELECT * FROM pony WHERE id > ?d AND name like ?s ORDER BY id",
                1337,
                "%hon Pon%",
            )
            # for row in result:
            #    print(row)
            print(result.column_names)
            print(len(result.rows), "records")
            print(db.m)
end = time.time()
duration = end - start
print("Duration: {}s".format(duration))