// (C) 2007-2019 GoodData Corporation
import { every, some, negate, includes, partial } from "lodash";
import { WrappedMetadataObject } from "../../model";
import { IMetadataObject } from "../../model/MetadataObject";
import { isVisualizationClass } from "../../model/VisualizationClass";
import { isVisualizationObject } from "../../model/VisualizationObject";
import { isVisualizationWidget } from "../../model/VisualizationWidget";
import { isKpi } from "../../model/Kpi";
import { isFilterContext } from "../../model/FilterContext";
import { isAttributeDisplayForm } from "../../model/AttributeDisplayForm";
import { isFact } from "../../model/Fact";
import { isMetric } from "../../model/Metric";
import { isAttribute } from "../../model/Attribute";
import { isKpiAlert } from "../../model/KpiAlert";
import { isDateDataSet, wrapDateDataSet, isDateAttribute, wrapDateAttribute } from "../../model/DateDataSet";
import { isAnalyticalDashboard } from "../../model/AnalyticalDashboard";
import { isDateFilterConfig } from "../../model/DateFilterConfig";

export function getIdentifier(item: IMetadataObject): string {
    return item.meta.identifier;
}

export function getTitle(item: IMetadataObject): string {
    return item.meta.title;
}

export function getUri(item: IMetadataObject): string {
    return item.meta.uri;
}

export function getTags(item: IMetadataObject): string {
    return item.meta.tags;
}

export function getAuthor(item: IMetadataObject): string {
    return item.meta.author;
}

export function parseTags(item: IMetadataObject): string[] {
    const tags = getTags(item);
    return !tags ? [] : tags.split(" ");
}

export interface IIncludeExclude {
    includeObjectsWithTags?: string[];
    excludeObjectsWithTags?: string[];
}

export function filterItem<T extends IMetadataObject>(filter: IIncludeExclude, item: T): boolean {
    const { includeObjectsWithTags, excludeObjectsWithTags } = filter;

    const tags = parseTags(item);

    if (includeObjectsWithTags) {
        return some(tags, partial(includes, includeObjectsWithTags));
    }

    return every(tags, negate(partial(includes, excludeObjectsWithTags)));
}

export function filterByTags<T extends IMetadataObject>(request: IIncludeExclude, items: T[]): T[] {
    return items.filter(partial(filterItem, request));
}

export function getWrappedMetadataObject(object: IMetadataObject): WrappedMetadataObject {
    if (isVisualizationObject(object)) {
        return { visualizationObject: object };
    }

    if (isVisualizationClass(object)) {
        return { visualizationClass: object };
    }

    if (isVisualizationWidget(object)) {
        return { visualizationWidget: object };
    }

    if (isKpi(object)) {
        return { kpi: object };
    }

    if (isFilterContext(object)) {
        return { filterContext: object };
    }

    if (isAttributeDisplayForm(object)) {
        return { attributeDisplayForm: object };
    }

    if (isFact(object)) {
        return { fact: object };
    }

    if (isMetric(object)) {
        return { metric: object };
    }

    // needs to be before isAttribute
    if (isDateAttribute(object)) {
        return wrapDateAttribute(object);
    }

    if (isAttribute(object)) {
        return { attribute: object };
    }

    if (isKpiAlert(object)) {
        return { kpiAlert: object };
    }

    if (isDateDataSet(object)) {
        return wrapDateDataSet(object);
    }

    if (isAnalyticalDashboard(object)) {
        return { analyticalDashboard: object };
    }

    if (isDateFilterConfig(object)) {
        return { dateFilterConfig: object };
    }

    console.log("unknown object: ", object); // tslint:disable-line:no-console
}