bool createDatabase(DatabaseManager* dbManager, const char* dbName) {
    Session* schemaSession = NULL;
    Session* dataSession = NULL;
    Options* opts = options_new();
    bool result = false;
    printf("Creating new database: %s\n", dbName);
    databases_create(dbManager, dbName);
    if (FAILED()) {
        handle_error("Database creation failed.");
        goto cleanup;
    }
    schemaSession = session_new(dbManager, dbName, Schema, opts);
    if (schemaSession == NULL || FAILED()) {
        goto cleanup;
    }
    dbSchemaSetup(schemaSession, "iam-schema.tql");
    session_close(schemaSession);
    dataSession = session_new(dbManager, dbName, Data, opts);
    if (dataSession == NULL || FAILED()) {
        goto cleanup;
    }
    dbDatasetSetup(dataSession, "iam-data-single-query.tql");
    session_close(dataSession);
    result = true;
cleanup:
    options_drop(opts);
    return result;
}

void delete_database_if_exists(DatabaseManager* databaseManager, const char* name) {
    if (NULL != databaseManager && databases_contains(databaseManager, name)) {
        Database* database = databases_get(databaseManager, name);
        database_delete(database);
    }
}

bool replaceDatabase(DatabaseManager* dbManager, const char* dbName) {
    printf("Deleting an existing database...");
    delete_database_if_exists(dbManager, dbName);
    if (FAILED()) {
        printf("Failed to delete the database. Terminating...\n");
        exit(EXIT_FAILURE);
    }
    printf("OK\n");

    if (!createDatabase(dbManager, dbName)) {
        printf("Failed to create a new database. Terminating...\n");
        exit(EXIT_FAILURE);
    }
    return true;
}

void dbSchemaSetup(Session* schemaSession, const char* schemaFile) {
    Transaction* tx = NULL;
    Options* opts = options_new();
    char defineQuery[4096] = {0};
    FILE* file = fopen(schemaFile, "r");
    if (FAILED()) goto cleanup;
    if (!file) handle_error("Failed to open schema file.");
    char line[512];
    while (fgets(line, sizeof(line), file)) strcat(defineQuery, line);
    fclose(file);

    tx = transaction_new(schemaSession, Write, opts);
    if (tx == NULL || FAILED()) {
        handle_error("Transaction failed to start.");
        goto cleanup;
    }
    void_promise_resolve(query_define(tx, defineQuery, opts));
    if (FAILED()) {
        handle_error("Query execution failed.");
        goto cleanup;
    }
    void_promise_resolve(transaction_commit(tx));
    if (FAILED()) {
        handle_error("Transaction commit failed.");
        goto cleanup;
    }
    printf("Schema setup complete.\n");
cleanup:
    options_drop(opts);
}

void dbDatasetSetup(Session* dataSession, const char* dataFile) {
    bool result = false;
    Transaction* tx = NULL;
    Options* opts = options_new();
    char insertQuery[4096] = {0};
    FILE* file = fopen(dataFile, "r");
    if (!file) handle_error("Failed to open data file.");

    char line[512];
    while (fgets(line, sizeof(line), file)) strcat(insertQuery, line);
    fclose(file);

    tx = transaction_new(dataSession, Write, opts);
    if (tx == NULL || FAILED()) {
        handle_error("Transaction failed to start.");
        goto cleanup;
    }
    ConceptMapIterator* insertResult = query_insert(tx, insertQuery, opts);
    if (FAILED()) {
        handle_error("Query execution failed.");
        goto cleanup;
    }
    void_promise_resolve(transaction_commit(tx));
    if (FAILED()) {
        handle_error("Transaction commit failed.");
        goto cleanup;
    }
    printf("Dataset setup complete.\n");
    result = true;
cleanup:
    concept_map_iterator_drop(insertResult);
    // transaction_close(tx);
    options_drop(opts);
}

bool dbCheck(Session* dataSession) {
    printf("Testing the database...");
    bool result = false;
    Transaction* tx = NULL;
    Options* opts = options_new();
    tx = transaction_new(dataSession, Read, opts);
    if (tx == NULL || FAILED()) {
        handle_error("Transaction failed to start.");
        goto cleanup;
    }
    const char* testQuery = "match $u isa user; get $u; count;";
    Concept* response = concept_promise_resolve(query_get_aggregate(tx, testQuery, opts));
    if (response == NULL || FAILED()) {
        handle_error("Query execution failed.");
        goto cleanup;
    }
    long answer = value_get_long(response);
    if (FAILED()) {
        handle_error("Value convertion failed.");
        goto cleanup;
    }

    if (answer == 3) {
        printf("Passed\n");
        result = true;
    } else {
        printf("Failed with the result: %ld\nExpected result: 3.\n", answer);
        exit(EXIT_FAILURE);
    }
cleanup:
    concept_drop(response);
    transaction_close(tx);
    options_drop(opts);
    return result;
}

int fetchAllUsers(DatabaseManager* dbManager, const char* dbName) {
    Options* opts = options_new();
    Transaction* tx = NULL;
    StringIterator* queryResult = NULL;
    Session* session = session_new(dbManager, dbName, Data, opts);
    if (session == NULL || FAILED()) {
        fprintf(stderr, "Failed to open session.\n");
        exit(EXIT_FAILURE);
    }
    tx = transaction_new(session, Read, opts);
    if (tx == NULL || FAILED()) {
        fprintf(stderr, "Failed to start transaction.\n");
        session_close(session);
        exit(EXIT_FAILURE);
    }

    const char* query = "match $u isa user; fetch $u: full-name, email;";
    queryResult = query_fetch(tx, query, opts);
    if (queryResult == NULL || FAILED()) {
        fprintf(stderr, "Query failed or no results.\n");
        transaction_close(tx);
        session_close(session);
        exit(EXIT_FAILURE);
    }

    char* userJSON = string_iterator_next(queryResult);
    int counter = 1;
    while (userJSON != NULL) {
        printf("User #%d: ", counter++);
        printf("%s \n",userJSON);
        userJSON = string_iterator_next(queryResult);
    }
cleanup:
    string_iterator_drop(queryResult);
    transaction_close(tx);
    session_close(session);
    return counter-1;
}

int insertNewUser(DatabaseManager* dbManager, const char* dbName, const char* name, const char* email) {
    Options* opts = options_new();
    Transaction* tx = NULL;
    Session* session = NULL;
    ConceptMapIterator* response = NULL;
    ConceptMap* conceptMap = NULL;

    session = session_new(dbManager, dbName, Data, opts);
    if (session == NULL || FAILED()) {
        fprintf(stderr, "Failed to open session.\n");
        exit(EXIT_FAILURE);
    }

    tx = transaction_new(session, Write, opts);
    if (tx == NULL || FAILED()) {
        fprintf(stderr, "Failed to start transaction.\n");
        session_close(session);
        exit(EXIT_FAILURE);
    }

    char query[512];
    snprintf(query, sizeof(query), "insert $p isa person, has full-name $fn, has email $e; $fn == '%s'; $e == '%s';", name, email);
    response = query_insert(tx, query, opts);
    if (response == NULL || FAILED()) {
        fprintf(stderr, "Failed to execute insert query.\n");
        transaction_close(tx);
        session_close(session);
        exit(EXIT_FAILURE);
    }

    int insertedCount = 0;
    while ((conceptMap = concept_map_iterator_next(response)) != NULL) {
        Concept* fnConcept = concept_map_get(conceptMap, "fn");
        Concept* eConcept = concept_map_get(conceptMap, "e");
        const char* fullName = value_get_string(attribute_get_value(fnConcept));
        const char* userEmail = value_get_string(attribute_get_value(eConcept));
        printf("Added new user. Name: %s, E-mail: %s\n", fullName, userEmail);
        concept_drop(fnConcept);
        concept_drop(eConcept);
        concept_map_drop(conceptMap);
        insertedCount++;
    }
    concept_map_iterator_drop(response);
    void_promise_resolve(transaction_commit(tx));
    session_close(session);
    return insertedCount;
}

int getFilesByUser(DatabaseManager* dbManager, const char* dbName, const char* name, bool inference) {
    Transaction* tx = NULL;
    Session* session = NULL;
    ConceptMapIterator* userResult = NULL;
    ConceptMapIterator* response = NULL;
    ConceptMap* cm = NULL;
    Options* opts = options_new();

    session = session_new(dbManager, dbName, Data, opts);
    if (session == NULL || FAILED()) {
        fprintf(stderr, "Failed to open session.\n");
        options_drop(opts);
        exit(EXIT_FAILURE);
    }

    options_set_infer(opts, inference);
    tx = transaction_new(session, Read, opts);
    if (tx == NULL || FAILED()) {
        fprintf(stderr, "Failed to start transaction.\n");
        options_drop(opts);
        session_close(session);
        exit(EXIT_FAILURE);
    }

    char query[512];
    snprintf(query, sizeof(query), "match $u isa user, has full-name '%s'; get;", name);
    userResult = query_get(tx, query, options_new());
    int userCount = 0;
    while (concept_map_iterator_next(userResult) != NULL) { userCount++; }
    concept_map_iterator_drop(userResult);

    if (userCount > 1) {
        fprintf(stderr, "Error: Found more than one user with that name.\n");
    } else if (userCount == 1) {
        snprintf(query, sizeof(query), "match $fn == '%s'; $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;", name);
        response = query_get(tx, query, options_new());
        int fileCount = 0;
        while ((cm = concept_map_iterator_next(response)) != NULL) {
            Concept* filePathConcept = concept_map_get(cm, "fp");
            const char* filePath = value_get_string(attribute_get_value(filePathConcept));
            printf("File #%d: %s\n", ++fileCount, filePath);
            concept_drop(filePathConcept);
            concept_map_drop(cm);
        }
        concept_map_iterator_drop(response);
        if (fileCount == 0) {
            printf("No files found. Try enabling inference.\n");
        }
    } else {
        fprintf(stderr, "Error: No users found with that name.\n");
    }

    transaction_close(tx);
    options_drop(opts);
    session_close(session);
    return userCount;
}

int16_t updateFilePath(DatabaseManager* dbManager, const char* dbName, const char* oldPath, const char* newPath) {
    Transaction* tx = NULL;
    Session* session = NULL;
    Options* opts = options_new();
    ConceptMapIterator* response = NULL;
    session = session_new(dbManager, dbName, Data, opts);
    if (session == NULL || FAILED()) {
        fprintf(stderr, "Failed to open session.\n");
        exit(EXIT_FAILURE);
    }

    tx = transaction_new(session, Write, opts);
    if (tx == NULL || FAILED()) {
        fprintf(stderr, "Failed to start transaction.\n");
        session_close(session);
        exit(EXIT_FAILURE);
    }

    char query[512];
    snprintf(query, sizeof(query), "match $f isa file, has path $old_path; $old_path = '%s'; delete $f has $old_path; insert $f has path $new_path; $new_path = '%s';", oldPath, newPath);

    response = query_update(tx, query, opts);
    if (response == NULL || FAILED()) {
        fprintf(stderr, "Query failed or no results.\n");
        transaction_close(tx);
        session_close(session);
        exit(EXIT_FAILURE);
    }

    int16_t count = 0;
    while (concept_map_iterator_next(response) != NULL) {
        count++;
    }
    concept_map_iterator_drop(response);

    if (count > 0) {
        void_promise_resolve(transaction_commit(tx));
        printf("Total number of paths updated: %d.\n", count);
    } else {
        printf("No matched paths: nothing to update.\n");
    }

    session_close(session);
    return count;
}

bool deleteFile(DatabaseManager* dbManager, const char* dbName, const char* path) {
    bool result = false;
    Transaction* tx = NULL;
    Session* session = NULL;
    Options* opts = options_new();
    ConceptMapIterator* response = NULL;

    session = session_new(dbManager, dbName, Data, opts);
    if (session == NULL || FAILED()) {
        fprintf(stderr, "Failed to open session.\n");
        exit(EXIT_FAILURE);
    }

    tx = transaction_new(session, Write, opts);
    if (tx == NULL || FAILED()) {
        fprintf(stderr, "Failed to start transaction.\n");
        session_close(session);
        exit(EXIT_FAILURE);
    }

    char query[256];
    snprintf(query, sizeof(query), "match $f isa file, has path '%s'; get;", path);
    response = query_get(tx, query, opts);
    if (response == NULL || FAILED()) {
        fprintf(stderr, "Query failed or no results.\n");
        transaction_close(tx);
        session_close(session);
        exit(EXIT_FAILURE);
    }

    int16_t count = 0;
    while (concept_map_iterator_next(response) != NULL) {
        count++;
    }
    concept_map_iterator_drop(response);

    if (count == 1) { // Delete the file if exactly one was found
        snprintf(query, sizeof(query), "match $f isa file, has path '%s'; delete $f isa file;", path);
        if (query_delete(tx, query, opts) == NULL || FAILED()) {
            fprintf(stderr, "Failed to delete file.\n");
            transaction_close(tx);
            session_close(session);
            exit(EXIT_FAILURE);
        }
        void_promise_resolve(transaction_commit(tx));
        printf("The file has been deleted.\n");
        result = true;
    } else if (count > 1) fprintf(stderr, "Matched more than one file with the same path.\nNo files were deleted.\n");
    else fprintf(stderr, "No files matched in the database.\nNo files were deleted.\n");

    session_close(session);
    return result;
}