"use strict";
(function () {
    'use strict';
    angular.module('myitsmApp')
        .factory('chatModel', ['$http', '$timeout', '$filter', '$q', 'chatService', 'chatSwarm', 'userModel', 'systemAlertService', 'ticketModel', 'assetModel',
        function ($http, $timeout, $filter, $q, chatService, chatSwarm, userModel, systemAlertService, ticketModel, assetModel) {
            var chatModel = {
                Client: {},
                connectInProgress: false,
                connected: false,
                cachedProfiles: {},
                pendingProfileRequests: {},
                currentUser: { available: EntityVO.CHAT_STATUS_OFFLINE },
                activeChatRooms: [],
                pendingChatRoomMessages: {}
            };
            var checkAvailabilityList = [], requestedProfiles = [], profileRequestPromise;
            chatModel.openChatConnection = function () {
                if (chatModel.connectInProgress) {
                    return;
                }
                chatModel.connectInProgress = true;
                userModel.getFullCurrentUserData()
                    .then(function () {
                    return chatService.openChatConnection({ userCallbacks: chatModel.chatEventHandlers });
                })
                    .then(function (Client) {
                    chatModel.Client = Client;
                    chatModel.Client.pendingPromises.connectionState.promise.then(function () {
                        chatModel.currentUser = userModel.userFullData;
                        chatModel.currentUser.available = EntityVO.CHAT_STATUS_ONLINE;
                        if (!chatModel.currentUser.jid) {
                            chatModel.currentUser.jid = Strophe.getNodeFromJid(chatModel.Client.conn.jid);
                        }
                        chatModel.connected = true;
                        chatModel.Client.pendingPromises.disconnect.promise.then(function () {
                            chatModel.connected = true;
                            chatModel.currentUser.available = EntityVO.CHAT_STATUS_ONLINE;
                        });
                    });
                })
                    .finally(function () {
                    chatModel.connectInProgress = false;
                });
            };
            chatModel.getUserProfileByJID = function (jid) {
                var userProfilesToRequest = _.uniq([].concat(jid));
                if (userProfilesToRequest && requestedProfiles.length > 0) {
                    userProfilesToRequest = _.difference(userProfilesToRequest, requestedProfiles);
                }
                if (userProfilesToRequest.length == 0) {
                    return profileRequestPromise;
                }
                else {
                    requestedProfiles = angular.copy(userProfilesToRequest);
                }
                profileRequestPromise = chatModel.Client.getUserProfileByJID(requestedProfiles)
                    .then(function (resp) {
                    _.each(resp, function (profile) {
                        chatModel.cachedProfiles[profile.jid] ? angular.extend(chatModel.cachedProfiles[profile.jid], profile) : chatModel.cachedProfiles[profile.jid] = profile;
                    });
                    return resp;
                })
                    .finally(function () {
                    requestedProfiles = [];
                });
                return profileRequestPromise;
            };
            var availabilityCheckDebounced = _.debounce(function (users) {
                var request = (users.length == 1) ? users[0] : users;
                return chatModel.Client.checkPresence(request)
                    .then(function (response) {
                    var availabilityData = {};
                    if (response.available) {
                        availabilityData[request] = response.available;
                    }
                    else {
                        availabilityData = response.availability;
                    }
                    _.each(availabilityData, function (status, userJID) {
                        status = status.toLowerCase();
                        if (chatModel.cachedProfiles[userJID]) {
                            chatModel.cachedProfiles[userJID].available = status;
                        }
                        else {
                            chatModel.cachedProfiles[userJID] = { available: status };
                        }
                    });
                    checkAvailabilityList = [];
                    return (response.available || response.availability);
                });
            }, 400);
            chatModel.checkUserAvailability = function (user) {
                checkAvailabilityList = _.uniq(checkAvailabilityList.concat(user));
                availabilityCheckDebounced(_.compact(checkAvailabilityList));
            };
            chatModel.generateUserJID = function (loginId) {
                if (!loginId)
                    return "";
                var systeUserJID = chatModel.currentUser.jid, systemUserId = chatModel.currentUser.loginId;
                var systemTenant = systeUserJID.split(systemUserId.toLowerCase()).pop();
                return loginId.toLowerCase() + systemTenant;
            };
            chatModel.updateCachedProfiles = function (profiles) {
                if (profiles && profiles.length) {
                    _.each(profiles, function (profile) {
                        if (profile.jid) {
                            chatModel.cachedProfiles[profile.jid] = profile;
                        }
                    });
                }
            };
            chatModel.setUserAvailability = function (availability) {
                chatModel.currentUser.available = availability;
                chatModel.currentUser.manualStatus = availability;
                return chatModel.Client.setUserPresence(availability);
            };
            chatModel.createChatRoom = function (invitee) {
                var chatWindow = chatModel.createChatWindowInstance({ isOpened: true, messages: [] });
                chatModel.activeChatRooms.push(chatWindow);
                return chatModel.Client.createChatRoom(invitee)
                    .then(function (room) {
                    var chatRoom = chatModel.Client.conn['muc'].rooms[room.name];
                    var userJid = chatModel.Client.conn.jid, message = chatModel.createChatMessageInstance({ eventType: 'enter', author: { jid: userJid }, type: 'system' }, chatRoom.name);
                    chatWindow.build({ id: chatRoom.name, room: chatRoom, isLoading: false, participants: chatRoom.roster, messages: [message] });
                    return chatWindow;
                })
                    .finally(function () {
                    chatWindow.isLoading = false;
                });
            };
            chatModel.createChatWindowInstance = function (config) {
                var activeChatWindow = config.room ? _.find(chatModel.activeChatRooms, { id: config.room.name }) : angular.noop();
                if (activeChatWindow)
                    return activeChatWindow;
                var chatWindow = new ChatWindowVO();
                if (config) {
                    chatWindow.build(config);
                }
                return chatWindow;
            };
            chatModel.createChatMessageInstance = function (message, roomName) {
                var chatWindow = _.find(chatModel.activeChatRooms, { id: roomName }), author = message.author, authorProfile, authorUserId, newMessage;
                var mucRoom = chatModel.Client.conn['muc'].rooms[roomName], currentUserNick = mucRoom.nick;
                if (author.nick && chatWindow) {
                    author.jid = chatWindow.participants[author.nick] ? chatWindow.participants[author.nick].jid : '';
                    if (!author.jid && currentUserNick == author.nick) {
                        author.jid = chatModel.currentUser.jid;
                    }
                }
                else if (author.nick && !chatWindow) {
                    var authorInfo = mucRoom.roster ? mucRoom.roster[author.nick] : angular.noop();
                    if (!authorInfo) {
                        if (currentUserNick == author.nick) {
                            authorInfo = chatModel.currentUser;
                        }
                        else
                            return { message: message, roomName: roomName, skipped: true };
                    }
                    author.jid = authorInfo.jid;
                }
                authorUserId = author.jid ? author.jid.split("@")[0] : angular.noop();
                authorProfile = (authorUserId == chatModel.currentUser.jid) ? chatModel.currentUser : chatModel.cachedProfiles[authorUserId];
                if (!authorProfile || (authorProfile && !authorProfile.firstName)) {
                    chatModel.getUserProfileByJID([authorUserId]).then(function () {
                        newMessage.author = chatModel.cachedProfiles[authorUserId];
                        (chatWindow && chatWindow.roster && !chatWindow.roster[authorUserId]) ? chatWindow.roster[authorUserId] = newMessage.author : angular.noop();
                    });
                }
                else {
                    (chatWindow && chatWindow.roster && !chatWindow.roster[authorUserId]) ? chatWindow.roster[authorUserId] = authorProfile : angular.noop();
                }
                if (chatSwarm.checkIfChatOpsMessage(message.text)) {
                    newMessage = chatSwarm.formatChatMessage(newMessage, message, chatWindow, authorProfile, false);
                }
                else if (message.hasOwnProperty("text") && message.text != (EntityVO.CHATOPS_SWARM) && message.text.startsWith(EntityVO.CHATOPS_SWARM)) {
                    try {
                        var messageText = message.text.substring(6);
                        if (!chatSwarm.checkIfJson(messageText)) {
                            newMessage = new ChatMessageVO()
                                .build({
                                text: message.text, author: authorProfile, chatWindow: chatWindow, type: message.type || 'chat',
                                created: message.created || "", eventType: message.eventType
                            });
                        }
                        else {
                            var fullData = JSON.parse(messageText);
                            var json = JSON.parse(fullData.participants);
                            for (var i = 0; i < json.length; i++) {
                                var personDetailsSelf = json[i];
                                if (authorProfile != null && authorProfile.hasOwnProperty("fullName") && personDetailsSelf[0].fullName == authorProfile.fullName) {
                                    json.splice(i, 1);
                                    break;
                                }
                            }
                            for (var p = 0; p < json.length; p++) {
                                var personDetails = json[p];
                                chatModel.checkUserAvailability(personDetails[0].jid);
                                try {
                                    json[p].available = chatModel.cachedProfiles[personDetails[0].jid].available;
                                }
                                catch (e) {
                                    json[p].available = "offline";
                                }
                            }
                            fullData.participants = json;
                            newMessage = new ChatMessageDataVO()
                                .build({
                                created: message.created,
                                data: fullData,
                                author: authorProfile,
                                type: message.type || 'swarmPeopleDetails',
                                chatWindow: chatWindow
                            });
                        }
                    }
                    catch (e) {
                        newMessage = new ChatMessageDataVO()
                            .build({
                            created: message.created,
                            data: [],
                            author: authorProfile,
                            type: message.type || 'swarmPeopleDetails',
                            chatWindow: chatWindow
                        });
                    }
                }
                else {
                    newMessage = new ChatMessageVO()
                        .build({
                        text: message.text, author: authorProfile, chatWindow: chatWindow, type: message.type || 'chat',
                        created: message.created || "", eventType: message.eventType
                    });
                }
                return newMessage;
            };
            chatModel.assignChatRoom = function (room, assignInfo) {
                return chatModel.Client.assignChatRoom(room, assignInfo);
            };
            chatModel.createAssignedChatRoom = function (parent, user) {
                return chatModel.createChatRoom(user).then(function (chatWindow) {
                    //						var chatRoom = _.findWhere(chatModel.activeChatRooms,{id: room.name});
                    chatWindow.parent = parent;
                    return chatModel.assignChatRoom(chatWindow.room, parent);
                });
            };
            chatModel.createAssignedChatRoomWithUser = function (user, parent) {
                return chatModel.createAssignedChatRoom(parent, user);
            };
            chatModel.removeChatAssignment = function (room) {
                return chatModel.Client.removeChatAssignment(room);
            };
            chatModel.inviteUserToChat = function (user, chatWindow) {
                chatModel.Client.inviteUserToChatRoom(user, chatWindow.room);
                if (!chatWindow.roster[user.jid]) {
                    chatWindow.roster[user.jid] = user;
                }
            };
            chatModel.processChatMessage = function (messageText, chatWindow) {
                if (messageText == EntityVO.CHATOPS_DETAILS || messageText == EntityVO.CHATOPS_KNOWLEDGE
                    || messageText == EntityVO.CHATOPS_SIMILARINCIDENTS || messageText == EntityVO.CHATOPS_SWARM || messageText == EntityVO.CHATOPS_TOOLS) {
                    chatSwarm.processChatMessage(messageText, chatWindow).then(function (response) {
                        chatModel.sendChatMessage(response, chatWindow.room);
                    }, function (result) {
                        chatModel.sendChatMessage(EntityVO.CHATOPS_ERROR, chatWindow.room);
                    });
                }
                else {
                    chatModel.sendChatMessage(messageText, chatWindow.room);
                }
            };
            chatModel.generateChatWindowByRoomId = function (id) {
                if (!id)
                    return $q.when(1);
                return chatModel.Client.joinChat(id).then(function (room) {
                    var chatConfig = { room: room, roster: {}, isLoading: true }, chatWindow = chatModel.createChatWindowInstance(chatConfig);
                    var participantPromise = chatModel.getParticipantsProfiles(chatWindow), parentPromise = chatModel.getRoomAdditionalInfo(chatWindow);
                    $q.all([participantPromise, parentPromise]).finally(function () {
                        chatWindow.isLoading = false;
                        if (!chatWindow.parent && chatWindow.assignedTo) {
                            var parent = ticketModel.cache[chatWindow.assignedTo.objectId];
                            if (parent) {
                                chatWindow.parent = parent;
                            }
                        }
                    });
                    chatModel.activeChatRooms.push(chatWindow);
                    return chatWindow;
                });
            };
            chatModel.sendChatMessage = function (message, room) {
                var nickname = room.client.nick;
                room.message(nickname, message, null, 'groupchat');
            };
            chatModel.getParticipantsProfiles = function (chatWindow) {
                var room = chatWindow.room, requestProfiles = [];
                _.each(room.roster, function (user) {
                    var userJID = Strophe.getNodeFromJid(user.jid), cachedProfile = chatModel.cachedProfiles[userJID];
                    if (userJID == chatModel.currentUser.jid) {
                        chatWindow.roster[userJID] = chatModel.currentUser;
                        return;
                    }
                    if (cachedProfile && (cachedProfile.fullName || cachedProfile.displayName)) {
                        chatWindow.roster[userJID] = chatModel.cachedProfiles[userJID];
                    }
                    else {
                        requestProfiles.push(userJID);
                    }
                });
                if (requestProfiles.length > 0) {
                    chatModel.getUserProfileByJID(requestProfiles).then(function () {
                        $timeout(function () {
                            _.each(requestProfiles, function (profileJID) {
                                chatWindow.roster[profileJID] = chatModel.cachedProfiles[profileJID];
                            });
                        });
                    });
                }
            };
            chatModel.getRoomAdditionalInfo = function (chatWindow) {
                var room = chatWindow.room, chatHistory = chatModel.pendingChatRoomMessages[chatWindow.id];
                if (chatHistory) {
                    !chatWindow.messages ? chatWindow.messages = [] : angular.noop();
                    _.each(chatHistory, function (historyItem) {
                        if (historyItem.skipped) {
                            var message = chatModel.createChatMessageInstance(historyItem.message, historyItem.roomName);
                        }
                        chatWindow.messages.push(message || historyItem);
                    });
                    chatModel.pendingChatRoomMessages[chatWindow.id] = null;
                }
                chatWindow.loadingAssignments = true;
                chatModel.Client.getRoomAssignments(room)
                    .then(function (resp) {
                    if (resp.assignmentData && !_.isEmpty(resp.assignmentData)) {
                        chatWindow.assignedTo = resp.assignmentData;
                        return chatModel.fillRoomParentData(chatWindow, resp.assignmentData);
                    }
                    else
                        chatWindow.loadingAssignments = false;
                    return $q.when(1);
                })
                    .catch(function () {
                    chatWindow.loadingAssignments = false;
                });
                //No need to show spinner while conversation assignment is loading
                return $q.when(1);
            };
            chatModel.fillRoomParentData = function (chatWindow, parentInfo) {
                var assignmentPromise;
                if (parentInfo.objectType == EntityVO.TYPE_ASSET) {
                    assignmentPromise = assetModel.getAssetDetailsByID(parentInfo.objectId, parentInfo.classId)
                        .then(function () {
                        chatWindow.parent = assetModel.assetDetails;
                        return assetModel.assetDetails;
                    });
                }
                else {
                    parentInfo.chatWindow = chatWindow;
                    assignmentPromise = ticketModel.getTicket(parentInfo.objectId, parentInfo.objectType)
                        .then(function () {
                        if (chatWindow) {
                            chatWindow.parent = ticketModel.cache[parentInfo.objectId];
                        }
                        return ticketModel.cache[parentInfo.objectId];
                    });
                }
                return assignmentPromise.finally(function () { chatWindow.loadingAssignments = false; });
            };
            chatModel.showNotification = function (chatWindow) {
                var senderJID = chatWindow.inviterJID, senderProfile = chatModel.cachedProfiles[senderJID] || {};
                if (senderProfile.fullName || senderProfile.displayName) {
                    var inviterName = senderProfile.fullName || senderProfile.displayName, text = $filter('i18n')('chat.invitationMessage', inviterName);
                }
                else {
                    var inviter = _.find(chatWindow.participants, function (user) {
                        var userJID = Strophe.getNodeFromJid(user.jid);
                        return (userJID == senderJID);
                    }), inviterNick = inviter.nick.split("_").join(" ");
                    text = $filter('i18n')('chat.invitationMessage', inviterNick);
                }
                systemAlertService.success({ text: text, icon: "icon-comments", clear: true, hide: 10000, click: (function () { this.isOpened = true; }).bind(chatWindow) });
            };
            chatModel.getCurrentStateTicketData = function (stateId) {
                return ticketModel.cache[stateId];
            };
            chatModel.saveChatLogToTicketWorknote = function (chatWindow, parentTicket) {
                //					if(chatWindow.parent && (parentTicket.id == chatWindow.parent.id)){
                if (parentTicket.reconciliationId) {
                    return chatModel.Client.saveChatLogToTicketWorknote(chatWindow.room, parentTicket.reconciliationId, parentTicket.ticketType, parentTicket.classId);
                }
                return chatModel.Client.saveChatLogToTicketWorknote(chatWindow.room, parentTicket.id, parentTicket.type);
            };
            chatModel.openChatWindow = function (chatWindow) {
                if (chatWindow.hasOwnProperty('isOpened')) {
                    chatWindow.isOpened = true;
                }
                return chatWindow;
            };
            chatModel.leaveRoomAndDestroyChatWindow = function (chatWindow) {
                chatModel.Client.destroyChatRoom(chatWindow.room);
                chatModel.removeChatFromActiveList(chatWindow);
                chatModel.Client.removeRoosterItemByJID(chatWindow.room.name);
            };
            chatModel.leaveConversation = function (chatWindow) {
                chatModel.Client.leaveChatRoom(chatWindow.room);
                chatModel.removeChatFromActiveList(chatWindow);
                chatModel.Client.removeRoosterItemByJID(chatWindow.room.name);
            };
            chatModel.removeChatFromActiveList = function (chatWindow) {
                var index = chatModel.activeChatRooms.indexOf(chatWindow);
                if (index >= 0) {
                    chatModel.activeChatRooms.splice(index, 1);
                }
            };
            /**
             * These Callbacks are being triggered from chat-service
             * */
            chatModel.chatEventHandlers = {
                connectionState: function (status) {
                    chatModel.connected = status == 'connected' ? true : false;
                },
                presence: function (jid, status, manualStatus) {
                    $timeout(function () {
                        var userId = jid.split("@")[0];
                        if (userId == chatModel.Client.conn.authcid && (jid != chatModel.Client.conn.jid)) {
                            if (manualStatus && (manualStatus != chatModel.currentUser.manualStatus)) {
                                chatModel.currentUser.available = status;
                                chatModel.currentUser.manualStatus = manualStatus;
                                chatModel.Client.setUserPresence(status);
                            }
                            return;
                        }
                        if (chatModel.cachedProfiles[userId]) {
                            chatModel.cachedProfiles[userId].available = status;
                        }
                        else {
                            chatModel.cachedProfiles[userId] = { available: status };
                        }
                    });
                },
                invite: function (invite) {
                    var from = invite.from, inviterJID = from.split("@")[0];
                    chatModel.Client.joinChat(invite.roomId).then(function (room) {
                        var chatConfig = { room: room, roster: {}, inviterJID: inviterJID, isLoading: true }, chatWindow = chatModel.createChatWindowInstance(chatConfig);
                        var participantsPromise = chatModel.getParticipantsProfiles(chatWindow), parentPromise = chatModel.getRoomAdditionalInfo(chatWindow);
                        $q.all([participantsPromise, parentPromise])
                            .finally(function () {
                            chatWindow.isLoading = false;
                            $timeout(function () {
                                chatModel.showNotification(chatWindow);
                                chatModel.activeChatRooms.push(chatWindow);
                            });
                            chatModel.Client.addToRoster(room.name);
                        });
                    });
                },
                message: function (messageData, roomName) {
                    var newMessage = chatModel.createChatMessageInstance(messageData, roomName), chatWindow = newMessage ? newMessage.chatWindow : null;
                    if (!chatWindow) {
                        chatModel.pendingChatRoomMessages[roomName] ? chatModel.pendingChatRoomMessages[roomName].push(newMessage) : chatModel.pendingChatRoomMessages[roomName] = [newMessage];
                        return true;
                    }
                    $timeout(function () {
                        chatWindow.messages ? chatWindow.messages.push(newMessage) : chatWindow.messages = [newMessage];
                    });
                },
                history: function (message, roomName) {
                    var newMessage = chatModel.createChatMessageInstance(message, roomName), chatWindow = newMessage.chatWindow;
                    if (!chatWindow) {
                        chatModel.pendingChatRoomMessages[roomName] ? chatModel.pendingChatRoomMessages[roomName].push(newMessage) : chatModel.pendingChatRoomMessages[roomName] = [newMessage];
                    }
                    else {
                        $timeout(function () {
                            chatWindow.messages ? chatWindow.messages.push(newMessage) : chatWindow.messages = [newMessage];
                        });
                    }
                },
                roomAutoJoin: function (room) {
                    var chatConfig = { room: room, roster: {}, isLoading: true }, chatWindow = chatModel.createChatWindowInstance(chatConfig);
                    var participantPromise = chatModel.getParticipantsProfiles(chatWindow);
                    var parentPromise = chatModel.getRoomAdditionalInfo(chatWindow);
                    $q.all([participantPromise, parentPromise]).finally(function () {
                        chatWindow.isLoading = false;
                    });
                    chatModel.activeChatRooms.push(chatWindow);
                },
                roomAutoLeave: function (room) {
                    var text = $filter('i18n')('chat.popup.systemMessage.leaveChatRoom.self');
                    var chatWindow = _.find(chatModel.activeChatRooms, { id: room.name });
                    if (window.opener) {
                        chatWindow.inactiveRoom = true;
                    }
                    if (chatWindow) {
                        chatWindow.inactiveRoomReason = text;
                        var index = chatModel.activeChatRooms.indexOf(chatWindow);
                        if (index >= 0) {
                            chatModel.activeChatRooms.splice(index, 1);
                        }
                    }
                    return room.name;
                },
                chatRoomChanges: function (room, changes) {
                    if (changes) {
                        var chatWindow = _.find(chatModel.activeChatRooms, { id: (room ? room.name : changes.data.roomId) });
                        if (changes.type == 'connection') {
                            chatWindow.loadingAssignments = true;
                            chatModel.fillRoomParentData(chatWindow, changes.data)
                                .then(function () {
                                var msg = generateAssignmentUpdatesMessage(chatWindow, changes);
                                $timeout(function () {
                                    chatWindow.messages.push(msg);
                                });
                            });
                        }
                        else if (changes.type == 'disconnection') {
                            changes.parent = _.clone(chatWindow.parent);
                            var msg = generateAssignmentUpdatesMessage(chatWindow, changes);
                            $timeout(function () {
                                chatWindow.messages.push(msg);
                            });
                            if (chatWindow.parent) {
                                chatWindow.parent = null;
                            }
                        }
                        else if (changes.type == 'roster') {
                            var userJid = Strophe.getBareJidFromJid(changes.data.jid), message = chatModel.createChatMessageInstance({ eventType: changes.data.eventType, author: { jid: userJid },
                                type: 'system' }, changes.data.roomId);
                            if (!chatWindow) {
                                if (chatModel.pendingChatRoomMessages[changes.data.roomId]) {
                                    chatModel.pendingChatRoomMessages[changes.data.roomId].push(message);
                                }
                                else {
                                    chatModel.pendingChatRoomMessages[changes.data.roomId] = [message];
                                }
                            }
                            else {
                                $timeout(function () {
                                    if (changes.data.eventType == 'enter') {
                                        chatWindow.participants = _.clone(chatWindow.room.roster);
                                    }
                                    chatWindow.messages ? chatWindow.messages.push(message) : chatWindow.messages = [message];
                                });
                            }
                        }
                        else if (changes.type == 'destroy' && chatWindow) {
                            if (room) {
                                var chatOwner = chatWindow.roomOwner || _.find(chatWindow.participants, { affiliation: 'owner' }), chatOwnerId = chatOwner.jid.split("@")[0], chatOwnerProfile = chatWindow.roster[chatOwnerId], ownerName = chatOwnerProfile ? "" + (chatOwnerProfile.displayName || chatOwnerProfile.firstName + " " + chatOwnerProfile.lastName) : chatOwner.nick.replace("_", " "), text = $filter('i18n')("chat.ownerLeave.notification", ownerName);
                                systemAlertService.success({ text: text, icon: "icon-comments", clear: true, hide: 10000 });
                                chatWindow.inactiveRoomReason = text;
                            }
                            $timeout(function () {
                                chatWindow.inactiveRoom = true;
                                chatWindow.isOpened = false;
                                var index = chatModel.activeChatRooms.indexOf(chatWindow);
                                (index >= 0) ? chatModel.activeChatRooms.splice(index, 1) : angular.noop();
                                if (window.opener)
                                    window.close();
                            });
                        }
                    }
                },
                rosterUpdates: function (updates) {
                    var deletedItems = updates.removed;
                    deletedItems.length && handleItemsDeletedFromRoster(deletedItems);
                }
            };
            chatModel.generateRosterSummary = function (chatWindow) {
                if (chatWindow.generateRosterSummary) {
                    return chatWindow.generateRosterSummary();
                }
            };
            chatModel.getArchivedConversationDetails = function (conv) {
                var roomId = conv.mucJid;
                return chatModel.Client.getArchivedConversationById(conv.id)
                    .then(function (resp) {
                    var conversationJSON, conversationMessages = [];
                    try {
                        conversationJSON = JSON.parse(resp);
                    }
                    catch (e) {
                        conversationJSON = {};
                    }
                    if (resp) {
                        var conversation = conversationJSON.messages || [];
                        _.each(conversation, function (msg, index, context) {
                            if (index > 0) {
                                var prevMsg = context[index - 1];
                                if (prevMsg && ((prevMsg.sentDate == msg.sentDate || prevMsg.body == msg.body) && prevMsg.fromJid == msg.fromJid && prevMsg.event && msg.event))
                                    return;
                            }
                            if (msg.event || (roomId == msg.fromJid && roomId == msg.toJid)) {
                                msg.type = 'system';
                                if (msg.body.indexOf("disconnection") >= 0) {
                                    msg.eventType = 'disconnected';
                                    msg.parent = msg.body.match(/[^{}]+(?=\})/g);
                                }
                                else if (msg.body.indexOf("connection") >= 0) {
                                    msg.eventType = 'connected';
                                    msg.parent = msg.body.match(/[^{}]+(?=\})/g);
                                }
                                else {
                                    msg.eventType = "other";
                                    msg.text = msg.body;
                                }
                                if (msg.parent) {
                                    msg.parent = JSON.parse("{" + msg.parent + "}");
                                    if (msg.parent.connectorsJid == chatModel.currentUser.jid)
                                        msg.senderProfile = chatModel.currentUser;
                                    else
                                        msg.senderProfile = chatModel.cachedProfiles[msg.parent.connectorsJid];
                                }
                            }
                            else {
                                if (msg.fromJid != chatModel.currentUser.jid)
                                    msg.senderProfile = chatModel.cachedProfiles[msg.fromJid];
                                else
                                    msg.senderProfile = chatModel.currentUser;
                            }
                            var message = convertArchiveItemToChatMessage(msg);
                            if (msg.parent)
                                chatModel.fillRoomParentData(message, msg.parent);
                            conversationMessages.push(message);
                        });
                        conversationMessages = _.sortBy(conversationMessages, 'created');
                    }
                    return conversationMessages;
                });
            };
            chatModel.getConversationsHistory = function (start, limit) {
                var params = { start: (start || 0), limit: (limit || 100) };
                return chatModel.Client.requestConversationsHistoryForCurrentUser(params)
                    .then(function (history) {
                    if (!history) {
                        return $q.when(1);
                    }
                    return processConversationHistory(history);
                });
            };
            function generateAssignmentUpdatesMessage(chatWindow, assignInfo) {
                var type = (assignInfo.type == 'connection') ? 'connected' : 'disconnected', userJid = assignInfo.data ? assignInfo.data.connectorsJid : '', userProfile = (userJid == chatModel.currentUser.jid) ? chatModel.currentUser : chatModel.cachedProfiles[userJid], parent = chatWindow.parent ? _.clone(chatWindow.parent) : assignInfo.parent;
                var settings = { author: userProfile, type: 'system', created: new Date().getTime(), eventType: type, parent: parent };
                return new ChatMessageVO().build(settings);
            }
            function processConversationHistory(historyItems) {
                console.log("Processing History: ", historyItems);
                var chatHistory = { requestProfiles: [], requestTickets: [], pendingTicketDetails: [] }, chatHistoryArr = [];
                _.map(historyItems, function (item) {
                    if (item.conversation.messagesCount == 0 || item.conversation.participants.length < 2) {
                        return;
                    }
                    var id = item.conversation.id, buildData = angular.extend(item.conversation, { connection: item.connection });
                    buildData.participants = _.without(buildData.participants, chatModel.currentUser.jid);
                    chatHistory[id] = new ChatHistoryItemVO().build(buildData);
                    chatHistoryArr.push(chatHistory[id]);
                    if (item.connection) {
                        chatHistory[id].parent = item.connection;
                        if (item.connection.objectType == EntityVO.TYPE_SERVICEREQUEST || item.connection.objectType == EntityVO.TYPE_ASSET) {
                            chatModel.fillRoomParentData(chatHistory[id], item.connection).then(function (parentData) {
                                chatHistory[id].parent = parentData;
                            });
                        }
                        else {
                            chatHistory.requestTickets = _.union(chatHistory.requestTickets, [{ uuid: item.connection.objectId, type: item.connection.objectType }]);
                            chatHistory.pendingTicketDetails.push(chatHistory[id]);
                        }
                    }
                    chatHistory.requestProfiles = _.union(chatHistory.requestProfiles, chatHistory[id].participants);
                });
                if (chatHistory.requestProfiles.length > 0) {
                    chatModel.getUserProfileByJID(chatHistory.requestProfiles, true).then(function () {
                        chatHistory.requestProfiles = null;
                        _.each(chatHistoryArr, function (chatHistoryItem) {
                            chatHistoryItem.fillRoster(chatModel.cachedProfiles);
                        });
                    });
                }
                if (chatHistory.requestTickets.length > 0) {
                    chatModel.Client.getTicketDetailsBulk(chatHistory.requestTickets)
                        .then(function (ticketDetails) {
                        chatHistory.requestTickets = null;
                        _.each(chatHistory.pendingTicketDetails, function (chatHistoryItem) {
                            var parentTicket = ticketDetails[chatHistoryItem.parent.objectId][0];
                            parentTicket ? chatHistoryItem.parent = parentTicket : angular.noop();
                            ticketModel.cache[chatHistoryItem.parent.objectId] = parentTicket;
                        });
                        chatHistory.pendingTicketDetails = [];
                    });
                }
                return { obj: chatHistory, arr: chatHistoryArr };
            }
            function convertArchiveItemToChatMessage(data) {
                var newMessage = "";
                if (chatSwarm.checkIfChatOpsMessage(data.body)) {
                    var message = { "text": data.body, "created": data.sentDate };
                    newMessage = chatSwarm.formatChatMessage(newMessage, message, null, data.senderProfile, true);
                }
                else if (data.body != (EntityVO.CHATOPS_SWARM) && data.body.startsWith(EntityVO.CHATOPS_SWARM) && chatSwarm.checkIfJson(data.body.substring(6))) {
                    try {
                        var messageText = data.body.substring(6);
                        var fullData = JSON.parse(messageText);
                        var json = JSON.parse(fullData.participants);
                        for (var i = 0; i < json.length; i++) {
                            var personDetailsSelf = json[i];
                            if (data.senderProfile != null && data.senderProfile.hasOwnProperty("fullName") && personDetailsSelf[0].fullName == data.senderProfile.fullName) {
                                json.splice(i, 1);
                                break;
                            }
                        }
                        for (var p = 0; p < json.length; p++) {
                            var personDetails = json[p];
                            chatModel.checkUserAvailability(personDetails[0].jid);
                            try {
                                json[p].available = chatModel.cachedProfiles[personDetails[0].jid].available;
                            }
                            catch (e) {
                                json[p].available = "offline";
                            }
                        }
                        fullData.participants = json;
                        newMessage = new ChatMessageDataVO()
                            .build({
                            created: data.sentDate,
                            data: fullData,
                            author: data.senderProfile,
                            type: 'swarmPeopleDetails',
                            fromHistory: true,
                            chatWindow: null
                        });
                    }
                    catch (e) {
                        newMessage = new ChatMessageDataVO()
                            .build({
                            created: data.sentDate,
                            data: [],
                            author: data.senderProfile,
                            type: 'swarmPeopleDetails',
                            fromHistory: true,
                            chatWindow: null
                        });
                    }
                }
                else {
                    var messageSettings = { text: data.text || data.body, author: data.senderProfile, type: data.type || 'chat', created: data.sentDate, eventType: data.eventType };
                    data.parent ? messageSettings.parent = data.parent : angular.noop();
                    newMessage = new ChatMessageVO().build(messageSettings);
                }
                return newMessage;
            }
            function handleItemsDeletedFromRoster(items) {
                _.each(items, function (jid) {
                    var chatWindow = _.find(chatModel.activeChatRooms, { id: jid });
                    if (chatWindow) {
                        var index = chatModel.activeChatRooms.indexOf(chatWindow);
                        if (index >= 0) {
                            $timeout(function () {
                                chatModel.activeChatRooms.splice(index, 1);
                            });
                        }
                    }
                });
            }
            return chatModel;
        }
    ]);
}());