"use strict";
(function () {
    'use strict';
    angular.module('templateModule')
        .factory('ticketTemplateModel', ['ticketTemplateService', 'categoriesService', '$log', 'metadataModel',
        function (ticketTemplateService, categoriesService, $log, metadataModel) {
            var self = {}, incidentMetadata = null, workorderMetadata = null, changeMetadata = null, releaseMetadata = null;
            self.selectedIncidentTemplateTier = [];
            self.defaultIncidentTemplateTier = '';
            /**
             * Public functions
             */
            self.getTemplatesForSmartRecorder = function (params) {
                return ticketTemplateService.getTemplatesForSmartRecorder(params).then(function (templates) {
                    return processSmartRecorderTemplates(templates);
                });
            };
            self.getIncidentTemplateList = function (searchQuery, companyName, metadata) {
                incidentMetadata = metadata;
                return ticketTemplateService.getIncidentTemplateList(searchQuery, companyName)
                    .then(processIncidentTemplateList)
                    .catch(function () {
                    $log.error('Error getting incident template list.');
                });
            };
            self.getIncidentTemplateListByCategory = function (params, metadata) {
                incidentMetadata = metadata;
                return ticketTemplateService.getIncidentTemplateListByCategory(params)
                    .then(processIncidentTemplateList)
                    .catch(function () {
                    $log.error('Error getting incident template list by category.');
                });
            };
            self.getIncidentTemplateTierOptions = function (tier) {
                var dependsParam = {}, dependency = {};
                if (self.selectedIncidentTemplateTier[0] !== self.defaultIncidentTemplateTier) {
                    dependsParam = {
                        templateCategoryTier1: self.selectedIncidentTemplateTier[0]
                    };
                    dependency = {
                        depends: dependsParam
                    };
                }
                if (self.selectedIncidentTemplateTier[1] !== self.defaultIncidentTemplateTier) {
                    dependsParam.templateCategoryTier2 = self.selectedIncidentTemplateTier[1];
                }
                return ticketTemplateService.getIncidentTemplateTierOptions(tier + 1, dependency).then(function (response) {
                    return response[0].items[0];
                });
            };
            self.getAllWorkorderTemplateList = function (metadata, company) {
                workorderMetadata = metadata;
                return ticketTemplateService.getAllWorkorderTemplateList(company)
                    .then(processWorkorderTemplateList)
                    .catch(function () {
                    $log.error('Error getting workorder template list.');
                });
            };
            self.getWorkorderTemplateList = function (params, metadata) {
                workorderMetadata = metadata;
                return ticketTemplateService.getWorkorderTemplateList(params.searchText, params.companyName)
                    .then(processWorkorderTemplateList)
                    .catch(function () {
                    $log.error('Error getting workorder template list.');
                });
            };
            self.getServicerequestTemplateList = function (searchQuery, companyName, customerId) {
                return ticketTemplateService.getServicerequestTemplateList(searchQuery, companyName, customerId)
                    .then(processServicerequestTemplateList)
                    .catch(function () {
                    $log.error('Error getting service request template list.');
                });
            };
            self.getServicerequestDynamicOptions = function (params, onSuccess) {
                var queryParams = { srdId: params[0], questionId: params[1] };
                if (typeof params[2] !== 'undefined' && typeof params[3] !== 'undefined') {
                    var questions = params[2], relatedQuestions = params[3];
                    _.each(questions, function (question) {
                        if (relatedQuestions.indexOf(question.id) !== -1 && question.id !== params[1]) {
                            if (question.format === 'DATE_TIME') {
                                question.answer = processTimeAnswer(question.answer.time, question.answer.date) + '';
                            }
                            if (question.format === 'DATE_ONLY') {
                                question.answer = moment(question.answer).unix() + '';
                            }
                            if (question.format === 'TIME_ONLY') {
                                question.answer = processTimeAnswer(question.answer) + '';
                            }
                            if (typeof question.answer === 'undefined' || question.answer === null) {
                                question.answer = '';
                            }
                            queryParams[question.id] = question.answer;
                        }
                    });
                }
                return ticketTemplateService.getServicerequestDynamicOptions(queryParams)
                    .then(onSuccess)
                    .catch(function () {
                    $log.error('Error getting service request dynamic options.');
                });
            };
            self.processDynamicQuestions = function (srdId, questions) {
                _.each(questions, function (question) {
                    // if (question.visibility) {
                    if (true) {
                        if (question.format === 'QUERY_MENU' || question.format === 'DYNAMIC_MENU') {
                            var params = [srdId, question.id];
                            if (question.format === 'DYNAMIC_MENU') {
                                params = [srdId, question.id, questions, question.relatedQuestions];
                            }
                            self.getServicerequestDynamicOptions(params, function (response) {
                                question.options = response.objects;
                            });
                        }
                    }
                });
            };
            self.updateDynamicQuestions = function (question, questions) {
                if (question.format === 'DYNAMIC_MENU') {
                    if (question.dataLoading) {
                        return;
                    }
                    question.options = [];
                    question.dataLoading = true;
                    var params = [question.srdIdForNullCheck, question.id, questions, question.relatedQuestions];
                    self.getServicerequestDynamicOptions(params, function (response) {
                        question.options = response.objects;
                    }).finally(function () {
                        question.dataLoading = false;
                    });
                }
            };
            self.getTaskTemplateMetadata = function () {
                return ticketTemplateService.getTaskTemplateMetadata().then(function (response) {
                    return response[0].items[0].types;
                });
            };
            self.getTaskGroupPreview = function (groupId) {
                return ticketTemplateService.getTaskGroupPreview(groupId).then(function (response) {
                    return response[0].items[0];
                });
            };
            self.getChangeTemplateList = function (searchQuery, companyName, metadata) {
                changeMetadata = metadata;
                return ticketTemplateService.getChangeTemplateList(searchQuery, companyName).then(function (response) {
                    var templateList = response.objects;
                    var data = _.map(templateList, function (item) {
                        return parseChangeTemplateItem(item);
                    });
                    return { items: data, exceedsChunkSize: response.exceedsChunkSize };
                });
            };
            self.getReleaseTemplateList = function (searchQuery, companyName, metadata) {
                releaseMetadata = metadata;
                return ticketTemplateService.getReleaseTemplateList(searchQuery, companyName).then(function (response) {
                    var templateList = response.objects;
                    var data = _.map(templateList, function (item) {
                        return parseReleaseTemplateItem(item);
                    });
                    return { items: data, exceedsChunkSize: response.exceedsChunkSize };
                });
            };
            self.getAllActivityTemplateList = function (company) {
                return ticketTemplateService.getAllActivityTemplateList(company)
                    .then(processActivityTemplateList)
                    .catch(function () {
                    $log.error('Error getting activity template list.');
                });
            };
            self.getActivityTemplateList = function (params) {
                return ticketTemplateService.getActivityTemplateList(params.searchText, params.companyName)
                    .then(processActivityTemplateList)
                    .catch(function () {
                    $log.error('Error getting activity template list.');
                });
            };
            self.getTaskTemplateList = function (term, companyName) {
                return ticketTemplateService.getTaskTemplateList(term, companyName);
            };
            /**
             * Private functions
             */
            function processSmartRecorderTemplates(templates) {
                return metadataModel.getMetadataByTypes([EntityVO.TYPE_INCIDENT, EntityVO.TYPE_WORKORDER]).then(function (metadataResponse) {
                    var incidentMetadata = metadataResponse[0], workorderMetadata = metadataResponse[1];
                    _.forEach(templates, function (template) {
                        if (template.type === 'incidenttemplate') {
                            // backend has inconsistent naming for Template Type. Smart search rest call returns as 'incidenttemplate',
                            // while string search rest call returns as 'incidentTemplate'.
                            // We will set them to the same name here so that it won't cause issue on share component
                            template.type = 'incidentTemplate';
                            var allCategories = template.templateObject.categorizations.concat(template.templateObject.resCategorizations);
                            template.allCategories = categoriesService.populateCategories(allCategories, incidentMetadata);
                        }
                        else if (template.type === 'workordertemplate') {
                            // same for workorder template type name. See comments above
                            template.type = 'workorderTemplate';
                            template.allCategories = categoriesService.populateCategories(template.templateObject.categorizations, workorderMetadata);
                        }
                    });
                    return templates;
                });
            }
            /**
             * Process incident template list data from server.
             *
             * @param {Array} data
             */
            function processIncidentTemplateList(data) {
                var items = data && data.objects || [];
                if (!items.length) {
                    $log.warn('Incient template list returned from server is empty or malformed.');
                }
                self.incidentTemplateList = _.map(items, function (item) {
                    return parseIncidentTemplateItem(item);
                });
                $log.debug('Incident template list loaded:');
                $log.debug(self.incidentTemplateList);
            }
            /**
             * Process service request template list data from server.
             *
             * @param {Array} data
             */
            function processServicerequestTemplateList(data) {
                var items = data && data.objects || [];
                if (!items.length) {
                    $log.warn('Service request template list returned from server is empty or malformed.');
                }
                self.servicerequestTemplateList = _.map(items, function (item) {
                    return parseServicerequestTemplateItem(item);
                });
                $log.debug('Service request template list loaded:');
                $log.debug(self.servicerequestTemplateList);
            }
            /**
             * Transform raw data into incident template item.
             *
             * @param {Object} data
             * @returns {IncidentTemplateVO} incident template item
             */
            function parseIncidentTemplateItem(data) {
                var incidentTemplateItem = new IncidentTemplateVO().build(data), allCategories = incidentTemplateItem.categorizations.concat(incidentTemplateItem.resCategorizations);
                incidentTemplateItem.allCategories = categoriesService.populateCategories(allCategories, incidentMetadata);
                return incidentTemplateItem;
            }
            /**
             * Process workorder template list data from server.
             *
             * @param {Array} data
             */
            function processWorkorderTemplateList(data) {
                var items = data && data.objects || [];
                if (!items.length) {
                    $log.warn('workorder template list returned from server is empty or malformed.');
                }
                self.workorderTemplateList = _.map(items, function (item) {
                    return parseWorkorderTemplateItem(item);
                });
                $log.debug('workorder template list loaded:');
                $log.debug(self.workorderTemplateList);
            }
            /**
             * Transform raw data into workorder template item.
             *
             * @param {Object} data
             * @returns {WorkorderTemplateVO} workorder template item
             */
            function parseWorkorderTemplateItem(data) {
                var templateItem = new WorkorderTemplateVO().build(data);
                templateItem.allCategories = categoriesService.populateCategories(templateItem.categorizations, workorderMetadata);
                return templateItem;
            }
            /**
             * Process Activity template list data from server.
             *
             * @param {Array} data
             */
            function processActivityTemplateList(data) {
                var items = data && data.objects || [];
                if (!items.length) {
                    $log.warn('Activity template list returned from server is empty or malformed.');
                }
                self.activityTemplateList = _.map(items, function (item) {
                    return parseActivityTemplateItem(item);
                });
                $log.debug('Activity template list loaded:');
                $log.debug(self.activityTemplateList);
            }
            /**
             * Transform raw data into Activity template item.
             *
             * @param {Object} data
             * @returns {ActivityTemplateVO} Activity template item
             */
            function parseActivityTemplateItem(data) {
                return new ActivityTemplateVO().build(data);
            }
            /**
             * Transform raw data into service request template item.
             *
             * @param {Object} data
             * @returns {ServicerequestTemplateVO} service request template item
             */
            function parseServicerequestTemplateItem(data) {
                var servicerequestTemplateItem = new ServicerequestTemplateVO().build(data);
                return servicerequestTemplateItem;
            }
            function processTimeAnswer(value, date) {
                if (value) {
                    var result = moment(value);
                    if (date) {
                        result = moment(date)
                            .hour(result.hour())
                            .minute(result.minute());
                    }
                    return result.unix();
                }
                return null;
            }
            /**
             * Transform raw data into change template item.
             *
             * @param {Object} data
             * @returns {ChangeTemplateVO} change template item
             */
            function parseChangeTemplateItem(data) {
                var changeTemplateItem = new ChangeTemplateVO().build(data);
                changeTemplateItem.allCategories = categoriesService.populateCategories(changeTemplateItem.categorizations, changeMetadata);
                return changeTemplateItem;
            }
            function parseReleaseTemplateItem(data) {
                var releaseTemplateItem = new ReleaseTemplateVO().build(data);
                releaseTemplateItem.allCategories = categoriesService.populateCategories(releaseTemplateItem.categorizations, releaseMetadata);
                return releaseTemplateItem;
            }
            return self;
        }]);
}());