/**
 * Data container instance - provides standard methods for obtaining data
 */
import EntityFilterQuery from "./query/entity-filter-query";
import EntityFilteredResults from "./query/entity-filtered-results";
import Loader from "../util/loader";
import ArrayFormatters from "kinibind/ts/formatters/array-formatters";
import ObjectFormatters from "kinibind/ts/formatters/object-formatters";

//import "kinibind/ts/util/polyfills";

import EntityMetaManager from "./entity-meta-manager";
import Config from "../config";

export default class EntityDataMapper {

    // Entity definition
    private _entityDefinition;

    // Local data
    private _localDataPromise: any;


    /**
     * Static data mappers collection
     */
    private static _dataMappers: any = {};

    // Entity constructor
    constructor(entityDefinition: any) {
        this._entityDefinition = entityDefinition;
    }


    // Get a data mapper for the passed entity by name
    public static getMapper(entityName: any): Promise<EntityDataMapper> {

        return EntityMetaManager.definitions.then(entityDefinitions => {

            if (entityDefinitions[entityName]) {
                if (!this._dataMappers[entityName]) {
                    this._dataMappers[entityName] = new EntityDataMapper(entityDefinitions[entityName]);
                }

                return this._dataMappers[entityName];
            } else {
                throw("No such entity " + entityName);
            }

        });

    }


    /**
     * Get filtered results for this entity
     *
     * @param filterQuery
     */
    public getFilteredResults(filterQuery: EntityFilterQuery): Promise<EntityFilteredResults> {

        return this.localDataPromise.then(data => {

            data = ObjectFormatters.values(data);

            if (filterQuery) {

                if (filterQuery.filters) {
                    data = ArrayFormatters.filter(data, filterQuery.filters);
                }

                if (filterQuery.sortOrders) {
                    data = ArrayFormatters.sort(data, filterQuery.sortOrders)
                }

                if (filterQuery.offset || filterQuery.limit) {
                    data = ArrayFormatters.slice(data, filterQuery.offset ? filterQuery.offset : 0,
                        filterQuery.limit ? filterQuery.limit : 1000000000);
                }

            }

            return new EntityFilteredResults(data, data.length);


        });

    }


    /**
     * Get a single item by id
     *
     * @param id
     */
    public getById(id: string): Promise<any> {

        return this.localDataPromise.then(data => {

            if (data[id]) {
                return data[id];
            } else {
                let keys = Object.keys(data);
                for (var i = 0; i < keys.length; i++) {
                    let dataItem = data[keys[i]];
                    if (dataItem.id == id) {
                        return dataItem;
                    }
                }
            }

            throw("No item of type " + this._entityDefinition.name + " matches id " + id);

        });


    }


    /**
     * Get a single item by path (if relevant)
     *
     * @param path
     */
    public getByPath(path: string): Promise<any> {
        return this.localDataPromise.then(data => {

            path = path.split("?")[0];

            if (path.startsWith("/"))
                path = path.substr(1);
            if (path.endsWith("/"))
                path = path.substr(0, path.length - 1);

            if (data[path]) {
                return data[path];
            } else if (!path.startsWith("_entitypreview")) {
                throw("No item of type " + this._entityDefinition.name + " matches path " + path);
            } else {
                return null;
            }
        });
    }


    /**
     * Get the single item for an entity defined as a single instance
     *
     */
    public single(): Promise<any> {
        return this.localDataPromise;
    }


    /**
     * Return all conceptually for an entity defined as a non single instance
     */
    public all(): Promise<any[]> {
        return this.localDataPromise.then(data => {
            return Object.values(data);
        });
    }


    // Get local data for this entity
    private get localDataPromise(): Promise<any> {
        if (!this._localDataPromise) {
            this._localDataPromise = Loader.loadSiteJsonFile(Config.instance().siteDataBasePath + "/data/" + this._entityDefinition.name + ".json", this._entityDefinition.singleInstance);
        }
        return this._localDataPromise;
    }

}