var-results.ts

import { CalculatorResults } from "./calculator-results";
import { CalculatedParamResults } from "./param-calc-results";
import { NgParameter } from "../formulaire/ngparam";
import { ResultElement } from "jalhyd";
import { ServiceFactory } from "../services/service-factory";
import { PlottableData } from "./plottable-data";
import { GraphType } from "./graph-type";

export class VarResults extends CalculatedParamResults implements PlottableData {
    /**
     * paramètre varié
     */
    private _variatedParam: NgParameter;

    /**
     * titre de la 1ère colonne des résultats variés
     */
    private _variableParamHeader: string;

    /**
     * clés des résultats complémentaires
     */
    public extraResultKeys: string[];

    /**
     * entête des colonnes des résultats supplémentaires
     */
    private _extraResultHeaders: string[];

    /**
     * type de graphe
     */
    public graphType: GraphType = GraphType.Scatter;

    /**
     * variated parameter or result displayed as chart's X-axis
     */
    public chartX: string;
    /**
     * variated parameter or result displayed as chart's Y-axis
     */
    public chartY: string;

    /**
     * tableau des ordonnées du graphe des résultats variés
     */
    private _yValues: number[] = [];

    constructor() {
        super();
        this.reset();
    }

    public reset() {
        super.reset();
        this._variableParamHeader = undefined;
        this._extraResultHeaders = [];
        this.extraResultKeys = [];
        this._yValues = [];
    }

    public get variatedParameter(): NgParameter {
        return this._variatedParam;
    }

    public set variatedParameter(p: NgParameter) {
        this._variatedParam = p;
        this._variableParamHeader = CalculatorResults.paramLabel(this._variatedParam, true);
    }

    public get variableParamHeader() {
        return this._variableParamHeader;
    }

    public get yValues() {
        return this._yValues;
    }

    public get resultElements(): ResultElement[] {
        return this.result.resultElements;
    }

    public get extraResultHeaders() {
        return this._extraResultHeaders;
    }

    public getChartAxisLabel(symbol: string) {
        // 1. calculated param ?
        if (this.calculatedParameter && this.calculatedParameter.symbol === symbol) {
            return this.calculatedParameterHeader;
        } else
        // 2. variated param ?
        if (this.variatedParameter.symbol === symbol) {
            return this.variableParamHeader;
        } else {
            // 3. Result element ?
            return ServiceFactory.instance.i18nService.getExtraResLabel(symbol);
        }
    }

    /**
     * Returns the series of values for the required variated parameter / result element
     * @param symbol parameter / result symbol (ex: "Q")
     */
    public getValuesSeries(symbol: string) {
        const series = [];
        // 1. calculated param ?
        if (this._calculatedParam && this._calculatedParam.symbol === symbol) {
            if (this.result) {
                for (const r of this.result.resultElements) {
                    series.push(r.vCalc);
                }
            }
        } else
        // 2. variated param ?
        if (this.variatedParameter.symbol === symbol) {
            for (const v of this.variatedParameter.valuesIterator) {
                series.push(v);
            }
        } else {
            // 3. Result element ?
            for (const r of this.result.resultElements) { // re:ResultElement
                for (const k in r.extraResults) {
                    if (k === symbol) {
                        series.push(r.extraResults[k]);
                    }
                }
            }
        }

        return series;
    }

    /**
     * Returns a list of plottable parameters / result elements, that can be defined
     * as X or Y chart axis
     */
    public getAvailableChartAxis(): string[] {
        const res: string[] = [];
        if (this.calculatedParameter) {
            res.push(this.calculatedParameter.symbol);
        }
        res.push(this.variatedParameter.symbol);
        for (const erk of this.extraResultKeys) {
            res.push(erk);
        }
        return res;
    }

    public update(displaySymbol: boolean) {
        if (this._variableParamHeader === undefined) {
            this._variableParamHeader = CalculatorResults.paramLabel(this.variatedParameter, displaySymbol);
        }

        // valeurs du paramètre à calculer
        for (const r of this.result.resultElements) {
            this._yValues.push(r.vCalc);
        }

        // clés des résultats supplémentaires
        if (this.extraResultKeys.length === 0) {
            for (const re of this.result.resultElements) { // re:ResultElement
                for (const erk in re.extraResults) {
                    if (!this.extraResultKeys.includes(erk)) {
                        this.extraResultKeys.push(erk);
                    }
                }
            }
        }

        // set axis selectors values the first time
        let defaultY = this.chartY;
        if (this.calculatedParameter) {
            defaultY = this.calculatedParameter.symbol;
        } else if (this.extraResultKeys.length > 0) {
            defaultY = this.extraResultKeys[0];
        }
        this.chartX = this.chartX || this.variatedParameter.symbol;
        this.chartY = defaultY;

        // entêtes des résultats supplémentaires
        const intlService = ServiceFactory.instance.i18nService;
        this._extraResultHeaders = [];
        for (const k of this.extraResultKeys) {
            this._extraResultHeaders.push(intlService.getExtraResLabel(k));
        }

        // when variable parameter changes, ensure the X / Y current values are still available
        // (might be the previous variated parameter, that is not accessible anymore)
        const aca = this.getAvailableChartAxis();
        if (! aca.includes(this.chartX)) {
            this.chartX = this.variatedParameter.symbol;
        }
        if (! aca.includes(this.chartY)) {
            this.chartY = this.variatedParameter.symbol;
        }
    }
}