"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = createDbFromSchema;
const noDatabaseDbHandler_1 = __importDefault(require("../utils/noDatabaseDbHandler"));
const varDatabaseDbHandler_1 = __importDefault(require("../utils/varDatabaseDbHandler"));
const createTable_1 = __importDefault(require("../utils/createTable"));
const updateTable_1 = __importDefault(require("../utils/updateTable"));
const grab_dir_names_1 = __importDefault(require("../../utils/backend/names/grab-dir-names"));
const check_db_record_1 = __importDefault(require("./check-db-record"));
const handle_indexes_1 = __importDefault(require("./handle-indexes"));
const grab_required_database_schemas_1 = __importStar(require("./grab-required-database-schemas"));
const dbHandler_1 = __importDefault(require("../../functions/backend/dbHandler"));
/**
 * # Create database from Schema Function
 * @requires DSQL_DB_CONN - Gobal Variable for Datasquirel Database
 */
function createDbFromSchema(_a) {
    return __awaiter(this, arguments, void 0, function* ({ userId, targetDatabase, dbSchemaData, targetTable, dbId, }) {
        var _b, _c;
        try {
            const { userSchemaMainJSONFilePath } = (0, grab_dir_names_1.default)({
                userId,
            });
            let dbSchema = dbSchemaData
                ? dbSchemaData
                : dbId
                    ? (0, grab_required_database_schemas_1.default)({
                        dbId,
                        userId,
                    })
                    : undefined;
            if (!dbSchema) {
                console.log("Schema Not Found!");
                return false;
            }
            const isMain = !userSchemaMainJSONFilePath;
            for (let i = 0; i < dbSchema.length; i++) {
                const database = dbSchema[i];
                const { dbFullName, tables, dbSlug, childrenDatabases } = database;
                if (!dbFullName)
                    continue;
                if (targetDatabase && dbFullName != targetDatabase) {
                    continue;
                }
                console.log(`Handling database => ${dbFullName}`);
                const dbCheck = yield (0, noDatabaseDbHandler_1.default)(`SELECT SCHEMA_NAME AS dbFullName FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '${dbFullName}'`);
                if (!((_b = dbCheck === null || dbCheck === void 0 ? void 0 : dbCheck[0]) === null || _b === void 0 ? void 0 : _b.dbFullName)) {
                    const newDatabase = yield (0, noDatabaseDbHandler_1.default)(`CREATE DATABASE IF NOT EXISTS \`${dbFullName}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_bin`);
                }
                const allTables = yield (0, noDatabaseDbHandler_1.default)(`SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='${dbFullName}'`);
                let recordedDbEntry = yield (0, check_db_record_1.default)({
                    dbSchema: database,
                    userId,
                    isMain,
                });
                for (let tb = 0; tb < allTables.length; tb++) {
                    const { TABLE_NAME } = allTables[tb];
                    const targetTableSchema = tables.find((_table) => _table.tableName === TABLE_NAME);
                    /**
                     * @description Check if TABLE_NAME is part of the tables contained
                     * in the user schema JSON. If it's not, the table is either deleted
                     * or the table name has been recently changed
                     */
                    if (!targetTableSchema) {
                        console.log(`Dropping Table ${TABLE_NAME} from ${dbFullName}`);
                        yield (0, varDatabaseDbHandler_1.default)({
                            queryString: `DROP TABLE \`${dbFullName}\`.\`${TABLE_NAME}\``,
                        });
                        const deleteTableEntry = yield (0, dbHandler_1.default)({
                            query: `DELETE FROM datasquirel.user_database_tables WHERE user_id = ? AND db_slug = ? AND table_slug = ?`,
                            values: [userId, dbSlug, TABLE_NAME],
                        });
                        // const oldTable = tables.find(
                        //     (_table) =>
                        //         _table.tableNameOld &&
                        //         _table.tableNameOld === TABLE_NAME
                        // );
                        // /**
                        //  * @description Check if this table has been recently renamed. Rename
                        //  * table id true. Drop table if false
                        //  */
                        // if (oldTable) {
                        //     console.log("Renaming Table");
                        //     await varDatabaseDbHandler({
                        //         queryString: `RENAME TABLE \`${dbFullName}\`.\`${oldTable.tableNameOld}\` TO \`${oldTable.tableName}\``,
                        //     });
                        // } else {
                        //     console.log(
                        //         `Dropping Table ${TABLE_NAME} from ${dbFullName}`
                        //     );
                        //     await varDatabaseDbHandler({
                        //         queryString: `DROP TABLE \`${dbFullName}\`.\`${TABLE_NAME}\``,
                        //     });
                        //     const deleteTableEntry = await dbHandler({
                        //         query: `DELETE FROM datasquirel.user_database_tables WHERE user_id = ? AND db_slug = ? AND table_slug = ?`,
                        //         values: [userId, dbSlug, TABLE_NAME],
                        //     });
                        // }
                    }
                }
                /**
                 * @description Iterate through each table and perform table actions
                 */
                for (let t = 0; t < tables.length; t++) {
                    const table = tables[t];
                    const { tableName, fields, indexes } = table;
                    if (targetTable && tableName !== targetTable)
                        continue;
                    console.log(`Handling table => ${tableName}`);
                    /**
                     * @description Check if table exists
                     * @type {any}
                     */
                    const tableCheck = yield (0, varDatabaseDbHandler_1.default)({
                        queryString: `
                        SELECT EXISTS (
                            SELECT
                            TABLE_NAME
                            FROM
                            information_schema.TABLES
                            WHERE
                            TABLE_SCHEMA = ? AND
                            TABLE_NAME = ?
                        ) AS tableExists`,
                        queryValuesArray: [dbFullName, table.tableName],
                    });
                    if (tableCheck && ((_c = tableCheck[0]) === null || _c === void 0 ? void 0 : _c.tableExists) > 0) {
                        /**
                         * @description Update table if table exists
                         */
                        const updateExistingTable = yield (0, updateTable_1.default)({
                            dbFullName: dbFullName,
                            tableName: tableName,
                            tableFields: fields,
                            userId,
                            dbSchema: database,
                            tableIndexes: indexes,
                            recordedDbEntry,
                            tableSchema: table,
                            isMain,
                        });
                        if (table.childrenTables && table.childrenTables[0]) {
                            for (let ch = 0; ch < table.childrenTables.length; ch++) {
                                const childTable = table.childrenTables[ch];
                                const childTableParentDbSchema = (0, grab_required_database_schemas_1.grabPrimaryRequiredDbSchema)({
                                    dbId: childTable.dbId,
                                    userId,
                                });
                                if (!(childTableParentDbSchema === null || childTableParentDbSchema === void 0 ? void 0 : childTableParentDbSchema.dbFullName))
                                    continue;
                                const childTableSchema = childTableParentDbSchema.tables.find((tbl) => tbl.id == childTable.tableId);
                                if (!childTableSchema)
                                    continue;
                                const updateExistingChildTable = yield (0, updateTable_1.default)({
                                    dbFullName: childTableParentDbSchema.dbFullName,
                                    tableName: childTableSchema.tableName,
                                    tableFields: childTableSchema.fields,
                                    userId,
                                    dbSchema: childTableParentDbSchema,
                                    tableIndexes: childTableSchema.indexes,
                                    clone: true,
                                    recordedDbEntry,
                                    tableSchema: table,
                                    isMain,
                                });
                            }
                        }
                    }
                    else {
                        /**
                         * @description Create new Table if table doesnt exist
                         */
                        const createNewTable = yield (0, createTable_1.default)({
                            tableName: tableName,
                            tableInfoArray: fields,
                            dbFullName: dbFullName,
                            tableSchema: table,
                            recordedDbEntry,
                            isMain,
                        });
                        /**
                         * Handle DATASQUIREL Table Indexes
                         * ===================================================
                         * @description Iterate through each datasquirel schema
                         * table index(if available), and perform operations
                         */
                        if (indexes === null || indexes === void 0 ? void 0 : indexes[0]) {
                            (0, handle_indexes_1.default)({
                                dbFullName,
                                indexes,
                                tableName,
                            });
                        }
                    }
                }
                /**
                 * @description Check all children databases
                 */
                if (childrenDatabases === null || childrenDatabases === void 0 ? void 0 : childrenDatabases[0]) {
                    for (let ch = 0; ch < childrenDatabases.length; ch++) {
                        const childDb = childrenDatabases[ch];
                        const { dbId } = childDb;
                        const targetDatabase = dbSchema.find((dbSch) => dbSch.childDatabaseDbId == dbId);
                        if (targetDatabase === null || targetDatabase === void 0 ? void 0 : targetDatabase.id) {
                            yield createDbFromSchema({
                                userId,
                                dbId: targetDatabase === null || targetDatabase === void 0 ? void 0 : targetDatabase.id,
                            });
                        }
                    }
                }
            }
            return true;
        }
        catch (error) {
            console.log(`createDbFromSchema ERROR => ${error.message}`);
            return false;
        }
    });
}