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
     */
    public resultKeys: string[];

    /**
     * entête des colonnes des résultats
     */
    private _resultHeaders: 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._resultHeaders = [];
        this.resultKeys = [];
        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 resultHeaders() {
        return this._resultHeaders;
    }

    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 / child result
        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 {
        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];
            ret += ServiceFactory.instance.i18nService.localizeText("INFO_OUVRAGE_N") + (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) {
        const series = [];
        // 1. 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);
                }
            }
        }
        // 2. Result element ?
        for (const r of this.result.resultElements) { // re:ResultElement
            for (const k in r.values) {
                if (k === symbol) {
                    series.push(r.getValue(k));
                }
            }
        }
        // 3. Child result element ?
        // detect children results
        const match = /^([0-9]+)_(.+)$/.exec(symbol);
        if (match !== null) {
            const sn = this.result.sourceNub;
            const pos = +match[1];
            symbol = match[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[] {
        const res: string[] = [];
        for (const v of this._variatedParams) {
            res.push(v.symbol);
        }
        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()) {
            // 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 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[] } = {};
        for (const v of this._variatedParams) {
            const f = ParamFamily[v.paramDefinition.family];
            if (f !== undefined) {
                if (! (f in families)) {
                    families[f] = [];
                }
                families[f].push(v.symbol);
            }
        }
        for (const erk of this.resultKeys) {
            const f = ParamFamily[this.result.sourceNub.getFamily(erk)];
            if (f !== undefined) {
                if (! (f in families)) {
                    families[f] = [];
                }
                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++;
        }

        // 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) {
            this._resultHeaders.push(
                ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(ct, k)
            );
        }
        // entêtes des résultats des enfants
        for (const c of sn.getChildren()) {
            // using latest ResultElement; results count / types are supposed to be the same on every iteration
            for (const k of c.result.resultElement.keys) {
                this._resultHeaders.push(
                    ServiceFactory.instance.i18nService.localizeText("INFO_OUVRAGE_N")
                        + (c.findPositionInParent() + 1) + " : "
                        + ServiceFactory.instance.formulaireService.expandVariableNameAndUnit(c.calcType, 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;
        }
    }
}