// (C) 2019 GoodData Corporation
import { ExecuteAFM as AFM, VisualizationObject } from "@gooddata/typings";
import { compact, flatMap } from "lodash";
import { convertVisualizationObjectFilter } from "./FilterConverter";
import MeasureConverter from "./MeasureConverter";

function convertAttribute(
    attribute: VisualizationObject.IVisualizationAttribute,
    idx: number,
): AFM.IAttribute {
    const alias = attribute.visualizationAttribute.alias;
    const aliasProp = alias ? { alias } : {};
    return {
        displayForm: attribute.visualizationAttribute.displayForm,
        localIdentifier: attribute.visualizationAttribute.localIdentifier || `a${idx + 1}`,
        ...aliasProp,
    };
}

function getMeasures(buckets: VisualizationObject.IBucket[]): VisualizationObject.IMeasure[] {
    return buckets.reduce((result: VisualizationObject.IMeasure[], bucket: VisualizationObject.IBucket) => {
        const measureItems: VisualizationObject.IMeasure[] = bucket.items.filter(
            VisualizationObject.isMeasure,
        );

        return result.concat(measureItems);
    }, []);
}

function getNativeTotalAttributeIdentifiers(
    bucket: VisualizationObject.IBucket,
    total: VisualizationObject.IVisualizationTotal,
): string[] {
    const attributes = bucket.items.filter(VisualizationObject.isAttribute);

    const totalAttributeIndex = attributes.findIndex(
        attribute => attribute.visualizationAttribute.localIdentifier === total.attributeIdentifier,
    );

    return attributes
        .slice(0, totalAttributeIndex)
        .map(attribute => attribute.visualizationAttribute.localIdentifier);
}

function convertNativeTotals(
    visObj: VisualizationObject.IVisualizationObjectContent,
): AFM.INativeTotalItem[] {
    const nativeTotalsPerBucket = visObj.buckets.map(bucket => {
        const totals = bucket.totals || [];
        const nativeTotals = totals.filter(total => total.type === "nat");

        return nativeTotals.map(total => ({
            measureIdentifier: total.measureIdentifier,
            attributeIdentifiers: getNativeTotalAttributeIdentifiers(bucket, total),
        }));
    });

    return flatMap(nativeTotalsPerBucket);
}

function getAttributes(
    buckets: VisualizationObject.IBucket[],
): VisualizationObject.IVisualizationAttribute[] {
    return buckets.reduce(
        (result: VisualizationObject.IVisualizationAttribute[], bucket: VisualizationObject.IBucket) => {
            const items: VisualizationObject.IVisualizationAttribute[] = bucket.items.filter(
                VisualizationObject.isAttribute,
            );

            return result.concat(items);
        },
        [],
    );
}

export function toAfm(visualizationObject: VisualizationObject.IVisualizationObjectContent): AFM.IAfm {
    const attributes: AFM.IAttribute[] = getAttributes(visualizationObject.buckets).map(convertAttribute);
    const attrProp = attributes.length ? { attributes } : {};

    const measures: AFM.IMeasure[] = getMeasures(visualizationObject.buckets).map(
        MeasureConverter.convertMeasure,
    );
    const measuresProp = measures.length ? { measures } : {};

    const filters: AFM.CompatibilityFilter[] = visualizationObject.filters
        ? compact(visualizationObject.filters.map(convertVisualizationObjectFilter))
        : [];
    const filtersProp = filters.length ? { filters } : {};

    const nativeTotals = convertNativeTotals(visualizationObject);
    const nativeTotalsProp = nativeTotals.length ? { nativeTotals } : {};

    return {
        ...measuresProp,
        ...attrProp,
        ...filtersProp,
        ...nativeTotalsProp,
    };
}