import fs from "fs";
import path from "path";
import grabDirNames from "../../../../../utils/backend/names/grab-dir-names";
import { APIResponseObject, UserType } from "../../../../../types";
import { DSQL_DATASQUIREL_BACKUPS } from "../../../../../types/dsql";
import importMariadbDatabase from "../../../../../utils/backend/import-mariadb-database";

type Params = {
    user: UserType;
    backup: DSQL_DATASQUIREL_BACKUPS;
};

export default async function suRestoreBackup({
    user,
    backup,
}: Params): Promise<APIResponseObject> {
    try {
        const {
            mainBackupDir,
            userBackupDir,
            sqlBackupDirName,
            schemasBackupDirName,
            targetUserPrivateDir,
            oldSchemasDir,
        } = grabDirNames({
            userId: backup.user_id,
        });

        if (backup.user_id && !userBackupDir) {
            return {
                success: false,
                msg: `Error grabbing user backup directory`,
            };
        }

        if (!backup.uuid) {
            return {
                success: false,
                msg: `No UUID found for backup`,
            };
        }

        const existingBackupDir = path.join(
            backup.user_id && userBackupDir ? userBackupDir : mainBackupDir,
            backup.uuid
        );

        const userDatabases = fs.readdirSync(
            path.join(existingBackupDir, sqlBackupDirName)
        );

        const databasesToRestore = userDatabases?.map(
            (db) => db.split(".")[0]
        ) || [process.env.DSQL_DB_NAME || "datasquirel"];

        for (let i = 0; i < databasesToRestore.length; i++) {
            const dbToBackup = databasesToRestore[i];
            if (!dbToBackup) continue;

            const dbFileName = `${dbToBackup}.sql`;
            const dbFilePath = path.join(
                existingBackupDir,
                sqlBackupDirName,
                dbFileName
            );

            importMariadbDatabase({
                dbFullName: dbToBackup,
                targetFilePath: dbFilePath,
            });
        }

        const userSchemaDirFiles = targetUserPrivateDir
            ? fs
                  .readdirSync(targetUserPrivateDir)
                  .filter((dirName) => dirName.match(/^\d+\.json$/))
            : undefined;
        const appSchemaDirFiles = fs
            .readdirSync(oldSchemasDir)
            .filter((dirName) => dirName.match(/^\d+\.json$/));

        const schemaFilesToWrite =
            backup.user_id && userSchemaDirFiles
                ? userSchemaDirFiles
                : appSchemaDirFiles;

        for (let i = 0; i < schemaFilesToWrite.length; i++) {
            const schemaFileName = schemaFilesToWrite[i];

            const originSchemaFilePath = path.join(
                existingBackupDir,
                schemasBackupDirName,
                schemaFileName
            );

            const destinationSchemaFilePath = path.join(
                backup.user_id && targetUserPrivateDir
                    ? targetUserPrivateDir
                    : oldSchemasDir,
                schemaFileName
            );

            fs.copyFileSync(originSchemaFilePath, destinationSchemaFilePath);
        }

        return { success: true };
    } catch (error: any) {
        return {
            success: false,
            msg: `Failed to write backup files`,
            error: error.message,
        };
    }
}