internationalisation.service.ts

import { Injectable, isDevMode } from "@angular/core";

import { Message, MessageCode, Observable, Observer, Nub } from "jalhyd";

import { StringMap } from "../stringmap";
import { ApplicationSetupService } from "./app-setup.service";
import { HttpService } from "./http.service";
import { fv, decodeHtml } from "../util";
import { ServiceFactory } from "./service-factory";

@Injectable()
export class I18nService extends Observable implements Observer {

    /** current ISO 639-1 language code */
    private _currentLanguage: string;

    /** current available languages as ISO 639-1 codes => native name */
    private _availableLanguages: any;

    /** localized messages */
    private _Messages: StringMap;

    /** localized messages in fallback language (the one in the config file) */
    private _fallbackMessages: StringMap;

    constructor(
        private applicationSetupService: ApplicationSetupService,
        private httpService: HttpService
    ) {
        super();
        this._availableLanguages = {
            fr: "Français",
            en: "English"
        };
        // load fallback language messages once for all
        this.httpGetMessages(this.applicationSetupService.fallbackLanguage).then((res: any) => {
            this._fallbackMessages = res;
        });
        // add language preferences observer
        this.applicationSetupService.addObserver(this);
    }

    public get languages() {
        return this._availableLanguages;
    }

    public get currentLanguage() {
        return this._currentLanguage;
    }

    public get currentMap() {
        return this._Messages;
    }

    /**
     * Defines the current language code from its ISO 639-1 code (2 characters) or locale code
     * (ex: "fr", "en", "fr_FR", "en-US")
     * @see this.languageCodeFromLocaleCode()
     *
     * @param code ISO 639-1 language code
     */
    public setLanguage(code: string) {
        // is language supported ?
        if (! Object.keys(this._availableLanguages).includes(code)) {
            throw new Error(`LANGUAGE_UNSUPPORTED "${code}"`);
        }
        // did language change ?
        if (this._currentLanguage !== code) {
            this._currentLanguage = code;
            this._Messages = undefined;
            // reload all messages
            const that = this;
            this.httpGetMessages(code).then((res: any) => {
                that._Messages = res;
                // propagate language change to all application
                that.notifyObservers(undefined);
            });
        }
    }

    /**
     * Loads localized messages from JSON files for the given language
     * (general messages files, not calculator-specific ones)
     */
    private httpGetMessages(lang: string): Promise<void> {
        const fileName = "messages." + lang + ".json";
        const filePath = "locale/" + fileName;
        return this.httpService.httpGetRequestPromise(filePath).then((res: any) => {
            return res;
        });
    }

    private getMessageFromCode(c: MessageCode): string {
        if (! this._Messages) {
            return `*** messages not loaded yet ***`;
        }
        if (this._Messages[MessageCode[c]] === undefined) {
            return `*** message not found ${MessageCode[c]} ***`;
        }
        return this._Messages[MessageCode[c]];
    }

    /**
     * Translates a text from its key.
     *
     * In production mode, looks in different messages collections :
     *  1. ${msg} if provided
     *  2. messages for current language
     *  3. messages for fallback language
     *
     * In dev mode, looks only in 1. if provided, else only in 2. which makes missing
     * translations easier to detect
     *
     * @param textKey id du texte (ex: "ERROR_PARAM_NULL")
     */
    public localizeText(textKey: string, msg?: StringMap) {
        const messages = msg || this._Messages;
        if (! messages) {
            return `*** messages not loaded: ${this._currentLanguage} ***`;
        }
        if (messages[textKey] !== undefined) {
            return messages[textKey];
        } else {
            // try general message
            if(msg !== undefined && this._Messages["INFO_LIB_"+textKey.toUpperCase()] !== undefined) {
                return this._Messages["INFO_LIB_"+textKey.toUpperCase()];
            }
            if (!isDevMode()) {
                // try fallback language before giving up
                if (this._fallbackMessages[textKey] !== undefined) {
                    return this._fallbackMessages[textKey];
                }
            }
            return `*** message not found: ${textKey} ***`;
        }
    }

    /**
     * Traduit un Message (classe Message de JaLHyd, pour les logs de calcul par exemple)
     * @param r Message
     * @param nDigits nombre de chiffres à utiliser pour l'arrondi dans le cas de données numériques
     */
    public localizeMessage(r: Message, nDigits: number = 3): string {
        let m: string = this.getMessageFromCode(r.code);

        for (const k in r.extraVar) {
            if (r.extraVar.hasOwnProperty(k)) {
                const v: any = r.extraVar[k];
                let s: string;
                // detect variable names to translate
                if (k === "variables" && Array.isArray(v)) {
                    // array of variable names
                    s = v.map((e) => {
                        return this.localizeText("INFO_LIB_" + e.toUpperCase());
                    }).join(", ");
                } else if (k.substring(0, 4) === "var_") {
                    // single variable name
                    s = this.localizeText("INFO_LIB_" + v.toUpperCase());
                } else {
                    if (typeof v === "number") {
                        s = fv(v);
                    } else {
                        s = v;
                    }
                }
                m = this.replaceAll(m, "%" + k + "%", s);
            }
        }

        // replace "ENUM_X_Y" by translated enum value;
        // example for lang "fr" : "ENUM_SPECIES_6" => "INFO_ENUM_SPECIES_6" => "Ombre commun"
        // (partly redundant with MSG_* but shorter to write)
        m = m.replace(/(ENUM_[^ ,;\.]+)/g, (match, p1) => {
            return this.localizeText("INFO_" + p1);
        });

        // replace "FORM_ID_X" by form name in current session, if any
        m = m.replace(/FORM_ID_(\w{6})/g, (match, p1) => {
            // cannot inject FormulaireService => cyclic dependency :/
            const form = ServiceFactory.instance.formulaireService.getFormulaireFromNubId(p1);
            let formName = "**UNKNOWN_FORM**";
            if (form !== undefined) {
                formName = form.calculatorName;
            }
            return formName;
        });

        // replace MSG_* with the translation of * ; allows
        // to inject any text translation in a message
        m = m.replace(/MSG_([^ ,;\.]+)/g, (match, p1) => {
            return this.localizeText(p1);
        });

        return decodeHtml(m);
    }

    private replaceAll(str: string, find: string, replace: string) {
        return str.replace(new RegExp(find, "g"), replace);
    }

    /**
     * Met en forme un result en fonction du libellé qui l'accompagne
     * Les result avec le terme "ENUM_" sont traduit avec le message INFO_ENUM_[Nom de la variable après ENUM_]
     */
    public formatResult(label: string, value: number): string {
        if (value === undefined) {
            return "";
        }
        const match = label.indexOf("ENUM_");
        if (match > -1) {
            return this.localizeText(`INFO_${label.substring(match).toUpperCase()}_${value}`);
        }
        return fv(value);
    }

    /**
     * Returns the localized name for the children type of the current Nub
     * @param plural if true, will return plural name
     */
    public childName(nub: Nub, plural: boolean = false) {
        const type: string = nub.childrenType;
        let k = "INFO_CHILD_TYPE_" + type.toUpperCase();
        if (plural) {
            k += "_PLUR";
        }
        return this.localizeText(k);
    }

    // interface Observer

    /**
     * Should only be triggered once at app startup, when setup service tries loading language
     * @param sender should always be ApplicationSetupService
     * @param data object {
     *                  action: should always be "languagePreferenceChanged"
     *                  languages: languages codes to try until one works
     *              }
     */
    public update(sender: any, data: any): void {
        if (sender instanceof ApplicationSetupService) {
            if (data.action === "languagePreferenceChanged") {
                let languageEventuallyUsed: string;
                for (let i = 0; i < data.languages.length && languageEventuallyUsed === undefined; i++) {
                    const l = data.languages[i];
                    if (l !== undefined) {
                        try {
                            this.setLanguage(l);
                            languageEventuallyUsed = l;
                        } catch (e) {
                            console.error(e.toString());
                        }
                    }
                }
                // confirm to setup service which language was eventually used at app startup (triggers nothing more)
                this.applicationSetupService.language = languageEventuallyUsed;
            }
        }
    }
}