formulaire.service.ts

import { Injectable } from "@angular/core";
import { decode } from "he";
import { saveAs } from "file-saver";

import { CalculatorType, LinkedValue, Observable, ParamDefinition, Session, Nub, ParallelStructure } from "jalhyd";

import { HttpService } from "../../services/http/http.service";
import { I18nService } from "../../services/internationalisation/internationalisation.service";
import { FormulaireDefinition } from "../../formulaire/definition/form-definition";
import { FormulaireElement } from "../../formulaire/formulaire-element";
import { InputField } from "../../formulaire/input-field";
import { SelectField } from "../../formulaire/select-field";
import { StringMap } from "../../stringmap";
import { FormulaireBase } from "../../formulaire/definition/concrete/form-base";
import { FormulaireLechaptCalmon } from "../../formulaire/definition/concrete/form-lechapt-calmon";
import { FormulaireSectionParametree } from "../../formulaire/definition/concrete/form-section-parametree";
import { FormulaireCourbeRemous } from "../../formulaire/definition/concrete/form-courbe-remous";
import { FormulaireRegimeUniforme } from "../../formulaire/definition/concrete/form-regime-uniforme";
import { FormulaireParallelStructure } from "../../formulaire/definition/concrete/form-parallel-structures";
import { NgParameter } from "../../formulaire/ngparam";
import { FieldsetContainer } from "../..//formulaire/fieldset-container";
import { ApplicationSetupService } from "../app-setup/app-setup.service";
import { NotificationsService } from "../notifications/notifications.service";

@Injectable()
export class FormulaireService extends Observable {
    /** list of known forms */
    private _formulaires: FormulaireDefinition[];

    private _currentFormId: string = null;

    /** to avoid loading language files multiple times */
    private languageCache = {};

    constructor(
        private i18nService: I18nService,
        private appSetupService: ApplicationSetupService,
        private httpService: HttpService,
        private intlService: I18nService,
        private notificationsService: NotificationsService
    ) {
        super();
        this._formulaires = [];
    }

    private get _intlService(): I18nService {
        return this.i18nService;
    }

    private get _httpService(): HttpService {
        return this.httpService;
    }

    public get formulaires(): FormulaireDefinition[] {
        return this._formulaires;
    }

    /**
     * Loads the localisation file dedicated to calculator type ct; tries the current
     * language then the fallback language
     */
    private loadLocalisation(calc: CalculatorType): Promise<any> {
        const lang = this._intlService.currentLanguage;
        return this.loadLocalisationForLang(calc, lang).then((localisation) => {
            return localisation as StringMap;
        }).catch((e) => {
            console.error(e);
            // try default lang (the one in the config file) ?
            const fallbackLang = this.appSetupService.fallbackLanguage;
            if (lang !== fallbackLang) {
                console.error(`trying fallback language: ${fallbackLang}`);
                return this.loadLocalisationForLang(calc, fallbackLang);
            }
        });
    }

    /**
     * Loads the localisation file dedicated to calculator type ct for language lang;
     * keeps it in cache for subsequent calls ()
     */
    private loadLocalisationForLang(calc: CalculatorType, lang: string): Promise<any> {
        const ct = String(calc);
        // already in cache ?
        if (Object.keys(this.languageCache).includes(ct) && Object.keys(this.languageCache[calc]).includes(lang)) {
            return new Promise((resolve) => {
                resolve(this.languageCache[ct][lang]);
            });
        } else {
            const f: string = this.getConfigPathPrefix(calc) + lang + ".json";
                return this._httpService.httpGetRequestPromise(f).then((localisation) => {
                this.languageCache[ct] = this.languageCache[ct] || {};
                this.languageCache[ct][lang] = localisation;
                return localisation as StringMap;
            }).catch((e) => {
                throw new Error(`LOCALISATION_FILE_NOT_FOUND "${f}"`);
            });
        }
    }

    /**
     * Loads localisation file corresponding to current language then updates all form strings,
     * only if form language was not already set to current language
     */
    public loadUpdateFormulaireLocalisation(f: FormulaireDefinition): Promise<FormulaireDefinition> {
        const requiredLang = this._intlService.currentLanguage;
        if (requiredLang !== f.currentLanguage) {
            return this.loadLocalisation(f.calculatorType).then(localisation => {
                f.updateLocalisation(localisation, requiredLang);
                return f;
            });
        }
    }

    /**
     * Retourne le titre complet du type de module de calcul, dans la langue en cours
     */
    public getLocalisedTitleFromCalculatorType(type: CalculatorType) {
        const sCalculator: string = CalculatorType[type].toUpperCase();
        return this._intlService.localizeText(`INFO_${sCalculator}_TITRE`);
    }

    /**
     * Retourne le titre cour du type de module de calcul, dans la langue en cours
     * (pour les titres d'onglets par défaut)
     */
    public getLocalisedShortTitleFromCalculatorType(type: CalculatorType) {
        const sCalculator: string = CalculatorType[type].toUpperCase();
        return this._intlService.localizeText(`INFO_${sCalculator}_TITRE_COURT`);
    }

    /**
     * Checks if the given calculator name (tab title) is already used by any existing
     * form; if so, adds a number after it
     */
    private suffixNameIfNeeded(name: string) {
        let found = false;
        let maxNumber = 0;

        // extract base name
        let baseName = name;
        const re1 = new RegExp("^.+( \\d+)$");
        const matches1 = re1.exec(name);
        if (matches1) {
            baseName = baseName.replace(matches1[1], "");
        }

        // browse session calculators
        const re2 = new RegExp("^" + baseName + "( (\\d+))?$");
        for (const f of this.formulaires) {
            const matches2 = re2.exec(f.calculatorName);
            if (matches2) {
                found = true;
                if (matches2[2] !== undefined) {
                    const nb = Number(matches2[2]);
                    maxNumber = Math.max(maxNumber, nb);
                }
            }
        }
        // suffix if needed
        if (found) {
            name = baseName + " " + (maxNumber + 1);
        }
        return name;
    }

    public loadConfig(ct: CalculatorType): Promise<any> {
        const f: string = this.getConfigPathPrefix(ct) + "config.json";
        return this._httpService.httpGetRequestPromise(f);
    }

    private newFormulaire(ct: CalculatorType, jsonState?: {}): FormulaireDefinition {
        let f: FormulaireDefinition;
        switch (ct) {
            case CalculatorType.ConduiteDistributrice:
            case CalculatorType.PabChute:
            case CalculatorType.PabDimensions:
            case CalculatorType.PabPuissance:
            case CalculatorType.MacroRugo:
                f = new FormulaireBase();
                break;

            case CalculatorType.LechaptCalmon:
                f = new FormulaireLechaptCalmon();
                break;

            case CalculatorType.SectionParametree:
                f = new FormulaireSectionParametree();
                break;

            case CalculatorType.RegimeUniforme:
                f = new FormulaireRegimeUniforme();
                break;

            case CalculatorType.CourbeRemous:
                f = new FormulaireCourbeRemous();
                break;

            case CalculatorType.ParallelStructure:
            case CalculatorType.Dever:
            case CalculatorType.Cloisons:
                f = new FormulaireParallelStructure();
                break;

            default:
                throw new Error(`FormulaireService.newFormulaire() : type de module de calcul ${CalculatorType[ct]} non pris en charge`);
        }

        f.defaultProperties["calcType"] = ct;

        return f;
    }

    /**
     * crée un formulaire d'un type donné
     * @param ct type de formulaire
     * @param nub nub existant à associer au formulaire (chargement de session / duplication de module)
     * @param calculatorName nom du module, à afficher dans l'interface
     */
    public createFormulaire(ct: CalculatorType, nub?: Nub, calculatorName?: string): Promise<FormulaireDefinition> {
        // Crée un formulaire du bon type
        const f: FormulaireDefinition = this.newFormulaire(ct);
        this._formulaires.push(f);
        // Charge la configuration dépendamment du type
        const prom: Promise<any> = this.loadConfig(ct);
        return prom.then(s => {
            f.preparseConfig(s);

            // Associe le Nub fourni (chargement de session / duplication de module), sinon en crée un nouveau
            if (nub) {
                f.currentNub = nub;
            } else {
                f.initNub();
            }

            // Restaure le nom du module, sinon affecte le nom par défaut
            let tempName: string;
            if (calculatorName) {
                tempName = calculatorName;
            } else {
                tempName = decode(this.getLocalisedShortTitleFromCalculatorType(ct));
            }
            // Suffixe le nom du module si nécessaire
            f.calculatorName = this.suffixNameIfNeeded(tempName);

            f.parseConfig();

            // add fieldsets for existing structures if needed
            if (f.currentNub instanceof ParallelStructure) {
                for (s of f.currentNub.structures) {
                    for (const e of f.allFormElements) {
                        if (e instanceof FieldsetContainer) { // @TODO manage many containers one day ?
                            e.addFromTemplate(0, undefined, s);
                        }
                    }
                }
            }
            return f;

        }).then(fi => {
            fi.applyDependencies();
            this.notifyObservers({
                "action": "createForm",
                "form": fi
            });
            return fi;
        });
    }

    /**
     * Trick to notify param-link components that parent form name changed
     * @TODO find a way to make param-link components directly observe FormDefinition
     */
    public propagateFormNameChange(f: FormulaireDefinition, name: string) {
        this.notifyObservers({
            "action": "formNameChanged",
            "form": f,
            "value": name
        });
    }

    public getFormulaireFromId(uid: string): FormulaireDefinition {
        for (const f of this._formulaires) {
            if (f.uid === uid) {
                return f;
            }
        }
    }

    public getInputField(formId: string, elemId: string): InputField {
        const s = this.getFormulaireElementById(formId, elemId);
        if (!(s instanceof InputField)) {
            throw new Error("Form element with id '" + elemId + "' is not an input");
        }
        return <InputField>s;
    }

    public getSelectField(formId: string, elemId: string): SelectField {
        const s = this.getFormulaireElementById(formId, elemId);
        if (!(s instanceof SelectField)) {
            throw new Error("Form element with id '" + elemId + "' is not a select");
        }
        return <SelectField>s;
    }

    private getFormulaireElementById(formId: string, elemId: string): FormulaireElement {
        for (const f of this._formulaires) {
            if (f.uid === formId) {
                const s = f.getFormulaireNodeById(elemId);
                if (s !== undefined) {
                    return s as FormulaireElement;
                }
            }
        }
    }

    public getParamdefParentForm(prm: ParamDefinition): FormulaireDefinition {
        for (const f of this._formulaires) {
            for (const p of f.allFormElements) {
                if (p instanceof NgParameter) {
                    if (p.paramDefinition.uid === prm.uid) {
                        return f;
                    }
                }
            }
        }
    }

    /**
     * retrouve un formulaire à partir d'un uid de Nub
     */
    public getFormulaireFromNubId(uid: string) {
        for (const f of this._formulaires) {
            if (f.hasNubId(uid)) {
                return f;
            }
        }
    }

    public getConfigPathPrefix(ct: CalculatorType): string {
        if (ct === undefined) {
            throw new Error("FormulaireService.getConfigPathPrefix() : CalculatorType is undefined");
        }

        switch (ct) {
            case CalculatorType.ConduiteDistributrice:
                return "app/calculators/cond_distri/cond_distri.";

            case CalculatorType.LechaptCalmon:
                return "app/calculators/lechapt-calmon/lechapt-calmon.";

            case CalculatorType.SectionParametree:
                return "app/calculators/section-param/section-param.";

            case CalculatorType.RegimeUniforme:
                return "app/calculators/regime-uniforme/regime-uniforme.";

            case CalculatorType.CourbeRemous:
                return "app/calculators/remous/remous.";

            case CalculatorType.PabDimensions:
                return "app/calculators/pab-dimensions/pab-dimensions.";

            case CalculatorType.PabPuissance:
                return "app/calculators/pab-puissance/pab-puissance.";

            case CalculatorType.Structure:
                return "app/calculators/ouvrages/ouvrages.";

            case CalculatorType.ParallelStructure:
                return "app/calculators/parallel-structures/parallel-structures.";

            case CalculatorType.Dever:
                return "app/calculators/dever/dever.";

            case CalculatorType.Cloisons:
                return "app/calculators/cloisons/cloisons.";

            case CalculatorType.MacroRugo:
                return "app/calculators/macrorugo/macrorugo.";

            case CalculatorType.PabChute:
                return "app/calculators/pab-chute/pab-chute.";

            default:
                throw new Error("FormulaireService.getConfigPathPrefix() : valeur de CalculatorType " + ct + " non implémentée");
        }
    }

    /**
     * Supprime le formulaire ciblé, et demande à JaLHyd d'effacer son Nub de la Session
     * @param uid formulaire à supprimer
     */
    public requestCloseForm(uid: string) {
        const form = this.getFormulaireFromId(uid);
        const nub = form.currentNub;
        if (form) {
            this._formulaires = this._formulaires.filter(f => f.uid !== uid);

            this.notifyObservers({
                "action": "closeForm",
                "form": form
            });

            // reset the result panels of all forms depending on this one
            // @TODO UI should detect model change instead of doing this manually
            this.resetAllDependingFormsResults(form, [], false);
        }
        if (nub) {
            // reset model results (important, also resets dependent Nubs results in chain)
            form.currentNub.resetResult();
            Session.getInstance().deleteNub(nub);
        }
    }

    public get currentFormId() {
        return this._currentFormId;
    }

    public setCurrentForm(formId: string) {
        const form = this.getFormulaireFromId(formId);
        if (form === undefined) {
            this._currentFormId = null;
            this.notifyObservers({
                "action": "invalidFormId",
                "formId": formId
            });
        } else {
            this._currentFormId = formId;
            this.notifyObservers({
                "action": "currentFormChanged",
                "formId": formId
            });
        }
    }

    private get currentForm(): FormulaireDefinition {
        return this.getFormulaireFromId(this._currentFormId);
    }

    public get currentFormHasResults(): boolean {
        const form = this.currentForm;
        if (form !== undefined) {
            return form.hasResults;
        }

        return false;
    }

    private readSingleFile(file: File): Promise<any> {
        return new Promise<any>((resolve, reject) => {
            const fr = new FileReader();
            fr.onload = () => {
                resolve(fr.result);
            };
            fr.onerror = () => {
                fr.abort();
                reject(new Error(`Erreur de lecture du fichier ${file.name}`));
            };
            fr.readAsText(file);
        });
    }

    /**
     * charge une session en tenant compte des modules de calcul sélectionnées
     * @param f fichier session
     * @param formInfos infos sur les modules de calcul @see DialogLoadSessionComponent.calculators
     */
    public loadSession(f: File, formInfos: any[]) {
        this.readSingleFile(f).then(s => {
            const uids: string[] = [];
            formInfos.forEach((fi) => {
                if (fi.selected) {
                    uids.push(fi.uid);
                }
            });
            const newNubs = Session.getInstance().unserialise(s, uids);
            // for each new Nub, create the related form, set its title
            newNubs.forEach((nn) => {
                this.createFormulaire(nn.nub.calcType, nn.nub, nn.meta.title);
            });
        }).catch(err => {
            throw err;
        });
    }

    /**
     * Sends an UTF-8 text file for download
     */
    public downloadTextFile(session: string, filename: string = "file_1") {
        const blob = new Blob([session], { type: "text/plain;charset=utf-8" });
        saveAs(blob, filename);
    }

    /**
     * obtient des infos (nom, uid des modules de calcul) d'un fichier session
     * @param f fichier session
     */
    public calculatorInfosFromSessionFile(f: File): Promise<any[]> {
        return this.readSingleFile(f).then(s => {
            const res: any[] = [];
            const data = JSON.parse(s);
            // liste des noms de modules de calcul
            if (data.session && Array.isArray(data.session)) {
                data.session.forEach((e: any) => {
                    const nubInfo = {
                        uid: e.uid,
                        title: e.meta && e.meta.title ? e.meta.title : undefined,
                        requires: [],
                        children: []
                    };
                    // list linked params dependencies for each Nub
                    if (e.parameters) {
                        e.parameters.forEach((p) => {
                            if (p.targetNub && ! nubInfo.requires.includes(p.targetNub)) {
                                nubInfo.requires.push(p.targetNub);
                            }
                        });
                    }
                    // list children nubs for each Nub
                    if (e.structures) {
                        e.structures.forEach((p) => {
                            nubInfo.children.push(p.uid);
                        });
                    }
                    res.push(nubInfo);
                });
            }
            return res;
        });
    }

    public saveForm(f: FormulaireDefinition) {
        this.notifyObservers({
            "action": "saveForm",
            "form": f
        });
    }

    /**
     * Demande à la Session JalHYd la liste des paramètres/résultats pouvant être liés au
     * paramètre fourni
     */
    public getLinkableValues(p: NgParameter): LinkedValue[] {
        let linkableValues: LinkedValue[] = [];
        if (p) {
            linkableValues = Session.getInstance().getLinkableValues(p.paramDefinition);
            // join form names to ease usage
            for (let i = 0; i < linkableValues.length; i++) {
                const lv = linkableValues[i];
                for (const f of this._formulaires) {
                    if (f.currentNub) {
                        if (f.currentNub.uid === lv.nub.uid) {
                            lv.meta["formTitle"] = f.calculatorName;
                        } else {
                            // child structures ?
                            if (f.currentNub instanceof ParallelStructure) {
                                for (const s of f.currentNub.structures) {
                                    if (s.uid === lv.nub.uid) {
                                        lv.meta["formTitle"] = f.calculatorName;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        linkableValues = this.filterLinkableValues(linkableValues);
        return linkableValues;
    }

    /**
     * filtre les valeurs liables à un paramètre :
     * - supprime les valeurs non affichées dans leur parent (ce n'est pas le cas par ex
     * pour Q, Z1, Z2 dans les ouvrages enfants des ouvrages //)
     * @param values valeurs liables (modifié par la méthode)
     */
    public filterLinkableValues(values: any[]): any[] {
        for (let i = values.length - 1; i >= 0; i--) {
            const v = values[i].value;
            if (v instanceof ParamDefinition) {
                // pour chaque paramètre...
                const prm: ParamDefinition = v;
                const parentForm: FormulaireDefinition = this.getParamdefParentForm(prm);
                // ... on cherche s'il est affiché dans son parent
                let found = false;
                if (parentForm !== undefined) {
                    for (const fe of parentForm.allFormElements) {
                        if (fe instanceof NgParameter) {
                            if (fe.paramDefinition.uid === prm.uid) {
                                found = true;
                                break;
                            }
                        }
                    }
                }
                if (!found) {
                    values.splice(i, 1);
                }
            }
        }
        return values;
    }

    /**
     * Resets the results of all forms depending on the given form "f"
     * @param f
     */
    public resetAllDependingFormsResults(f: FormulaireDefinition, visited: string[] = [], notify: boolean = true) {
        const dependingNubs = Session.getInstance().getDependingNubs(f.currentNub.uid);
        for (const dn of dependingNubs) {
            if (! visited.includes(dn.uid)) {
                const form = this.getFormulaireFromNubId(dn.uid);
                if (form) {
                    const hadResults = form.hasResults;
                    // form might not have a result, but still have another form depending on it !
                    form.resetResults(visited);
                    if (hadResults) {
                        if (notify) {
                            this.notificationsService.notify(
                                this.intlService.localizeText("INFO_SNACKBAR_RESULTS_INVALIDATED") + " " + form.calculatorName,
                                1500
                            );
                        }
                    }
                }
            }
        }
    }
}