"use strict";
(function () {
    'use strict';
    angular.module('feedModule')
        .factory('feedModel', ['feedService', '$q', 'attachmentService', 'metadataModel', 'systemAlertService', '$filter', 'ticketModel',
        function (feedService, $q, attachmentService, metadataModel, systemAlertService, $filter, ticketModel) {
            var feedModel = {
                pendingWorkNote: null
            };
            var allFilterSelected = false;
            var filterSelectedCount;
            var updateFeed = {
                filters: {},
                params: {
                    searchQuery: '',
                    followCount: true,
                    limit: 20
                }
            };
            var activityFeed = {
                filters: {},
                params: {
                    searchQuery: '',
                    limit: 20
                }
            };
            var prepareGetFeedItemsRequestParams = function (feed, criteria, entity) {
                var filters = {};
                _.forEach(feed.filters, function (item, key) {
                    filters[key] = item.join(',');
                });
                if (!feed.params.searchQuery) {
                    feed.params.searchQuery = void 0; //small hack to get rid of searchQuery from url, as it is undefined $resource does not include it in a request URL.
                }
                if (entity && entity.poiId) {
                    feed.params.poiId = entity.poiId;
                }
                else {
                    feed.params.poiId = null;
                }
                return angular.extend({}, filters, criteria, feed.params);
            };
            feedModel.updateFeed = updateFeed;
            feedModel.activityFeed = activityFeed;
            feedModel.workinfoTypeFilters = {};
            feedModel.getUpdateFeedItems = function (criteria) {
                if (allFilterSelected) {
                    updateFeed.filters = {};
                }
                return feedService.getUpdateFeedItems(prepareGetFeedItemsRequestParams(updateFeed, criteria));
            };
            feedModel.buildFeedFilter = function (feed, filtersSet) {
                var criteria = [];
                feed.filters = {};
                filterSelectedCount = 0;
                _.forEach(filtersSet, function (filter) {
                    if (filter.selected) {
                        filterSelectedCount++;
                        criteria = (_.isArray(filter.criteria)) ? filter.criteria : [filter.criteria];
                        _.forEach(criteria, function (criterion) {
                            if (feed.filters[criterion.name]) {
                                feed.filters[criterion.name] = _.union(feed.filters[criterion.name], criterion.value);
                            }
                            else {
                                feed.filters[criterion.name] = criterion.value;
                            }
                        });
                    }
                });
                allFilterSelected = filterSelectedCount === filtersSet.length ? true : false;
            };
            feedModel.getActivityFeedItems = function (entity, criteria) {
                if (entity.id && entity.type) {
                    return feedService.getActivityFeedItems(entity, prepareGetFeedItemsRequestParams(activityFeed, criteria, entity));
                }
            };
            /**
             * Save work note
             *
             * @param entity
             * @param note
             * @returns {*}
             */
            feedModel.saveNote = function (entity, note) {
                var request, prom;
                if (note.addFlagNote) {
                    if (note.isNeedAttentionFlag) {
                        request = {
                            needsAttention: note.flag ? "Yes" : "No",
                            worknote: (note.flag ? "Needs Attention Flagged: " : "Needs Attention Unflagged: ") + note.noteText
                        };
                        return ticketModel.update(entity.id, entity.type, request);
                    }
                    else {
                        request = {
                            flagNote: note.noteText,
                            flagged: note.flag,
                            workInfoType: note.workInfoType
                        };
                        if (!_.isUndefined(note.workNoteGuid)) {
                            request.isCommentOnly = note.isCommentOnly;
                            request.workNoteGuid = note.workNoteGuid;
                        }
                    }
                }
                else if (!note.worknote) {
                    request = {
                        worknote: note.noteText,
                        access: note.access,
                        workInfoType: note.workInfoType,
                        chatSessionId: note.chatSessionId
                    };
                }
                else {
                    request = note;
                }
                if (note.brokerVendorName) {
                    if (note.shareWithVendor) {
                        request.shareWithVendor = true;
                    }
                    if (note.vendorTicketId) {
                        request.vendorTicketId = note.vendorTicketId;
                    }
                    request.brokerVendorName = note.brokerVendorName;
                }
                if (note.addFlagNote) {
                    return feedService.addActivityFeedWorknoteWithFlag(entity, request);
                }
                else if (note.attachments && note.attachments.length) {
                    prom = attachmentService.addWorknoteWithAttachment(entity, note);
                    prom.catch(function (err) {
                        systemAlertService.error({
                            text: (err && err.data && (err.data.defaultMessage || err.data.detailMessage || err.data.error)) || err,
                            clear: false
                        });
                    });
                    return prom;
                }
                else {
                    prom = feedService.addActivityFeedWorknote(entity, request);
                    prom.then(function (res) {
                        if (note.articleId && note.attachmentType === "pdf") {
                            systemAlertService.success({ text: res[0].items[0].statusInfo.message, clear: true, hide: 10000 });
                        }
                    }).catch(function (err) {
                        if (err) {
                            systemAlertService.error({
                                text: (err.data && err.data.error) || $filter('i18n')('error.unknown'),
                                clear: false
                            });
                        }
                    });
                    return prom;
                }
            };
            feedModel.saveNoteBulk = function (request) {
                if (request.attachments && request.attachments.length) {
                    return attachmentService.addWorknoteWithAttachmentBulk(request);
                }
                else {
                    return feedService.addActivityFeedWorknoteBulk(request);
                }
            };
            /**
             * Process pending work note (if any)
             *
             * @param {Object} ticket - related ticket
             */
            feedModel.processPendingWorkNote = function (ticket) {
                if (feedModel.pendingWorkNote) {
                    console.log('saving pending note..');
                    var entity = {
                        type: ticket.type,
                        id: ticket.id
                    };
                    return feedModel.saveNote(entity, feedModel.pendingWorkNote)
                        .then(function () {
                        console.log('pending note saved');
                        feedModel.pendingWorkNote = null;
                    }).catch(function (pendingWorkNoteError) {
                        systemAlertService.error({
                            text: pendingWorkNoteError.data.error,
                            clear: false,
                            displayOnStateChange: true
                        });
                    });
                }
            };
            feedModel.getWorkinfoTypeFilters = function (type) {
                if (feedModel.workinfoTypeFilters[type] || !EntityVO.hasMetadata(type)) {
                    return $q.when(feedModel.workinfoTypeFilters[type] || []);
                }
                feedModel.workinfoTypeFilters[type] = [];
                return metadataModel.getMetadataByType(type).then(function (metadata) {
                    var workinfoTypes = _.filter(metadata.workinfoTypes, { type: 'option' });
                    _.forEach(workinfoTypes, function (workinfoType) {
                        feedModel.workinfoTypeFilters[type].push({
                            name: workinfoType.name,
                            label: workinfoType.label,
                            type: 'showWorkinfoTypes',
                            criteria: [{
                                    name: 'workNoteTypeId',
                                    value: [workinfoType.index]
                                }, {
                                    name: 'filterType',
                                    value: ['comment']
                                }
                            ]
                        });
                    });
                    return feedModel.workinfoTypeFilters[type] || [];
                });
            };
            feedModel.unpinFeedItem = function (feedItem) {
                var entity = {
                    type: feedItem.type,
                    id: feedItem.id
                };
                return feedService.unpinFeedItem(entity).then(function () {
                }).catch(function () {
                    systemAlertService.error({
                        text: $filter('i18n')('feed.unpin.error'),
                        clear: false
                    });
                });
            };
            return feedModel;
        }
    ]);
}());