internationalisation.service.ts

import { Injectable } from '@angular/core';
import { Response } from '@angular/http';

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

import { StringMap } from "../../stringmap";
import { ServiceFactory } from '../service-factory';

/*
  language tag : fr-FR
  primary subcode : fr
  optional subcode : FR
 */
export enum LanguageCode {
    FRENCH,

    ENGLISH,
}


export class Language {
    private _code: LanguageCode;
    private _tag: string;
    private _label: string;

    constructor(c: LanguageCode, t: string, l: string) {
        this._code = c;
        this._tag = t;
        this._label = l;
    }

    get code(): LanguageCode {
        return this._code;
    }

    get tag(): string {
        return this._tag;
    }

    get label(): string {
        return this._label;
    }
}

@Injectable()
export class InternationalisationService extends Observable {
    private _currLang: Language;
    private _sLang: string;
    private _Messages: StringMap;

    private _languages: Language[];

    public constructor() {
        super();
        this._languages = [];
        this._languages.push(new Language(LanguageCode.FRENCH, "fr", "Français"));
        this._languages.push(new Language(LanguageCode.ENGLISH, "en", "English"));
    }

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

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

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

    private getLanguageFromCode(lc: LanguageCode) {
        for (let l of this._languages) {
            if (l.code === lc)
                return l;
        }
        throw new Message(MessageCode.ERROR_LANG_UNSUPPORTED);
    }

    private getLanguageFromTag(tag: string) {
        for (let l of this._languages) {
            if (l.tag === tag)
                return l;
        }
        let e = new Message(MessageCode.ERROR_LANG_UNSUPPORTED);
        e.extraVar["locale"] = tag;
        throw e;
    }

    public setLocale(lng: string | LanguageCode) {
        if (this._currLang !== undefined)
            var oldLang: LanguageCode = this._currLang.code;

        if (typeof lng === "string") {
            let t: string = lng.substr(0, 2).toLowerCase();
            this._currLang = this.getLanguageFromTag(t);
        }
        else {
            this._currLang = this.getLanguageFromCode(lng);
        }

        let prom = this.httpGetMessages();
        prom.then((res) => {
            this.notifyObservers(undefined);
        })
    }

    private httpGetMessages(): Promise<Response> {
        let is: InternationalisationService = this;
        let processData = function (s: string) {
            // fermeture nécessaire pour capturer la valeur de this (undefined sinon)
            is._Messages = JSON.parse(s);
        }

        let l;
        switch (this._currLang.code) {
            case LanguageCode.FRENCH:
                l = "fr";
                break;

            default:
                l = "en";
        }

        let f: string = "error_messages." + l + ".json"
        return ServiceFactory.instance.httpService.httpGetRequest(undefined, undefined, undefined, "locale/" + f, processData);
    }

    private getMessageFromCode(c: MessageCode): string {
        let sCode: string = MessageCode[c];
        return this._Messages[MessageCode[c]];
    }

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

    /**
     * traduit un message
     * @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 sCode: string = MessageCode[r.code];
        let m: string = this.getMessageFromCode(r.code);

        for (let k in r.extraVar) {
            let v: any = r.extraVar[k];
            if (typeof v === "number")
                var s = v.toFixed(nDigits);
            else
                s = v;
            m = this.replaceAll(m, "%" + k + "%", s);
        }

        return m;
    }

    /**
     * Traduit un texte défini dans les fichiers error_message.xx.json
     * Les ids dans ces fichiers sont soit un enum de JalHyd, soit une chaine libre correspondant au code passé àlocalizeText()
     * @param code id du texte
     */
    public localizeText(code: string) {
        if (this._Messages === undefined) {
            return "<messages not loaded>";
        }
        if (this._Messages[code] === undefined) {
            return `<message not exists: ${code}>`;
        }
        return this._Messages[code];
    }

    /**
     * analyse un libellé du type ouvrage[n].XX
     */
    private parseLabel(lbl: string) {
        const re = /([A-Z,a-z]+)\[(\d+)\]\.(.+)/;
        return re.exec(lbl);
    }

    /**
     * traduit un libellé qui peut être un code
     */
    public translateLabel(o: any) {
        let res;
        if (typeof o === "string") {
            switch (o) {
                case "flu":
                    res = this.localizeText("INFO_REMOUSRESULTS_LIGNEFLUVIALE");
                    break;

                case "tor":
                    res = this.localizeText("INFO_REMOUSRESULTS_LIGNETORRENTIELLE");
                    break;

                default:
                    const match = this.parseLabel(o);
                    if (match) {
                        if (match[1] === "ouvrage")
                            res = this.localizeText("INFO_OUVRAGE") + " n°" + (+match[2] + 1);

                        const p = match[3];
                        switch (p) {
                            case "Q":
                                res += " : " + this.localizeText("INFO_GRANDEUR_" + p);
                                break;

                            case "Q_Mode":
                                res += " : " + this.localizeText("INFO_TYPE_ECOULEMENT");
                                break;

                            case "Q_Regime":
                                res += " : " + this.localizeText("INFO_REGIME");
                                break;
                        }
                    }
                    else
                        res = o;
                    break;
            }
        }
        return res;
    }

    /**
     * met en forme ou traduit un résultat en fonction du libellé qui l'accompagne
     */
    public formatResult(label: string, value: number): string {
        const match = this.parseLabel(label);
        if (match)
            switch (match[1]) {
                case "ouvrage":
                    switch (match[3]) {
                        case "Q_Mode":
                            switch (value) {
                                case 0:
                                case 1:
                                case 2:
                                    const key = `INFO_LIB_ENUM_RES_STRUCTURE_MODE_${value}`;
                                    return this.localizeText(key);

                                default:
                                    throw new Error(`InternationalisationService.formatResult : valeur ${value} incorrecte pour STRUCTURE_MODE`);
                            }

                        case "Q_Regime":
                            switch (value) {
                                case 0:
                                case 1:
                                case 2:
                                    const key = `INFO_LIB_ENUM_RES_STRUCTURE_REGIME_${value}`;
                                    return this.localizeText(key);

                                default:
                                    throw new Error(`InternationalisationService.formatResult : valeur ${value} incorrecte pour STRUCTURE_REGIME`);
                            }

                    }
            }

        const appSetupService = ServiceFactory.instance.applicationSetupService;
        const nDigits = appSetupService.displayDigits;
        return value.toFixed(nDigits);
    }
}