formulaire.service.ts

import { Injectable } from "@angular/core";
import { Response } from "@angular/http";
import { Observable as rxObservable } from "rxjs/Observable";
import "rxjs/add/operator/toPromise";
import { decode } from "he";

import { CalculatorType, EnumEx } from "jalhyd";

import { ParamService } from "../param/param.service";
import { HttpService } from "../../services/http/http.service";
import { InternationalisationService } from "../../services/internationalisation/internationalisation.service";
import { ApplicationSetupService } from "../../services/app-setup/app-setup.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 { CheckField } from "../../formulaire/check-field";
import { StringMap } from "../../stringmap";
import { Observable } from "../observer";
import { FormulaireConduiteDistributrice } from "../../formulaire/definition/concrete/form-cond-distri";
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 { FormulairePasseBassinDimensions } from "../../formulaire/definition/concrete/form-passe-bassin-dim";
import { FormulairePasseBassinPuissance } from "../../formulaire/definition/concrete/form-passe-bassin-puissance";
import { FormulaireParallelStructure } from "../../formulaire/definition/concrete/form-parallel-structures";

@Injectable()
export class FormulaireService extends Observable {
    private _formulaires: FormulaireDefinition[];

    private _currentFormId = -1;

    constructor(private paramService: ParamService,
        private httpService: HttpService,
        private intlService: InternationalisationService,
        private appSetupService: ApplicationSetupService
    ) {
        super();
        this._formulaires = [];
    }

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

    private loadLocalisation(calc: CalculatorType): Promise<any> {
        let f: string = this.getConfigPathPrefix(calc) + this.intlService.currentLanguage.tag + ".json"
        let resp: rxObservable<Response> = this.httpService.httpGetRequestResponse(undefined, undefined, undefined, f);

        let prom = resp.map(res => res.text()).toPromise();
        return prom.then((res) => {
            let j = JSON.parse(res);
            return j as StringMap;
        })
    }

    /**
     * met à jour la langue du formulaire
     * @param formId id unique du formulaire
     * @param localisation ensemble id-message traduit
     */
    private updateFormulaireLocalisation(formId: number, localisation: StringMap) {
        for (let f of this._formulaires)
            if (f.uid == formId) {
                f.updateLocalisation(localisation);
                break;
            }
    }

    /**
     * charge la localisation et met à jour la langue du formulaire
     */
    private loadUpdateFormulaireLocalisation(f: FormulaireDefinition): Promise<any> {
        return this.loadLocalisation(f.calculatorType)
            .then(localisation => {
                this.updateFormulaireLocalisation(f.uid, localisation);
            });
    }

    public updateLocalisation() {
        for (const c of EnumEx.getValues(CalculatorType)) {
            const prom: Promise<StringMap> = this.loadLocalisation(c);
            prom.then(loc => {
                for (const f of this._formulaires)
                    if (f.calculatorType == c)
                        this.updateFormulaireLocalisation(f.uid, loc);
            }
            );
        }
    }

    public getLocalisedTitleFromCalculatorType(type: CalculatorType) {
        switch (type) {
            case CalculatorType.ConduiteDistributrice:
                return this.intlService.localizeText("INFO_CONDDISTRI_TITRE");

            case CalculatorType.LechaptCalmon:
                return this.intlService.localizeText("INFO_LECHAPT_TITRE");

            case CalculatorType.RegimeUniforme:
                return this.intlService.localizeText("INFO_REGUNI_TITRE");

            case CalculatorType.SectionParametree:
                return this.intlService.localizeText("INFO_SECTPARAM_TITRE");

            case CalculatorType.CourbeRemous:
                return this.intlService.localizeText("INFO_REMOUS_TITRE")

            case CalculatorType.PabDimensions:
                return this.intlService.localizeText("INFO_PABDIM_TITRE")

            case CalculatorType.PabPuissance:
                return this.intlService.localizeText("INFO_PABPUISS_TITRE")

            case CalculatorType.ParallelStructure:
                return this.intlService.localizeText("INFO_OUVRAGEPARAL_TITRE")

            default:
                return "Invalid calculator type " + type;
        }
    }

    private loadConfig(form: FormulaireDefinition, ct: CalculatorType): Promise<Response> {
        let processData = function (s: string) {
            form.parseConfig(JSON.parse(s));
        }

        let f: string = this.getConfigPathPrefix(ct) + "config.json"
        return this.httpService.httpGetRequest(undefined, undefined, undefined, f, processData);
    }

    public createFormulaire(ct: CalculatorType): Promise<FormulaireDefinition> {
        let f: FormulaireDefinition;
        switch (ct) {
            case CalculatorType.ConduiteDistributrice:
                f = new FormulaireConduiteDistributrice(this.paramService, this.appSetupService);
                break;

            case CalculatorType.LechaptCalmon:
                f = new FormulaireLechaptCalmon(this.paramService, this.appSetupService);
                break;

            case CalculatorType.SectionParametree:
                f = new FormulaireSectionParametree(this.paramService, this.appSetupService, this.intlService);
                break;

            case CalculatorType.RegimeUniforme:
                f = new FormulaireRegimeUniforme(this.paramService, this.appSetupService);
                break;

            case CalculatorType.CourbeRemous:
                f = new FormulaireCourbeRemous(this.paramService, this.appSetupService);
                break;

            case CalculatorType.PabDimensions:
                f = new FormulairePasseBassinDimensions(this.paramService, this.appSetupService);
                break;

            case CalculatorType.PabPuissance:
                f = new FormulairePasseBassinPuissance(this.paramService, this.appSetupService);
                break;

            case CalculatorType.ParallelStructure:
                f = new FormulaireParallelStructure(this.paramService, this.appSetupService);
                break;

            default:
                throw new Error(`FormulaireService.createFormulaire() : type de calculette ${ct} non pris en charge`)
        }

        f.calculatorName = decode(this.getLocalisedTitleFromCalculatorType(ct) + " (" + f.uid + ")");
        this._formulaires.push(f);
        let prom: Promise<Response> = this.loadConfig(f, ct);
        return prom.then(_ => {
            return f;
        }).then(f => {
            this.loadUpdateFormulaireLocalisation(f);
            return f;
        }).then(f => {
            f.applyDependencies();
            return f;
        }).then(f => {
            this.notifyObservers(
                {
                    "action": "createForm",
                    "form": f
                });
            return f;
        });
    }

    public getFormulaireFromId(uid: number): FormulaireDefinition {
        for (let f of this._formulaires)
            if (f.uid == uid)
                return f;

        return undefined;
    }

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

    public getCheckField(formId: number, elemId: string): CheckField {
        let s = this.getFormulaireElementById(formId, elemId);
        if (!(s instanceof CheckField))
            throw "Form element with id '" + elemId + "' is not a checkbox";
        return <CheckField>s;
    }

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

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

    private getConfigPathPrefix(ct: CalculatorType): string {
        if (ct == undefined)
            throw "FormulaireService.getConfigPathPrefix() : invalid undefined CalculatorType"

        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.";

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

    public requestCloseForm(uid: number) {
        const form = this.getFormulaireFromId(uid);
        if (form != undefined) {
            this._formulaires = this._formulaires.filter(f => f.uid !== uid);

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

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

    public setCurrentForm(formId: number) {
        const form = this.getFormulaireFromId(formId);
        if (form == undefined) {
            this._currentFormId = -1;
            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;
    }
}