// (C) 2007-2019 GoodData Corporation
import { ExecuteAFM as AFM } from "@gooddata/typings";
import * as invariant from "invariant";
import {
    IMockProject,
    getAttributeDisplayForms,
    getMetrics,
    getAllDateDataSetDisplayForms,
} from "../../../model/MockProject";
import { getMetricByUri, getMetricByIdentifier, IMetric } from "../../../model/Metric";
import {
    getDisplayFormByIdentifier,
    getDisplayFormByUri,
    IAttributeDisplayForm,
} from "../../../model/AttributeDisplayForm";

function findMeasure(afm: AFM.IAfm, localIdentifier: string): AFM.IMeasure {
    return afm.measures.find(measure => measure.localIdentifier === localIdentifier);
}

function findMasterMeasureLocalIdentifierByDerivedMeasure(measure: AFM.IMeasure): string {
    const { definition } = measure;
    if (AFM.isPopMeasureDefinition(definition)) {
        return definition.popMeasure.measureIdentifier;
    } else if (AFM.isPreviousPeriodMeasureDefinition(definition)) {
        return definition.previousPeriodMeasure.measureIdentifier;
    } else {
        throw Error(`This measure definition type is not supported! ${JSON.stringify(definition)}`);
    }
}

export function isDerivedFromArithmeticMeasure(measure: AFM.IMeasure, afm: AFM.IAfm): boolean {
    const measureDefinition = measure.definition;
    if (
        AFM.isPopMeasureDefinition(measureDefinition) ||
        AFM.isPreviousPeriodMeasureDefinition(measureDefinition)
    ) {
        const masterMeasure = findMeasure(afm, findMasterMeasureLocalIdentifierByDerivedMeasure(measure));
        return AFM.isArithmeticMeasureDefinition(masterMeasure.definition);
    }

    return false;
}

export function getMetric(project: IMockProject, measure: AFM.IMeasure, afm: AFM.IAfm = null): IMetric {
    const measures = getMetrics(project);
    const { definition } = measure;

    if (AFM.isSimpleMeasureDefinition(definition)) {
        return getMetricBySimpleMeasure(definition, measures);
    } else {
        invariant(afm, "Could not read afm from execution");

        const referencedMeasure = findMeasure(afm, findMasterMeasureLocalIdentifierByDerivedMeasure(measure));

        invariant(referencedMeasure, "The measure could not be referenced.");
        return getMetricBySimpleMeasure(referencedMeasure.definition, measures);
    }
}

function getMetricBySimpleMeasure(measureDefinition: AFM.MeasureDefinition, measures: IMetric[]) {
    if (AFM.isSimpleMeasureDefinition(measureDefinition)) {
        if (AFM.isObjectUriQualifier(measureDefinition.measure.item)) {
            return getMetricByUri(measures, measureDefinition.measure.item.uri);
        }

        return getMetricByIdentifier(measures, measureDefinition.measure.item.identifier);
    }

    invariant(false, "Provided measure is not SimpleMeasureDefinition");
}

export function getDisplayForm(project: IMockProject, attribute: AFM.IAttribute): IAttributeDisplayForm {
    return getDisplayFormByQualifier(project, attribute.displayForm);
}

export function getDisplayFormByQualifier(
    project: IMockProject,
    qualifier: AFM.ObjQualifier,
): IAttributeDisplayForm {
    const attributeDisplayForms = getAttributeDisplayForms(project);
    const dateDataSetDisplayForms = getAllDateDataSetDisplayForms(project);
    const displayForms = [...attributeDisplayForms, ...dateDataSetDisplayForms];

    if (AFM.isObjectUriQualifier(qualifier)) {
        return getDisplayFormByUri(displayForms, qualifier.uri);
    }

    return getDisplayFormByIdentifier(displayForms, qualifier.identifier);
}