var-results.ts

import { CalculatorResults } from "./calculator-results";
import { CalculatedParamResults } from "./param-calc-results";
import { NgParameter } from "../formulaire/ngparam";
import { ResultElement, ParamFamily } 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ètres variés
     */
    private _variatedParams: NgParameter[];

    /**
     * titre des colonnes des résultats variés
     */
    private _variableParamHeaders: 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
     */
    protected _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;

    /** 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._extraResultHeaders = [];
        this.extraResultKeys = [];
        this._yValues = [];
        this.longest = 0;
    }

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

    public set variatedParameters(p: NgParameter[]) {
        this._variatedParams = p;
        this._variableParamHeaders = this._variatedParams.map((v) => {
            return CalculatorResults.paramLabel(v, true);
        });
    }

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

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

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

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

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

    public set graphType(gt: GraphType) {
        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
        return this.expandLabelFromSymbol(symbol);

    }

    /**
     * Returns the translated name of the given symbol (usually an extraResult) with
     * its unit, but without the symbol itself
     */
    public expandLabelFromSymbol(symbol: string): string {
        // calculator type for translation
        const sn = this.result.sourceNub;
        let ct = sn.calcType;
        if (sn.parent) {
            ct = sn.parent.calcType;
        }
        return ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(ct, 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);
                }
            }
        }
        // 2. variated param ?
        for (let i = 0; i < this.variatedParameters.length; i++) {
            if (this._variatedParams[i].symbol === symbol) {
                const iter = this.variatedParameters[i].getExtendedValuesIterator(this.size);
                for (const v of iter) {
                    series.push(v);
                }
            }
        }
        // 3. Result element ?
        for (const r of this.result.resultElements) { // re:ResultElement
            for (const k in r.realExtraResults) {
                if (k === symbol) {
                    series.push(r.extraResults[k]);
                }
            }
        }

        return series;
    }

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

    /**
     * Same as X axis, plus results families if graph type is Scatter
     * (for multi-series comparison)
     */
    public getAvailableYAxis(): string[] {
        const res: string[] = this.getAvailableXAxis();
        if (this._graphType === GraphType.Scatter) {
            // add families having more than 1 variable as plottable ordinates
            const families = this.extractFamilies();
            console.log("FOUND FAMILIES", families);
            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
     */
    private extractFamilies(): { [key: string]: string[] } {
        const families: { [key: string]: string[] } = {};
        if (this.calculatedParameter) {
            const f = ParamFamily[this.calculatedParameter.paramDefinition.family];
            console.log(`1 - calcParam: ${this.calculatedParameter.symbol} > ${f}`);
            if (f !== undefined) {
                if (! (f in families)) {
                    console.log("-- init to []");
                    families[f] = [];
                }
                console.log("--- push", this.calculatedParameter.symbol);
                families[f].push(this.calculatedParameter.symbol);
            }
        }
        for (const v of this._variatedParams) {
            const f = ParamFamily[v.paramDefinition.family];
            console.log(`2 - variatedParam: ${v.symbol} > ${f}`);
            if (f !== undefined) {
                if (! (f in families)) {
                    console.log("-- init to []");
                    families[f] = [];
                }
                console.log("--- push", v.symbol);
                families[f].push(v.symbol);
            }
        }
        for (const erk in this.extraResultKeys) {

            const f = ParamFamily[this.result.sourceNub.extraResultsFamilies[erk]];
            console.log(`3 - extraResult: ${erk} > ${f}`);
            if (f !== undefined) {
                if (! (f in families)) {
                    console.log("-- init to []");
                    families[f] = [];
                }
                console.log("--- push", erk);
                families[f].push(erk);
            }
        }
        return families;
    }

    /**
     * Returns the list of variating parameters
     * (used by tooltip functions)
     */
    public getVariatingParametersSymbols(): string[] {
        return this._variatedParams.map((vp) => {
            return vp.symbol;
        });
    }

    public update() {
        if (this._variableParamHeaders.length === 0) {
            this._variableParamHeaders = this._variatedParams.map((v) => {
                return CalculatorResults.paramLabel(v, true);
            });
        }

        // 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++;
        }

        // 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.realExtraResults) {
                    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.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 supplémentaires
        this._extraResultHeaders = [];
        for (const k of this.extraResultKeys) {
            this._extraResultHeaders.push(
                ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(ct, k)
            );
        }
        this.resetDefaultAxisIfNeeded();
    }

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