// (C) 2007-2019 GoodData Corporation
import { ExecuteAFM as AFM, Execution } from "@gooddata/typings";
import * as invariant from "invariant";
import { getMetric, getDisplayForm, isDerivedFromArithmeticMeasure } from "./afm";
import { getAttributes, getDateAttributes, IMockProject } from "../../../model/MockProject";
import {
    getMeasureTitles,
    isAdHocMeasure,
    isArithmeticMeasure,
    isAttributeBasedMeasure,
} from "./helpers/headers";

function createMeasureHeader(project: IMockProject, afm: AFM.IAfm): Execution.IMeasureGroupHeader {
    const titles = getMeasureTitles(project, afm);

    return {
        measureGroupHeader: {
            items: afm.measures.map(measure => {
                // for ad hoc measures backend doesn't return uri and identifier
                const isAdHoc = isAdHocMeasure(measure);

                if (
                    isAttributeBasedMeasure(measure) ||
                    isArithmeticMeasure(measure) ||
                    isDerivedFromArithmeticMeasure(measure, afm)
                ) {
                    return {
                        measureHeaderItem: {
                            localIdentifier: measure.localIdentifier,
                            format: measure.format,
                            name: titles.get(measure.localIdentifier),
                        },
                    };
                }

                const metric = getMetric(project, measure, afm);

                return {
                    measureHeaderItem: {
                        identifier: isAdHoc ? undefined : metric.meta.identifier,
                        uri: isAdHoc ? undefined : metric.meta.uri,
                        localIdentifier: measure.localIdentifier,
                        format: measure.format || metric.content.format,
                        name: titles.get(measure.localIdentifier),
                    },
                };
            }),
        },
    };
}

function createAttributeHeader(
    project: IMockProject,
    afm: AFM.IAfm,
    itemIdentifier: string,
    totalTypes: AFM.TotalType[] = [],
): Execution.IAttributeHeader {
    const attribute = afm.attributes.find(attribute => attribute.localIdentifier === itemIdentifier);
    invariant(attribute, `Attribute '${itemIdentifier}' was not found in AFM`);

    const displayForm = getDisplayForm(project, attribute);
    invariant(displayForm, `Display form '${attribute.alias}' not found`);

    const allAttributes = [...getAttributes(project), ...getDateAttributes(project)];

    const attributeInfo = allAttributes.find(attr => attr.meta.uri === displayForm.content.formOf);
    invariant(attributeInfo, `Attribute info '${displayForm.content.formOf}' not found`);

    const totalItems = totalTypes.map(name => ({ totalHeaderItem: { name } }));

    return {
        attributeHeader: {
            identifier: displayForm.meta.identifier,
            uri: displayForm.meta.uri,
            name: displayForm.meta.title,
            localIdentifier: attribute.localIdentifier,
            totalItems: totalItems.length ? totalItems : undefined,
            formOf: {
                uri: attributeInfo.meta.uri,
                identifier: attributeInfo.meta.identifier,
                name: attribute.alias || attributeInfo.meta.title,
            },
        },
    };
}

function createHeader(
    project: IMockProject,
    afm: AFM.IAfm,
    itemIdentifier: string,
    totalTypes: AFM.TotalType[] = [],
): Execution.IHeader {
    if (itemIdentifier === "measureGroup") {
        return createMeasureHeader(project, afm);
    }

    return createAttributeHeader(project, afm, itemIdentifier, totalTypes);
}

export function generateDimensions(
    project: IMockProject,
    afm: AFM.IAfm,
    resultSpec: AFM.IResultSpec,
    totalTypes: AFM.TotalType[] = [],
): Execution.IResultDimension[] {
    return resultSpec.dimensions.map(dimension => {
        return {
            headers: dimension.itemIdentifiers.map(itemIdentifier => {
                return createHeader(project, afm, itemIdentifier, totalTypes);
            }),
        };
    });
}