import varDatabaseDbHandler from "../../functions/backend/varDatabaseDbHandler";
import addDbEntry from "../../functions/backend/db/addDbEntry";
import slugToCamelTitle from "../../shell/utils/slugToCamelTitle";
import {
    DSQL_DATASQUIREL_USER_DATABASE_TABLES,
    DSQL_DATASQUIREL_USER_DATABASES,
} from "../../types/dsql";
import {
    DSQL_FieldSchemaType,
    DSQL_IndexSchemaType,
    DSQL_MYSQL_SHOW_COLUMNS_Type,
    DSQL_TableSchemaType,
} from "../../types";
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";

type Params = {
    userId: number | string;
    database: DSQL_DATASQUIREL_USER_DATABASES;
    dbId?: string | number;
};

export default async function createDbSchemaFromDb({
    userId,
    database,
    dbId,
}: Params) {
    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] as string;

            const tableInsert =
                await addDbEntry<DSQL_DATASQUIREL_USER_DATABASE_TABLES>({
                    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: DSQL_TableSchemaType = {
                tableName: tableName,
                fields: [],
                indexes: [],
            };

            const tableColumns: DSQL_MYSQL_SHOW_COLUMNS_Type[] =
                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: DSQL_FieldSchemaType = {
                        fieldName: Field,
                        dataType: dataTypeConstructor(
                            parsedDataType.type,
                            parsedDataType.limit,
                            parsedDataType.decimal
                        ),
                    };

                    if (Null?.match(/^no$/i)) fieldObject.notNullValue = true;
                    if (Key?.match(/^pri$/i)) fieldObject.primaryKey = true;
                    if (Default?.toString()?.match(/./))
                        fieldObject.defaultValue = Default;
                    if (Default?.toString()?.match(/timestamp/i)) {
                        delete fieldObject.defaultValue;
                        fieldObject.defaultValueLiteral = Default;
                    }
                    if (Extra?.toString()?.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?.match(
                            new RegExp(grabDSQLSchemaIndexComment())
                        )
                    )
                        continue;

                    const indexNewObject: DSQL_IndexSchemaType = {
                        indexType: Index_type?.match(/fulltext/i)
                            ? "full_text"
                            : "regular",
                        indexName: Key_name,
                        indexTableFields: [],
                    };

                    const targetTableFieldObject = tableColumns?.filter(
                        (col) => col.Field === Column_name
                    )[0];

                    const existingIndexField = tableObject.indexes?.filter(
                        (indx) => indx.indexName == Key_name
                    );

                    if (existingIndexField && existingIndexField[0]) {
                        existingIndexField[0].indexTableFields?.push({
                            value: Column_name,
                            dataType: targetTableFieldObject.Type.toUpperCase(),
                        });
                    } else {
                        indexNewObject.indexTableFields = [
                            {
                                value: Column_name,
                                dataType:
                                    targetTableFieldObject.Type.toUpperCase(),
                            },
                        ];

                        tableObject.indexes?.push(indexNewObject);
                    }
                }
            }

            targetDb.tables.push(tableObject);
        }

        writeUpdatedDbSchema({ dbSchema: targetDb, userId });
        return true;
    } catch (error) {
        console.log(error);

        return false;
    }
}