import { logger } from "@/src/utils/logger";
import fs from "fs";
import path from "path";
import prettier from "prettier";

const languageList = ["de", "es", "fr", "it", "ja", "ko", "pl", "pt", "ru", "tr", "uk", "zh", "tc", "th"];
const baseLangFile = "./static/webui/translations/en.json";
const oldLangFile = "./static/webui/translations/old_en.json";

function mergeTranslations(source: Record<string, unknown>, target: Record<string, unknown>) {
    Object.keys(source).forEach(key => {
        if (typeof source[key] === "object" && source[key] !== null) {
            if (!target[key] || typeof target[key] !== "object") {
                target[key] = {};
            }
            mergeTranslations(source[key] as Record<string, unknown>, target[key] as Record<string, unknown>);
        } else if (!(key in target)) {
            target[key] = "";
        }
    });
}

function compareAndUpdateTranslations(
    newData: Record<string, unknown>,
    oldData: Record<string, unknown>,
    langData: Record<string, unknown>
): boolean {
    let updated = false;

    Object.keys(newData).forEach(key => {
        const newValue = newData[key];
        const oldValue = oldData[key];

        if (typeof newValue === "object" && newValue !== null) {
            if (typeof oldValue !== "object" || oldValue === null) {
                langData[key] = { ...newValue };
                updated = true;
            } else {
                const isSubUpdated = compareAndUpdateTranslations(
                    newValue as Record<string, unknown>,
                    oldValue as Record<string, unknown>,
                    langData[key] as Record<string, unknown>
                );
                if (isSubUpdated) {
                    updated = true;
                }
            }
        } else {
            if (newValue !== oldValue) {
                langData[key] = newValue;
                updated = true;
            }
        }
    });

    return updated;
}

async function processTranslations() {
    let enData: Record<string, unknown>;
    let oldEnData: Record<string, unknown> = {};

    try {
        enData = JSON.parse(fs.readFileSync(baseLangFile, "utf-8"));
        oldEnData = fs.existsSync(oldLangFile) ? JSON.parse(fs.readFileSync(oldLangFile, "utf-8")) : {};
    } catch (error) {
        logger.error("Error reading base or old language files:", error);
        process.exit(1);
    }

    for (const lang of languageList) {
        const langFile = `./static/webui/translations/${lang}.json`;
        const langPath = path.resolve(langFile);

        if (!fs.existsSync(langPath)) {
            logger.warn(`File ${langFile} not found! Creating a new one.`);
            fs.writeFileSync(langPath, JSON.stringify({}, null, 2), "utf-8");
        }

        try {
            const langData: Record<string, unknown> = JSON.parse(fs.readFileSync(langPath, "utf-8"));

            const originalLangDataStr = JSON.stringify(langData);

            compareAndUpdateTranslations(enData, oldEnData, langData);
            mergeTranslations(enData, langData);

            const newLangDataStr = JSON.stringify(langData);
            if (originalLangDataStr !== newLangDataStr) {
                const formattedLangData = await prettier.format(newLangDataStr, { parser: "json" });
                fs.writeFileSync(langPath, formattedLangData, "utf-8");
                logger.info(`Updated: ${langFile}`);
            }
        } catch (error) {
            logger.error(`Error processing ${langFile}:`, error);
        }
    }

    try {
        const formattedEnData = await prettier.format(JSON.stringify(enData), {
            parser: "json"
        });

        fs.writeFileSync(oldLangFile, formattedEnData, "utf-8");
        logger.info("Updated old_en.json with the latest translations.");
        process.exit(0);
    } catch (error) {
        logger.error("Error during the formatting or writing of old_en.json:", error);
        process.exit(1);
    }
}
void processTranslations();