// (C) 2007-2019 GoodData Corporation
import { ISchema } from "../model/Schema";
import { createProject } from "./ProjectBuilder";
import { getProjectId } from "../../model/Project";
import { objectUri } from "../../route/routes";
import { cloneDeep } from "lodash";
import { IMockResponseConfig } from "../../endpoints/helpers/mockRequest";
import { IOrganizedCatalog } from "../../model/MockProject";

export function createOrganizedCatalog(schema: ISchema): IOrganizedCatalog {
    const project = createProject(schema);
    const projectId = getProjectId(project);

    if (schema.organizedCatalog === undefined) {
        return;
    }

    const transformedSchema = cloneDeep(schema.organizedCatalog);

    transformedSchema.items = transformItemsMocks(schema.organizedCatalog.items || [], projectId);
    transformedSchema.queryResponse = transformQueryMocks(
        schema.organizedCatalog.queryResponse || [],
        projectId,
    );
    transformedSchema.groups = transformGroupsMocks(schema.organizedCatalog.groups || []);

    return transformedSchema;
}

const transformGroupsMocks = (originalGroupsMocks: IMockResponseConfig[]) =>
    originalGroupsMocks.map((mockResponseConfig: IMockResponseConfig) => {
        const transformedMock: IMockResponseConfig = cloneDeep(mockResponseConfig);
        transformedMock.response = {
            catalogGroups: mockResponseConfig.response,
        };
        return transformedMock;
    });

const transformItemsMocks = (originalItemsMocks: IMockResponseConfig[], projectId: string) => {
    return originalItemsMocks.map((mockResponseConfig: IMockResponseConfig) => {
        const transformedMock: IMockResponseConfig = cloneDeep(mockResponseConfig);
        const transformedItems = mockResponseConfig.response.map((item: any) => ({
            ...item,
            links: getLinks(projectId, item),
        }));
        transformedMock.response = {
            catalogItems: {
                items: transformedItems,
                paging: {
                    count: transformedItems.length,
                    offset: parseInt(mockResponseConfig.query.offset, 10),
                },
            },
        };
        return transformedMock;
    });
};

const transformQueryMocks = (originalQueryMocks: IMockResponseConfig[], projectId: string) => {
    return originalQueryMocks.map((mockResponseConfig: IMockResponseConfig) => {
        const transformedMock: IMockResponseConfig = cloneDeep(mockResponseConfig);
        transformedMock.response = {
            catalogAvailableItems: {
                items: mockResponseConfig.response.map((itemIdentifier: string) =>
                    objectUri(projectId, itemIdentifier),
                ),
            },
        };
        transformedMock.body.catalogQueryRequest.bucketItems = mockResponseConfig.body.catalogQueryRequest.bucketItems.map(
            (itemIdentifier: string) => ({ uri: objectUri(projectId, itemIdentifier) }),
        );
        return transformedMock;
    });
};

const getLinks = (projectId: string, item: any) =>
    item.type === "attribute"
        ? {
              defaultDisplayForm: objectUri(projectId, `${item.identifier}.df`),
              self: objectUri(projectId, item.identifier),
          }
        : {
              self: objectUri(projectId, item.identifier),
          };