// (C) 2007-2019 GoodData Corporation
import { VisualizationObject, VisualizationClass } from "@gooddata/typings";
import { IWrappedKpiAlert } from "../../../model/KpiAlert";
import * as request from "supertest";
import { objects } from "../objects";
import { createEndpoint } from "../../../utils/tests";
import { ISchema } from "../../../schema/model/Schema";
import { IWrappedDateFilterConfig } from "../../../model/DateFilterConfig";

const schema: ISchema = {
    project: {
        title: "My title",
    },

    visualizationObjects: [
        {
            title: "My visualization A",
            type: "local:column",
            author: "john-doe",
            identifier: "vis-a",
        },
        {
            title: "My visualization B",
            type: "local:column",
            author: "the-other-guy",
            identifier: "vis-b",
        },
        {
            title: "My visualization C",
            type: "local:column",
            author: "the-other-guy",
            identifier: "vis-c",
        },
    ],
    kpiAlerts: [
        {
            identifier: "alert_a",
            author: "john-doe",
            kpiId: "",
            dashboardId: "",
            threshold: 20,
            isTriggered: false,
            whenTriggered: "underThreshold",
        },
    ],
    visualizationClasses: [
        {
            title: "Table",
            url: "local:table",
        },
        {
            title: "Column",
            url: "local:column",
        },
    ],
    dateFilterConfig: {
        absoluteForm: {
            localIdentifier: "absoluteFormIdentifier",
            name: "testName",
            visible: true,
        },
        absolutePresets: [
            {
                from: "2017-01-01",
                localIdentifier: "my_identifier_absolute",
                name: "my_name2",
                to: "2018-01-01",
                visible: true,
            },
        ],
        allTime: {
            localIdentifier: "allTimeIdentifier",
            name: "testName",
            visible: true,
        },
        relativeForm: {
            granularities: ["GDC.time.date", "GDC.time.year"],
            localIdentifier: "relativeFormIdentifier",
            name: "testName",
            visible: true,
        },
        relativePresets: [
            {
                from: 1,
                granularity: "GDC.time.year",
                localIdentifier: "my_identifier_relative",
                name: "my_name",
                to: 2,
                visible: true,
            },
        ],
        selectedOption: "allTimeIdentifier",
        identifier: "defaultDateFilterConfig",
        title: "Date filter",
    },
};

function createVisualizationObject(
    title: string,
    identifier: string,
    visualizationClass: string,
    author?: string,
): VisualizationObject.IVisualization {
    return {
        visualizationObject: {
            content: {
                visualizationClass: {
                    uri: `/gdc/md/mockproject/obj/${visualizationClass}`,
                },
                buckets: [],
            },
            meta: {
                author: `/gdc/account/profile/${author}`,
                category: "visualizationObject",
                identifier,
                title,
                uri: `/gdc/md/mockproject/obj/${identifier}`,
            },
        },
    };
}

function createKpiAlert(identifier: string, author?: string): IWrappedKpiAlert {
    return {
        kpiAlert: {
            content: {
                kpi: "/gdc/md/mockproject/obj/",
                dashboard: "/gdc/md/mockproject/obj/",
                threshold: 20,
                isTriggered: false,
                whenTriggered: "underThreshold",
                filterContext: "",
            },
            meta: {
                author: `/gdc/account/profile/${author}`,
                category: "kpiAlert",
                identifier,
                title: "kpi alert",
                uri: `/gdc/md/mockproject/obj/${identifier}`,
            },
        },
    };
}

function createVisualizationClass(
    identifier: string,
    title: string,
    url: string,
    author?: string,
): VisualizationClass.IVisualizationClassWrapped {
    return {
        visualizationClass: {
            content: {
                url,
                icon: url,
                iconSelected: `${url}.selected`,
                checksum: "local",
            },
            meta: {
                author: `/gdc/account/profile/${author}`,
                category: "visualizationClass",
                identifier,
                title,
                uri: `/gdc/md/mockproject/obj/${identifier}`,
            },
        },
    };
}

const VisualizationA = createVisualizationObject("My visualization A", "vis-a", "column", "john-doe");
const VisualizationB = createVisualizationObject("My visualization B", "vis-b", "column", "the-other-guy");
const VisualizationC = createVisualizationObject("My visualization C", "vis-c", "column", "the-other-guy");

const JohnsKpiAlert = createKpiAlert("alert_a", "john-doe");

const visualizationClassTable = createVisualizationClass("table", "Table", "local:table", "john-doe");

const visualizationClassColumn = createVisualizationClass("column", "Column", "local:column", "john-doe");

const dateFilterConfig: IWrappedDateFilterConfig = {
    dateFilterConfig: {
        content: {
            absoluteForm: {
                localIdentifier: "absoluteFormIdentifier",
                name: "testName",
                visible: true,
            },
            absolutePresets: [
                {
                    from: "2017-01-01",
                    localIdentifier: "my_identifier_absolute",
                    name: "my_name2",
                    to: "2018-01-01",
                    visible: true,
                },
            ],
            allTime: {
                localIdentifier: "allTimeIdentifier",
                name: "testName",
                visible: true,
            },
            relativeForm: {
                granularities: ["GDC.time.date", "GDC.time.year"],
                localIdentifier: "relativeFormIdentifier",
                name: "testName",
                visible: true,
            },
            relativePresets: [
                {
                    from: 1,
                    granularity: "GDC.time.year",
                    localIdentifier: "my_identifier_relative",
                    name: "my_name",
                    to: 2,
                    visible: true,
                },
            ],
            selectedOption: "allTimeIdentifier",
        },
        meta: {
            category: "dateFilterConfig",
            identifier: "defaultDateFilterConfig",
            title: "Date filter",
            uri: "/gdc/md/mockproject/obj/defaultDateFilterConfig",
        },
    },
};

it("should return all visualizations by default", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get("/gdc/md/mockproject/objects/query?category=visualizationObject")
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [VisualizationA, VisualizationB, VisualizationC],
                    paging: {
                        offset: 0,
                        count: 3,
                    },
                },
            });
        });
});

it("should respect offset and limit", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get("/gdc/md/mockproject/objects/query?category=visualizationObject&offset=1&limit=1")
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [VisualizationB],
                    paging: {
                        offset: 1,
                        count: 1,
                        next:
                            "/gdc/md/mockproject/objects/query?category=visualizationObject&offset=2&limit=1",
                    },
                },
            });
        });
});

it("should provide polling link and total count if necessary", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get(
            "/gdc/md/mockproject/objects/query?category=visualizationObject&offset=0&limit=2&getTotalCount=1",
        )
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [VisualizationA, VisualizationB],
                    paging: {
                        offset: 0,
                        count: 2,
                        totalCount: 3,
                        next:
                            "/gdc/md/mockproject/objects/query?category=visualizationObject" +
                            "&offset=2&limit=2&getTotalCount=1",
                    },
                },
            });
        });
});

it("should be possible to filter by author", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get(
            "/gdc/md/mockproject/objects/query?category=visualizationObject&author=/gdc/account/profile/john-doe",
        )
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [VisualizationA],
                    paging: {
                        offset: 0,
                        count: 1,
                    },
                },
            });
        });
});

it("should return all kpiAlerts of given author", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get("/gdc/md/mockproject/objects/query?category=kpiAlert&author=/gdc/account/profile/john-doe")
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [JohnsKpiAlert],
                    paging: {
                        offset: 0,
                        count: 1,
                    },
                },
            });
        });
});

it("should fail if unknown category is queried", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get("/gdc/md/mockproject/objects/query?category=UNKNOWN")
        .set("Content-Type", "application/json")
        .expect(404);
});

it("should return all visualization classes", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get(
            "/gdc/md/mockproject/objects/query?category=visualizationClass&author=/gdc/account/profile/john-doe",
        )
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [visualizationClassTable, visualizationClassColumn],
                    paging: {
                        offset: 0,
                        count: 2,
                    },
                },
            });
        });
});

it("should return date filter config", () => {
    const app = createEndpoint(objects, schema);

    return request(app)
        .get("/gdc/md/mockproject/objects/query?category=dateFilterConfig")
        .set("Content-Type", "application/json")
        .expect(200)
        .then(res => {
            expect(res.body).toEqual({
                objects: {
                    items: [dateFilterConfig],
                    paging: {
                        offset: 0,
                        count: 1,
                    },
                },
            });
        });
});