// (C) 2007-2019 GoodData Corporation
import { VisualizationObject, VisualizationClass, ExtendedDateFilters } from "@gooddata/typings";
import { flatMap } from "lodash";
import { IAttribute } from "./Attribute";
import { IFact } from "./Fact";
import { IUser } from "./User";
import { IMetric } from "./Metric";
import { IProject } from "./Project";
import { IProjectPermissions } from "./ProjectPermissions";
import { IDateAttribute, IDateDataSet } from "./DateDataSet";
import { IElement } from "./Element";
import { IFeatureFlags } from "./FeatureFlags";
import { IConfigSettingItem } from "./ProjectConfigs";
import { IExecution } from "./Executions";
import { IAnalyticalDashboard } from "./AnalyticalDashboard";
import { IVisualizationWidget } from "./VisualizationWidget";
import { IKpi } from "./Kpi";
import { IFilterContext } from "./FilterContext";
import { Widget } from "./Widget";
import { IKpiAlert } from "./KpiAlert";
import { IAttributeDisplayForm } from "./AttributeDisplayForm";
import { ISchemaAfmExecution } from "../schema/model/SchemaAfmExecution";
import { ElementMap } from "../schema/builders/ElementsBuilder";
import { DateRangesMap } from "../schema/builders/DateRangesBuilder";
import { IEndPoints } from "./endPoints/EndPoints";
import { IBootstrap } from "./Bootstrap";
import { IStyleSettings } from "../model/StyleSetting";
import { IMockResponseConfig } from "../endpoints/helpers/mockRequest";

export type GroupType = "production" | "csv";

export interface IGroupMeta {
    identifier: string;
    type: GroupType;
}

export interface IProjectGroup {
    attributes: IAttribute[];
    metrics: IMetric[];
    facts: IFact[];
    dateDataSets: IDateDataSet[];
    meta: IGroupMeta;
}

export interface IOrganizedCatalog {
    items?: IMockResponseConfig[];
    groups?: IMockResponseConfig[];
    queryResponse?: IMockResponseConfig[];
    queryResult?: IMockResponseConfig[];
}

export interface IMockProject {
    project?: IProject;
    projectPermissions?: IProjectPermissions;
    users?: IUser[];
    groups?: IProjectGroup[];
    elements?: ElementMap;
    dateRanges?: DateRangesMap;
    featureFlags?: IFeatureFlags;
    projectConfigs?: IConfigSettingItem[];
    userConfigs?: IConfigSettingItem[];
    executions?: IExecution[];
    afmExecutions?: ISchemaAfmExecution[];
    endPoints?: IEndPoints;
    analyticalDashboards?: IAnalyticalDashboard[];
    visualizationObjects?: VisualizationObject.IVisualizationObject[];
    visualizationClasses?: VisualizationClass.IVisualizationClass[];
    visualizationWidgets?: IVisualizationWidget[];
    kpis?: IKpi[];
    filterContexts?: IFilterContext[];
    widgets?: Widget[];
    kpiAlerts?: IKpiAlert[];
    bootstrap?: IBootstrap;
    styleSettings?: IStyleSettings;
    dateFilterConfig?: ExtendedDateFilters.IDateFilterConfig;
    organizedCatalog?: IOrganizedCatalog;
}

export function getAttributes(project: IMockProject): IAttribute[] {
    return flatMap(project.groups, group => group.attributes);
}

export function getDateAttributes(project: IMockProject): IDateAttribute[] {
    return flatMap(getDateDataSets(project), dateDataSet => dateDataSet.availableDateAttributes);
}

export function getAttributeDisplayForms(project: IMockProject): IAttributeDisplayForm[] {
    const attributes = getAttributes(project);

    return flatMap(attributes, attribute => attribute.content.displayForms);
}

export function getDateAttributeDisplayForms(project: IMockProject): IAttributeDisplayForm[] {
    return flatMap(getDateAttributes(project), dateAttribute => dateAttribute.displayForms);
}

export function getMetrics(project: IMockProject): IMetric[] {
    return flatMap(project.groups, group => group.metrics);
}

export function getFacts(project: IMockProject): IFact[] {
    return flatMap(project.groups, group => group.facts);
}

export function getFilterContexts(project: IMockProject): IFilterContext[] {
    return project.filterContexts;
}

export function getDateDataSets(project: IMockProject): IDateDataSet[] {
    return flatMap(project.groups, group => group.dateDataSets);
}

export function getDateDataSetDisplayForms(dateDataSet: IDateDataSet): IAttributeDisplayForm[] {
    return flatMap(dateDataSet.availableDateAttributes, attribute => attribute.displayForms);
}

export function getAllDateDataSetDisplayForms(project: IMockProject): IAttributeDisplayForm[] {
    const dateDataSets = getDateDataSets(project);
    return flatMap(dateDataSets, getDateDataSetDisplayForms);
}

export function getWidgets(project: IMockProject): Widget[] {
    return project.widgets;
}

export function getAnalyticalDashboards(project: IMockProject): IAnalyticalDashboard[] {
    return project.analyticalDashboards;
}

export function getVisualizationObjects(project: IMockProject): VisualizationObject.IVisualizationObject[] {
    return project.visualizationObjects;
}

export function getVisualizationObject(
    project: IMockProject,
    uri: string,
): VisualizationObject.IVisualizationObject {
    return project.visualizationObjects
        ? project.visualizationObjects.find(obj => obj.meta.uri === uri)
        : undefined;
}

export function getVisualizationClasses(project: IMockProject): VisualizationClass.IVisualizationClass[] {
    return project.visualizationClasses;
}

export function getVisualizationWidgets(project: IMockProject): IVisualizationWidget[] {
    const widgets: Widget[] = project.widgets
        ? project.widgets.filter((widget: Widget) => widget.meta.category === "visualizationWidget")
        : [];

    return widgets as IVisualizationWidget[];
}

export function getDateFilterConfig(project: IMockProject): ExtendedDateFilters.IDateFilterConfig {
    return project.dateFilterConfig;
}

export function getAttributeByUri(project: IMockProject, uri: string): IAttribute {
    return getAttributes(project).find(attribute => attribute.meta.uri === uri);
}

export function getAttributeByTitle(project: IMockProject, title: string): IAttribute {
    return getAttributes(project).find(attribute => attribute.meta.title === title);
}

export function isKnownDisplayFormId(project: IMockProject, displayFormId: string): boolean {
    const displayForms = flatMap(getAttributes(project), attribute => attribute.content.displayForms);

    return displayForms.some(displayForm => displayForm.meta.identifier === displayFormId);
}

export function isDateDisplayForm(project: IMockProject, displayForm: IAttributeDisplayForm): boolean {
    return getAllDateDataSetDisplayForms(project).some(
        dateDisplayForm => dateDisplayForm.meta.identifier === displayForm.meta.identifier,
    );
}

export function isDateDisplayFormById(project: IMockProject, displayFormId: string): boolean {
    return getAllDateDataSetDisplayForms(project).some(
        dateDisplayForm => dateDisplayForm.meta.identifier === displayFormId,
    );
}

export function getAttributeElementsByDisplayForm(project: IMockProject, displayFormId: string): IElement[] {
    const displayForms = getAttributeDisplayForms(project);

    const displayForm = displayForms.find(df => df.meta.identifier === displayFormId);

    if (!displayForm) {
        return [];
    }

    const attribute = getAttributes(project).find(attr => attr.meta.uri === displayForm.content.formOf);

    return attribute ? project.elements.get(attribute.meta.identifier) : [];
}