import _ from 'lodash';
import moment from 'moment';
import {appConfig} from 'appConfig';

ArchiveService.$inject = ['desks', 'session', 'api', '$q', 'search', '$location'];
export function ArchiveService(desks, session, api, $q, search, $location) {
    /**
     * Adds 'task' property to the article represented by item.
     *
     * @param {Object} item
     * @param {Object} desk when passed the item will be assigned to this desk instead of user's activeDesk.
     */
    this.addTaskToArticle = function(item, desk = desks.getCurrentDesk()) {
        if ((!item.task || !item.task.desk) && desk && $location.path() !== '/workspace/personal') {
            item.task = {desk: desk._id, stage: desk.working_stage, user: session.identity._id};
        }
    };

    /**
     * Returns the _type aka repository of the item.
     *
     * @param {Object} item
     * @return String
     *      'ingest' if the state of the item is Ingested
     *      'spike' if the state of the item is Spiked
     *      'archived' if item is archived (no post publish actions)
     *      'archive' if none of the above is returned
     */
    this.getType = function(item) {
        var itemType;

        if (this.isLegal(item)) {
            itemType = item._type;
        } else if (this.isArchived(item)) {
            itemType = 'archived';
        } else if (item._type === 'externalsource') {
            itemType = 'externalsource';
        } else if (item.state === 'spiked') {
            itemType = 'spike';
        } else if (item.state === 'ingested') {
            itemType = 'ingest';
        } else {
            itemType = 'archive';
        }

        return itemType;
    };

    /**
     * Returns true if the item is fetched from Legal Archive
     *
     * @param {Object} item
     * @return boolean if the item is fetched from Legal Archive, false otherwise.
     */
    this.isLegal = function(item) {
        return item._type === 'legal_archive';
    };

    /**
     * Returns true if the item is fetched from Archived
     *
     * @param {Object} item
     * @return boolean if the item is fetched from Archived, false otherwise.
     */
    this.isArchived = function(item) {
        return item._type === 'archived';
    };

    /**
     * Returns true if the item is in personal workspace
     *
     * @param {Object} item
     * @return boolean
     */
    this.isPersonal = (item) => item.task && item.task.user && !item.task.desk;

    /**
     *  Returns the list of items having the same slugline and type from midnight onwards.
     *  @param {Object} item
     *  @param {Datetime} fromDateTime - from datetime
     *  @return {Object} the list of archive items
     */
    this.getRelatedItems = function(item, fromDateTime) {
        var beforeDateTime = fromDateTime || moment().subtract(1, 'days')
            .format(appConfig.view.dateformat);
        var params: any = {};

        params.q = 'slugline.phrase:"' + _.trim(item.slugline) + '"'; // exact match
        params.ignoreKilled = true;
        params.ignoreDigital = true;
        params.versioncreatedfrom = beforeDateTime;

        var query = search.query(params);

        query.size(200);

        if (_.get(item, '_id')) {
            let filter: any = {
                bool: {
                    must_not: [
                        {bool: {must: [{term: {_id: item._id}}, {term: {_type: 'archive'}}]}},
                        {bool: {must: [{term: {item_id: item._id}}, {term: {_type: 'published'}}]}},
                    ],
                    must: [{term: {type: item.type}}],
                },
            };

            query.filter(filter);
        }

        var criteria = query.getCriteria(true);

        criteria.repo = 'archive,published';

        return api.query('search', criteria).then((result) => result);
    };

    /** *
     * Returns versions of the item.
     *
     * @param {Object} item
     * @param {Object} deskService
     * @param {String} versionType one of versions, operations
     * @return list of object where each object is a version of the item
     */
    this.getVersions = function(item, deskService, versionType) {
        if (this.isLegal(item)) {
            return api.find('legal_archive', item._id, {version: 'all', max_results: 200})
                .then((result) => {
                    _.each(result._items, (version) => {
                        version.desk = version.task && version.task.desk ? version.task.desk : '';
                        version.stage = version.task && version.task.stage ? version.task.stage : '';
                        version.creator = version.version_creator || version.original_creator;

                        if (version.type === 'text') {
                            version.typeName = 'Story';
                        } else {
                            version.typeName = _.capitalize(item.type);
                        }
                    });

                    if (versionType === 'versions') {
                        return $q.when(_.sortBy(_.reject(result._items, {version: 0}), '_current_version').reverse());
                    } else if (versionType === 'operations') {
                        return $q.when(_.sortBy(result._items, '_current_version'));
                    }
                });
        }

        return api.find('archive', item._id, {version: 'all', embedded: {user: 1}, max_results: 200})
            .then((result) => {
                _.each(result._items, (version) => {
                    if (version.task) {
                        if (version.task.desk) {
                            var versiondesk = deskService.deskLookup[version.task.desk];

                            version.desk = versiondesk && versiondesk.name;
                        }
                        if (version.task.stage) {
                            var versionstage = deskService.stageLookup[version.task.stage];

                            version.stage = versionstage && versionstage.name;
                        }
                    }
                    if (version.version_creator || version.original_creator) {
                        var versioncreator =
                            deskService.userLookup[version.version_creator || version.original_creator];

                        version.creator = versioncreator && versioncreator.display_name || 'System';
                    }

                    if (version.type === 'text') {
                        version.typeName = 'Story';
                    } else {
                        version.typeName = _.capitalize(item.type);
                    }
                });

                if (versionType === 'versions') {
                    return $q.when(_.sortBy(_.reject(result._items, {version: 0}), '_current_version').reverse());
                } else if (versionType === 'operations') {
                    return $q.when(_.sortBy(result._items, '_current_version'));
                }
            });
    };

    /**
     * Get latest version from the list
     *
     * @param {Object} item
     * @param {Object} versions
     * @return last version of the item
     */
    this.lastVersion = function(item, versions) {
        if (item._latest_version) {
            return _.find(versions, {_current_version: item._latest_version});
        }

        const versionsMap = versions.map((v) => v._current_version || v.version);

        return _.max(versionsMap);
    };
}