var-results.ts

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

import { sprintf } from "sprintf-js";

export class VarResults extends CalculatedParamResults implements PlottableData {
    /**
     * paramètres variés
     */
    private _variatedParams: NgParameter[];

    /**
     * titre des colonnes des résultats variés
     */
    private _variableParamHeaders: string[];

    /**
     * clés des résultats
     */
    public resultKeys: string[];

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

    /**
     * type de graphe
     */
    protected _graphType: ChartType = ChartType.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;

    /** size of the longest variated parameter */
    public size: number;

    /** index of the longest variated parameter */
    public longest: number;

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

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

    public reset() {
        super.reset();
        this._variableParamHeaders = [];
        this._resultHeaders = [];
        this.resultKeys = [];
        this._yValues = [];
        this.longest = 0;
    }

    public get variatedParameters(): NgParameter[] {
        return this._variatedParams;
    }

    public set variatedParameters(p: NgParameter[]) {
        this._variatedParams = p;
    }

    public get variableParamHeaders() {
        return this._variableParamHeaders;
    }

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

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

    public get resultHeaders() {
        return this._resultHeaders;
    }

    public get graphType(): ChartType {
        return this._graphType;
    }

    public set graphType(gt: ChartType) {
        this._graphType = gt;
        this.resetDefaultAxisIfNeeded();
    }

    public getChartAxisLabel(symbol: string): string {
        // 1. calculated param ?
        if (this.calculatedParameter && this.calculatedParameter.symbol === symbol) {
            return this.calculatedParameterHeader;
        }
        // 2. variated param ?
        for (let i = 0; i < this.variatedParameters.length; i++) {
            if (this._variatedParams[i].symbol === symbol) {
                return this.variableParamHeaders[i];
            }
        }
        // 3. Result element / child result
        return this.expandLabelFromSymbol(symbol);
    }

    /**
     * Returns the translated name of the given symbol (usually a result or child result) with
     * its unit, but without the symbol itself
     */
    public expandLabelFromSymbol(symbol: string): string {
        let ret = "";
        // calculator type for translation
        const sn = this.result.sourceNub;
        let ct = sn.calcType;
        if (sn.parent) {
            ct = sn.parent.calcType;
        }
        // detect children results
        const match = /^([0-9]+)_(.+)$/.exec(symbol);
        if (match !== null) {
            const pos = +match[1];
            ct = sn.getChildren()[pos].calcType;
            symbol = match[2];
            const cn = capitalize(ServiceFactory.instance.i18nService.childName(sn));
            ret += sprintf(ServiceFactory.instance.i18nService.localizeText("INFO_STUFF_N"), cn) + (pos + 1) + " : ";
        }
        ret += ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(ct, symbol);
        return ret;
    }

    /**
     * Returns the series of values for the required variated parameter / result element
     * @param symbol parameter / result symbol (ex: "Q", "0_Q"...)
     */
    public getValuesSeries(symbol: string): number[] {
        let found = false;
        const series: number[] = [];
        // detect children results
        const isChildResult = /^([0-9]+)_(.+)$/.exec(symbol);

        // 1. variated param ?
        for (let i = 0; i < this.variatedParameters.length; i++) {
            const vp = this._variatedParams[i];
            let isTheGoodChild = false;
            // are we looking for a child variated param ?
            if (isChildResult !== null) {
                const children = this.result.sourceNub.getChildren();
                const parameterNub = vp.paramDefinition.parentNub;
                if (children.includes(parameterNub)) { // current var param is a child param !
                    const pos = parameterNub.findPositionInParent();
                    isTheGoodChild = (pos === +isChildResult[1] && vp.symbol === isChildResult[2]);
                }
            }
            // in any case
            if (isTheGoodChild || vp.symbol === symbol) {
                found = true;
                const iter = vp.getExtendedValuesIterator(this.size);
                for (const v of iter) {
                    series.push(v);
                }
            }
        }
        // 2. Result element ?
        if (! found) {
            for (const r of this.result.resultElements) { // re:ResultElement
                for (const k in r.values) {
                    if (k === symbol) {
                        found = true;
                        series.push(r.getValue(k));
                    }
                }
            }
        }
        // 3. Child result element ?
        if (! found) {
            if (isChildResult !== null) {
                found = true;
                const sn = this.result.sourceNub;
                const pos = +isChildResult[1];
                symbol = isChildResult[2];
                const child = sn.getChildren()[pos];
                for (const r of child.result.resultElements) {
                    series.push(r.getValue(symbol));
                }
            }
        }

        return series;
    }

    /**
     * Returns a list of plottable parameters / result elements, that can be defined
     * as X chart axis
     */
    public getAvailableXAxis(): string[] {
        let res: string[] = [];
        res = res.concat(this.getVariatingParametersSymbols());
        for (const erk of this.resultKeys) {
            if (erk.indexOf("ENUM_") === -1) { // ENUM variables are not plottable
                res.push(erk);
            }
        }
        // children results
        const sn = this.result.sourceNub;
        for (const c of sn.getChildren()) {
            if (c.result) {
                // using latest ResultElement; results count / types are supposed to be the same on every iteration
                for (const k of c.result.resultElement.keys) {
                    if (k.indexOf("ENUM_") === -1) { // ENUM variables are not plottable
                        res.push(c.findPositionInParent() + "_" + k);
                    }
                }
            }
        }
        return res;
    }

    /**
     * Same as X axis, plus results families if chart type is Scatter
     * (for multi-series comparison)
     */
    public getAvailableYAxis(): string[] {
        const res: string[] = this.getAvailableXAxis();
        if (this._graphType === ChartType.Scatter) {
            // add families having more than 1 variable as plottable ordinates
            const families = this.extractFamilies();
            for (const f in families) {
                if (families[f].length > 1) {
                    res.push(f);
                }
            }
        }
        return res;
    }

    /**
     * Browses all parameters and results to produce a map of families => list of
     * symbols in this family
     */
    public extractFamilies(): { [key: string]: string[] } {
        const families: { [key: string]: string[] } = {};
        // variating parameters
        for (const v of this._variatedParams) {
            // exclude pseudo-family "ANY"
            const fam = v.paramDefinition.family;
            if (fam !== undefined && fam !== ParamFamily.ANY) {
                const f = ParamFamily[fam];
                if (! (f in families)) {
                    families[f] = [];
                }
                families[f].push(v.symbol);
            }
        }
        // results
        for (const erk of this.resultKeys) {
            const fam = this.result.sourceNub.getFamily(erk);
            // exclude pseudo-family "ANY"
            if (fam !== undefined && fam !== ParamFamily.ANY) {
                const f = ParamFamily[fam];
                if (! (f in families)) {
                    families[f] = [];
                }
                families[f].push(erk);
            }
        }
        // children results
        const sn = this.result.sourceNub;
        for (const c of sn.getChildren()) {
            if (c.result) {
                for (const k of c.result.resultElement.keys) {
                    const fam = this.result.sourceNub.getFamily(k);
                    // exclude pseudo-family "ANY"
                    if (fam !== undefined && fam !== ParamFamily.ANY) {
                        const f = ParamFamily[fam];
                        if (! (f in families)) {
                            families[f] = [];
                        }
                        const pos = c.findPositionInParent();
                        families[f].push(pos + "_" + k);
                    }
                }
            }
        }
        return families;
    }

    /**
     * Returns the list of variating parameters
     * (used by tooltip functions)
     */
    public getVariatingParametersSymbols(): string[] {
        const sn = this.result.sourceNub;
        return this._variatedParams.map((vp) => {
            // detect if variated param is a children param
            const parameterNub = vp.paramDefinition.parentNub;
            const children = sn.getChildren();
            let symb = vp.symbol;
            if (children.includes(parameterNub)) {
                symb = parameterNub.findPositionInParent() + "_" + symb;
            }
            return symb;
        });
    }

    public update() {
        // refresh param headers
        this._variableParamHeaders = this._variatedParams.map((v) => {
            let h = CalculatorResults.paramLabel(v, true, this.result.sourceNub);
            h += this.getHelpLink(v.symbol);
            return h;
        });

        // liste la plus longue
        this.size = 0;
        let i = 0;
        for (const v of this._variatedParams) {
            const s = v.valuesIterator.count();
            if (s > this.size) {
                this.size = s;
                this.longest = i;
            }
            i++;
        }

        // result keys (extra or not) - some lines might miss some results, in case of an error;
        // use those keys to ensure all columns are filled
        if (this.resultKeys.length === 0) {
            for (const re of this.result.resultElements) { // re:ResultElement
                for (const erk in re.values) {
                    if (!this.resultKeys.includes(erk)) {
                        this.resultKeys.push(erk);
                    }
                }
            }
        }

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

        // calculator type for translation
        const sn = this.result.sourceNub;
        let ct = sn.calcType;
        if (sn.parent) {
            ct = sn.parent.calcType;
        }
        // entêtes des résultats
        this._resultHeaders = [];
        for (const k of this.resultKeys) {
            let unit;
            // is k the calculated parameter ? If so, extract its unit
            try {
                const p = sn.getParameter(k);
                if (p) {
                    unit = p.unit;
                }
            } catch (e) { /* silent fail */ }
            let rh = ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(ct, k, unit);
            rh += this.getHelpLink(k);
            this._resultHeaders.push(rh);
        }
        // entêtes des résultats des enfants
        for (const c of sn.getChildren()) {
            if (c.result) {
                const cn = capitalize(ServiceFactory.instance.i18nService.childName(sn));
                // using latest ResultElement; results count / types are supposed to be the same on every iteration
                for (const k of c.result.resultElement.keys) {
                    let rh = sprintf(ServiceFactory.instance.i18nService.localizeText("INFO_STUFF_N"), cn)
                        + (c.findPositionInParent() + 1) + " : "
                        + ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(ct, k);
                    rh += this.getHelpLink(k);
                    this._resultHeaders.push(rh);
                }
            }
        }

        this.resetDefaultAxisIfNeeded();
    }

    /**
     * When variable parameter or chart type changes, ensure the X / Y current values are still available
     */
    public resetDefaultAxisIfNeeded() {
        if (! this.getAvailableXAxis().includes(this.chartX)) {
            this.chartX = this.variatedParameters[0].symbol;
        }
        if (! this.getAvailableYAxis().includes(this.chartY)) {
            this.chartY = this.variatedParameters[0].symbol;
        }
    }
}