import fs from "fs";
import path from "path";
import { DSQL_DATASQUIREL_BACKUPS } from "../../../../../types/dsql";
import { APIResponseObject } from "../../../../../types";
import grabDirNames from "../../../../../utils/backend/names/grab-dir-names";
import { AppNames } from "../../../../../dict/app-names";
import dbHandler from "../../../dbHandler";
import exportMariadbDatabase from "../../../../../utils/backend/export-mariadb-database";

type Params = {
    backup: DSQL_DATASQUIREL_BACKUPS;
};

export default async function writeBackupFiles({
    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 newBackupDir = path.join(
            backup.user_id && userBackupDir ? userBackupDir : mainBackupDir,
            backup.uuid
        );

        fs.mkdirSync(newBackupDir, { recursive: true });
        fs.mkdirSync(path.join(newBackupDir, sqlBackupDirName), {
            recursive: true,
        });
        fs.mkdirSync(path.join(newBackupDir, schemasBackupDirName), {
            recursive: true,
        });

        const userDatabases = backup.user_id
            ? ((await dbHandler({
                  query: `SHOW DATABASES LIKE '${AppNames["DsqlDbPrefix"]}${backup.user_id}_%'`,
              })) as { [k: string]: string }[])
            : undefined;

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

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

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

            exportMariadbDatabase({
                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(
                backup.user_id && targetUserPrivateDir
                    ? targetUserPrivateDir
                    : oldSchemasDir,
                schemaFileName
            );

            const destinationSchemaFilePath = path.join(
                newBackupDir,
                schemasBackupDirName,
                schemaFileName
            );

            fs.copyFileSync(originSchemaFilePath, destinationSchemaFilePath);
        }

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