let translationsLoaded = false;
let translationData = null;

const parser = window.moParser || undefined;

let locale = window._locale;

console.log('Detected locale:', locale);

if(!locale)
{
    const localeRegex = /[a-z]{2}-[A-Z]{2}/g;
    const currentUrl = window.location.href;
    const matches = currentUrl.match(localeRegex);
    locale = matches ? matches[0] : 'en-AU';
}

const loadMo = async () => {
    if (locale.startsWith('en'))
	{
		console.log('Locale is English, skipping MO file load.');
        return;
    }

	console.log('Translation service initialized for locale:', locale);

    try {
		const microTime = Date.now() * 1000; // current microseconds (approx)
		const response = await fetch(`/storage/translations/${locale}?cacheBust=${microTime}`);

		if (!response.ok)
		{
			throw new Error(`HTTP error! status: ${response.status}`);
		}

		translationsLoaded = true;
		translationData = await parser.parse(response);

		//console.log('translationData:', translationData);

	} catch (error) {
		console.error("Error loading MO file:", error);
	}
}

const hasTranslation = (msgstr) => {
    if (!msgstr) return false;
    for (let i = 0; i < msgstr.length; i++) {
        if (!msgstr[i].length) return false;
    }
    return true;
}

const getTranslation = (text, ctx = '') => {
    if (!('translations' in translationData)) {
        return text;
    }

    const transCtx = translationData.translations[ctx] || translationData.translations[''] || null;
    if (!transCtx) {
        return text;
    }

    const translation = transCtx && transCtx[text];

    if (translation && hasTranslation(translation)) {
        return translation.msgstr[0];
    }

    return null;
}

const submitUnknownTranslation = async (text, locale) => {
    if (locale.startsWith('en')) {
        return text;
    }

    const url = '/pos/translations/unknown';

    const body = {
        content: text,
        locale: locale
    };

    const resp = await fetch(url, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(body)
    });

    if (!resp.ok) {
        console.error(`Failed to submit unknown translation for "${text}" in locale "${locale}".`);
        return;
    }

    const data = await resp.json();
    if (data.status !== 'success' || !data.translation) {
        console.error(`Failed to submit unknown translation for "${text}" in locale "${locale}": ${data.error || 'Unknown response'}`);
    }
}

loadMo().then(() => {
    window.translationData = translationData;
    window.translationService =
    {
        translate: (text) => {
            if(typeof text !== 'string' || text?.trim() === '') {
                return text;
            }

            if (locale.startsWith('en')) {
                return text;
            }

            if (!translationsLoaded || !translationData) {
                console.warn('Translations not loaded yet.');
                return text;
            }

            const translatedText = getTranslation(text);
            if(!translatedText) {
                submitUnknownTranslation(text, locale);
            }

            return translatedText || text;
        }
    };

})