// (C) 2007-2019 GoodData Corporation
import { ExecuteAFM as AFM } from "@gooddata/typings";
import { generateDimensions } from "../dimensions";
import { buildProject } from "../../../../schema/builder";
import { schema } from "../../../../schema/fixtures/dummySchema";
import { AFMBuilder } from "../../../../utils/AFMBuilder/AFMBuilder";

describe("generateDimensions", () => {
    const project = buildProject(schema);
    const [metric1] = project.groups[0].metrics;
    const [displayForm] = project.groups[0].attributes[0].content.displayForms;
    const attribute = project.groups[0].attributes[0];

    it("should generate dimension for measures", () => {
        const { execution } = AFMBuilder.buildFromSchema(schema)
            .addMeasure()
            .addMeasure("#0", "Custom title", true)
            .build();

        const resultSpec: AFM.IResultSpec = {
            dimensions: [
                {
                    itemIdentifiers: ["measureGroup"],
                },
            ],
        };

        expect(generateDimensions(project, execution.afm, resultSpec)).toEqual([
            {
                headers: [
                    {
                        measureGroupHeader: {
                            items: [
                                {
                                    measureHeaderItem: {
                                        format: metric1.content.format,
                                        identifier: metric1.meta.identifier,
                                        localIdentifier: "m0",
                                        name: metric1.meta.title,
                                        uri: metric1.meta.uri,
                                    },
                                },
                                {
                                    measureHeaderItem: {
                                        format: "#0",
                                        localIdentifier: "m1",
                                        name: "Custom title",
                                    },
                                },
                            ],
                        },
                    },
                ],
            },
        ]);
    });

    it("should generate dimension for attribute based measures", () => {
        const { execution } = AFMBuilder.buildFromSchema(schema)
            .addAttributeBasedMeasure()
            .build();

        const resultSpec: AFM.IResultSpec = {
            dimensions: [
                {
                    itemIdentifiers: ["measureGroup"],
                },
            ],
        };

        expect(generateDimensions(project, execution.afm, resultSpec)).toEqual([
            {
                headers: [
                    {
                        measureGroupHeader: {
                            items: [
                                {
                                    measureHeaderItem: {
                                        format: "#,##0",
                                        localIdentifier: "m0",
                                        name: "Count of Employee",
                                    },
                                },
                            ],
                        },
                    },
                ],
            },
        ]);
    });

    it("should generate dimensions for attributes", () => {
        const { execution } = AFMBuilder.buildFromSchema(schema)
            .addAttribute()
            .build();

        const resultSpec: AFM.IResultSpec = {
            dimensions: [
                {
                    itemIdentifiers: ["a0"],
                },
            ],
        };

        expect(generateDimensions(project, execution.afm, resultSpec)).toEqual([
            {
                headers: [
                    {
                        attributeHeader: {
                            identifier: displayForm.meta.identifier,
                            localIdentifier: "a0",
                            name: displayForm.meta.title,
                            uri: displayForm.meta.uri,
                            formOf: {
                                uri: attribute.meta.uri,
                                identifier: attribute.meta.identifier,
                                name: attribute.meta.title,
                            },
                        },
                    },
                ],
            },
        ]);
    });

    it("should generate dimensions for attributes with alias", () => {
        const alias = "My custom header name";

        const { execution } = AFMBuilder.buildFromSchema(schema)
            .addAttribute(alias)
            .build();

        const resultSpec: AFM.IResultSpec = {
            dimensions: [
                {
                    itemIdentifiers: ["a0"],
                },
            ],
        };

        expect(generateDimensions(project, execution.afm, resultSpec)).toEqual([
            {
                headers: [
                    {
                        attributeHeader: {
                            identifier: displayForm.meta.identifier,
                            localIdentifier: "a0",
                            name: displayForm.meta.title,
                            uri: displayForm.meta.uri,
                            formOf: {
                                uri: attribute.meta.uri,
                                identifier: attribute.meta.identifier,
                                name: alias,
                            },
                        },
                    },
                ],
            },
        ]);
    });

    it("should generate dimensions for pivot table", () => {
        const { execution } = AFMBuilder.buildFromSchema(schema)
            .addAttributeByTitle("Employee")
            .addAttributeByTitle("Customer")
            .addAttributeByTitle("Country")
            .addMeasure()
            .build();

        const resultSpec: AFM.IResultSpec = {
            dimensions: [
                {
                    itemIdentifiers: ["a0"],
                },
                {
                    itemIdentifiers: ["a2", "a1", "measureGroup"],
                },
            ],
        };

        const customerAttr = project.groups[0].attributes[1];
        const [customerDf] = project.groups[0].attributes[1].content.displayForms;
        const countryAttr = project.groups[0].attributes[3];
        const [countryDf] = project.groups[0].attributes[3].content.displayForms;

        expect(generateDimensions(project, execution.afm, resultSpec)).toEqual([
            {
                headers: [
                    {
                        attributeHeader: {
                            identifier: displayForm.meta.identifier,
                            localIdentifier: "a0",
                            name: displayForm.meta.title,
                            uri: displayForm.meta.uri,
                            formOf: {
                                uri: attribute.meta.uri,
                                identifier: attribute.meta.identifier,
                                name: attribute.meta.title,
                            },
                        },
                    },
                ],
            },
            {
                headers: [
                    {
                        attributeHeader: {
                            identifier: countryDf.meta.identifier,
                            localIdentifier: "a2",
                            name: countryDf.meta.title,
                            uri: countryDf.meta.uri,
                            formOf: {
                                uri: countryAttr.meta.uri,
                                identifier: countryAttr.meta.identifier,
                                name: countryAttr.meta.title,
                            },
                        },
                    },
                    {
                        attributeHeader: {
                            identifier: customerDf.meta.identifier,
                            localIdentifier: "a1",
                            name: customerDf.meta.title,
                            uri: customerDf.meta.uri,
                            formOf: {
                                uri: customerAttr.meta.uri,
                                identifier: customerAttr.meta.identifier,
                                name: customerAttr.meta.title,
                            },
                        },
                    },
                    {
                        measureGroupHeader: {
                            items: [
                                {
                                    measureHeaderItem: {
                                        format: metric1.content.format,
                                        identifier: metric1.meta.identifier,
                                        localIdentifier: "m0",
                                        name: metric1.meta.title,
                                        uri: metric1.meta.uri,
                                    },
                                },
                            ],
                        },
                    },
                ],
            },
        ]);
    });
});