async function createDatabase(driver, dbName) {
    process.stdout.write("Creating a new database...");
    await driver.databases.create(dbName);
    console.log("OK");
    try {
        {
            let session = await driver.session(dbName, SessionType.SCHEMA);
            await dbSchemaSetup(session);
            await session.close();
        }
        {
            let session = await driver.session(dbName, SessionType.DATA);
            await dbDatasetSetup(session);
            await session.close();
        }
    } catch (error) { console.error(error); };
    return true;
}

async function replaceDatabase(driver, dbName) {
    process.stdout.write("Deleting an existing database...");
    await (await driver.databases.get(dbName)).delete();
    console.log("OK");
    if ((await createDatabase(driver, dbName)) === true) {
        return true;
    } else {
        console.log("Failed to create a database. Terminating...");
        return false;
    }
}

async function dbSchemaSetup(schemaSession) {
    process.stdout.write("Defining schema...");
    try {
        let tx = await schemaSession.transaction(TransactionType.WRITE);
        try {
            const define_query = await readFile("iam-schema.tql", 'utf8');
            await tx.query.define(define_query);
            await tx.commit();
            console.log("OK");
            return true;
        }
        catch (e) {
            callback(e);
            return false;
        }
    }
    catch (e) {
        callback(e);
        return false;
    }
}

async function dbDatasetSetup(dataSession) {
    process.stdout.write("Loading data...");
    try {
        let tx = await dataSession.transaction(TransactionType.WRITE);
        try {
            const insert_query = await readFile("iam-data-single-query.tql", 'utf8');
            await tx.query.insert(insert_query);
            await tx.commit();
            console.log("OK");
        }
        catch (e) { callback(e); }
    }
    catch (e) { callback(e); }
}

async function dbCheck(dataSession) {
    process.stdout.write("Testing the database...");
    try {
        let tx = await dataSession.transaction(TransactionType.READ);
        try {
            const test_query = "match $u isa user; get $u; count;";
            let response = await tx.query.getAggregate(test_query);
            let result = await response.asValue().asLong();
            if (result == 3) {
                console.log("Passed");
                return true;
            } else {
                console.log("Failed with the result: " + result.toString() + " Expected result: 3");
                return false;
            }
        }
        catch (e) { callback(e); }
    }
    catch (e) { callback(e); }
}

async function fetchAllUsers(driver, dbName) {
    let dataSession = await driver.session(dbName, SessionType.DATA);
    let users;
    try {
        let tx = await dataSession.transaction(TransactionType.READ);
        try {
            users = await tx.query.fetch("match $u isa user; fetch $u: full-name, email;").collect();
            for (let i = 0; i < users.length; i++) {
                console.log("User #" + (i + 1).toString() + ": " + users[i]["u"]["full-name"][0]["value"]);
            }
        }
        catch (error) { console.error(error); }
        finally { if (tx.isOpen()) {await tx.close()}; };
    }
    catch (error) { console.error(error); }
    finally { await dataSession?.close(); };
    return users;
}

async function insertNewUser(driver, dbName, name, email) {
    let result;
    let dataSession = await driver.session(dbName, SessionType.DATA);
    try {
        let tx = await dataSession.transaction(TransactionType.WRITE);
        try {
            let response = await tx.query.insert(`insert $p isa person, has full-name $fn, has email $e; $fn == '${name}'; $e == '${email}';`);
            let answers = await response.collect();
            result = await Promise.all(
                answers.map(answer =>
                    [answer.get("fn").value,
                    answer.get("e").value]
                )
            );
            for(let i = 0; i < result.length; i++) {
                console.log("User inserted: " + result[i][0] + ", has E-mail: " + result[i][1]);
            };
            await tx.commit();
        }
        catch (error) { console.error(error); }
        finally { if (tx.isOpen()) {await tx.close()}; };
    }
    catch (error) { console.error(error); }
    finally { await dataSession?.close(); };
    return result;
}

async function getFilesByUser(driver, dbName, name, inference=false) {
    let options = new TypeDBOptions();
    options.infer = inference;
    let dataSession = await driver.session(dbName, SessionType.DATA);
    let users;
    try {
        let tx = await dataSession.transaction(TransactionType.READ, options);
        try {
            users = await tx.query.get(`match $u isa user, has full-name '${name}'; get;`).collect();
            if (users.length > 1) {
                console.log("Error: Found more than one user with that name.");
                await dataSession.close();
                return null;
            } else if (users.length == 1) {
                let response = tx.query.get(`match
                                            $fn == '${name}';
                                            $u isa user, has full-name $fn;
                                            $p($u, $pa) isa permission;
                                            $o isa object, has path $fp;
                                            $pa($o, $va) isa access;
                                            $va isa action, has name 'view_file';
                                            get $fp; sort $fp asc;
                                            `);
                answers = await response.collect();
                result = await Promise.all(
                    answers.map(answer =>
                        [answer.get("fp").value]
                    )
                );
                for (let i = 0; i < result.length; i++) {
                    console.log("File #" + (i + 1).toString() + ": " + result[i]);
                }
                if (answers.length == 0) {
                    console.log("No files found. Try enabling inference.");
                return answers
                }
            } else {
                console.log("Error: No users found with that name.");
                await dataSession.close();
                return null;
            }
        }
        catch (error) { console.error(error); }
        finally { if (tx.isOpen()) {await tx.close()}; };
    }
    catch (error) { console.error(error); }
    finally { await dataSession?.close(); };
    return users;
}

async function updateFilepath(driver, dbName, oldPath, newPath) {
    let dataSession = await driver.session(dbName, SessionType.DATA);
    try {
        let tx = await dataSession.transaction(TransactionType.WRITE);
        try {
            let response = await tx.query.update(`
                                                match
                                                $f isa file, has path $old_path;
                                                $old_path = '${oldPath}';
                                                delete
                                                $f has $old_path;
                                                insert
                                                $f has path $new_path;
                                                $new_path = '${newPath}';
                                                `).collect();
            if (response.length > 0) {
                await tx.commit();
                console.log(`Total number of paths updated: ${response.length}.`);
                await dataSession.close();
                return response;
            } else {
                console.log("No matched paths: nothing to update.");
                await dataSession.close();
                return null;
            }
        }
        catch (error) { console.error(error); }
        finally { if (tx.isOpen()) {await tx.close()}; };
    }
    catch (error) { console.error(error); }
    finally { await dataSession?.close(); };
}

async function delete_file(driver, dbName, path) {
    let dataSession = await driver.session(dbName, SessionType.DATA);
    try {
        let tx = await dataSession.transaction(TransactionType.WRITE);
        try {
            let response = await tx.query.get(`match
                                                $f isa file, has path '${path}';
                                                get;`).collect();
            if (response.length == 1) {
                await tx.query.delete(`
                                    match
                                    $f isa file, has path '${path}';
                                    delete
                                    $f isa file;
                                    `);
                await tx.commit();
                console.log("The file has been deleted.");
                await dataSession.close();
                return true;
            } else if (response.length > 1) {
                console.log("Matched more than one file with the same path.");
                console.log("No files were deleted.");
                await tx.close();
                await dataSession.close();
                return false;
            } else {
                console.log(response.length)
                console.log("No files matched in the database.");
                console.log("No files were deleted.");
                await tx.close();
                await dataSession.close();
                return false;
            }
        }
        catch (error) { console.error(error); }
        finally { if (tx.isOpen()) {await tx.close()}; };
    }
    catch (error) { console.error(error); }
    finally { await dataSession?.close(); };
}