import varDatabaseDbHandler from "../../functions/backend/varDatabaseDbHandler";
import addDbEntry from "../../functions/backend/db/addDbEntry";
import slugToCamelTitle from "../../shell/utils/slugToCamelTitle";
import grabDSQLSchemaIndexComment from "../../shell/utils/grab-dsql-schema-index-comment";
import { grabPrimaryRequiredDbSchema, writeUpdatedDbSchema, } from "../../shell/createDbFromSchema/grab-required-database-schemas";
import _n from "../../utils/numberfy";
import dataTypeParser from "../../utils/db/schema/data-type-parser";
import dataTypeConstructor from "../../utils/db/schema/data-type-constructor";
export default async function createDbSchemaFromDb({ userId, database, dbId, }) {
    var _a, _b, _c, _d, _e, _f;
    try {
        if (!userId) {
            console.log("No user Id provided");
            return;
        }
        const targetDb = grabPrimaryRequiredDbSchema({
            userId,
            dbId: database.db_schema_id || dbId,
        });
        if (!targetDb)
            throw new Error(`Target Db not found!`);
        const existingTables = await varDatabaseDbHandler({
            database: database.db_full_name,
            queryString: `SHOW TABLES FROM ${database.db_full_name}`,
        });
        if (!existingTables)
            throw new Error("No Existing Tables");
        for (let i = 0; i < existingTables.length; i++) {
            const table = existingTables[i];
            const tableName = Object.values(table)[0];
            const tableInsert = await addDbEntry({
                dbFullName: "datasquirel",
                tableName: "user_database_tables",
                data: {
                    user_id: _n(userId),
                    db_id: database.id,
                    db_slug: database.db_slug,
                    table_name: slugToCamelTitle(tableName) || undefined,
                    table_slug: tableName,
                },
            });
            const tableObject = {
                tableName: tableName,
                fields: [],
                indexes: [],
            };
            const tableColumns = await varDatabaseDbHandler({
                database: database.db_full_name,
                queryString: `SHOW COLUMNS FROM ${database.db_full_name}.${tableName}`,
            });
            if (tableColumns) {
                for (let k = 0; k < tableColumns.length; k++) {
                    const tableColumn = tableColumns[k];
                    const { Field, Type, Null, Key, Default, Extra } = tableColumn;
                    const parsedDataType = dataTypeParser(Type.toUpperCase());
                    const fieldObject = {
                        fieldName: Field,
                        dataType: dataTypeConstructor(parsedDataType.type, parsedDataType.limit, parsedDataType.decimal),
                    };
                    if (Null === null || Null === void 0 ? void 0 : Null.match(/^no$/i))
                        fieldObject.notNullValue = true;
                    if (Key === null || Key === void 0 ? void 0 : Key.match(/^pri$/i))
                        fieldObject.primaryKey = true;
                    if ((_a = Default === null || Default === void 0 ? void 0 : Default.toString()) === null || _a === void 0 ? void 0 : _a.match(/./))
                        fieldObject.defaultValue = Default;
                    if ((_b = Default === null || Default === void 0 ? void 0 : Default.toString()) === null || _b === void 0 ? void 0 : _b.match(/timestamp/i)) {
                        delete fieldObject.defaultValue;
                        fieldObject.defaultValueLiteral = Default;
                    }
                    if ((_c = Extra === null || Extra === void 0 ? void 0 : Extra.toString()) === null || _c === void 0 ? void 0 : _c.match(/auto_increment/i))
                        fieldObject.autoIncrement = true;
                    tableObject.fields.push(fieldObject);
                }
            }
            const tableIndexes = await varDatabaseDbHandler({
                database: database.db_full_name,
                queryString: `SHOW INDEXES FROM ${database.db_full_name}.${tableName}`,
            });
            if (tableIndexes) {
                for (let m = 0; m < tableIndexes.length; m++) {
                    const indexObject = tableIndexes[m];
                    const { Table, Key_name, Column_name, Null, Index_type, Index_comment, } = indexObject;
                    if (!(Index_comment === null || Index_comment === void 0 ? void 0 : Index_comment.match(new RegExp(grabDSQLSchemaIndexComment()))))
                        continue;
                    const indexNewObject = {
                        indexType: (Index_type === null || Index_type === void 0 ? void 0 : Index_type.match(/fulltext/i))
                            ? "full_text"
                            : "regular",
                        indexName: Key_name,
                        indexTableFields: [],
                    };
                    const targetTableFieldObject = tableColumns === null || tableColumns === void 0 ? void 0 : tableColumns.filter((col) => col.Field === Column_name)[0];
                    const existingIndexField = (_d = tableObject.indexes) === null || _d === void 0 ? void 0 : _d.filter((indx) => indx.indexName == Key_name);
                    if (existingIndexField && existingIndexField[0]) {
                        (_e = existingIndexField[0].indexTableFields) === null || _e === void 0 ? void 0 : _e.push({
                            value: Column_name,
                            dataType: targetTableFieldObject.Type.toUpperCase(),
                        });
                    }
                    else {
                        indexNewObject.indexTableFields = [
                            {
                                value: Column_name,
                                dataType: targetTableFieldObject.Type.toUpperCase(),
                            },
                        ];
                        (_f = tableObject.indexes) === null || _f === void 0 ? void 0 : _f.push(indexNewObject);
                    }
                }
            }
            targetDb.tables.push(tableObject);
        }
        writeUpdatedDbSchema({ dbSchema: targetDb, userId });
        return true;
    }
    catch (error) {
        console.log(error);
        return false;
    }
}