/**
 * 聊天组模型。
 */
"use strict";

let CONTENT_TYPES = require('../include/commons').CONTENT_TYPE;
let PLATFORMS = require('../include/commons').PLATFORM;

let BaseModel = require('./base.model');
let log = require("../util/log.js");
let modelUtil = require('../util/modelUtil');
let getui = require('getui');

let Patient = new require("../models/patient");
let Doctor = new require('../models/doctor');

let doctorRepo = require('../repository/doctor.repo.js');
let groupRepo = require('../repository/group.repo');
let gmRepo = require('../repository/group.msg.repo');
let nmRepo = require("../repository/notify.msg.repo");
let statsRepo = require("../repository/stats.msg.repo");
let objectUtil = require("../util/objectUtil.js");

class GroupMessage extends BaseModel {
    constructor() {
        super();
    }

    /**
     * 发送消息。
     *
     * @param message
     */
    sendMessage(message) {
        let self = this;
        gmRepo.isGroupMember(message.group, message.groupType, message.from, function (err, result) {
            if (err) {
                modelUtil.emitDbError(self.eventEmitter, 'Check group member failed', err);
                return;
            }

            if (result.length == 0) {
                modelUtil.emitDataNotFound(self.eventEmitter, 'Member with id "' + message.from + '" is not in group "' + message.group + '"');
                return;
            }

            // 保存群组消息
            gmRepo.save(message.from, message.group, message.at, message.contentType, message.content, function (err, insertedRow) {
                if (err) {
                    modelUtil.emitDbError(self.eventEmitter, 'Save group message failed', err);
                    return;
                }

                gmRepo.findOneMessage(insertedRow.insertId, function (err, groupMsg) {
                    if (err) {
                        modelUtil.emitDbError(self.eventEmitter, 'Save group message success, but return this message failed', err);
                        return;
                    }

                    // 关闭网络连接后执行后续操作
                    let feedback = Patient.fillMessages(groupMsg);
                    modelUtil.emitData(self.eventEmitter, feedback);

                    // 推送通知消息给群组成员
                    groupRepo.getMembers(message.group, message.groupType, function (err, members) {
                        if (err) {
                            log.error('Get group members failed: ', err);
                            return;
                        }

                        if (members.length == 0) {
                            log.warn('No members in group ', message.group,
                                message.groupType === GROUP_TYPE.AdminTeam ? " of admin team." : "of discussion group.");

                            return;
                        }

                        // 逐个推送通知，患者与医生推送方式不一样
                        for (let i = 0; i < members.length; i++) {
                            let member = members[i];
                            if (member.user_id === message.from) continue;

                            (function (userId) {
                                Patient.isPatientCode(userId,
                                    function () {
                                        Patient.sendMessage(userId, 2, feedback);
                                    },
                                    function () {
                                        Doctor.pushMessage(message, 'group_msg');

                                        // 更新用户组内消息摘要
                                        let at = message.at == userId ? 1 : 0;
                                        statsRepo.updateGroupChatSummary(userId,
                                            message.group,
                                            message.from,
                                            at,
                                            message.contentType,
                                            message.content,
                                            true,
                                            function (err, result) {
                                                if (err) console.log(err);
                                            });
                                    });
                            })(member.user_id);
                        }
                    });
                });

                // 更新组内统计信息
                statsRepo.updateGroupChatSummary(message.from, message.group, message.from, 0, message.contentType, message.content, false, function (err, result) {
                    if (err) log.error(err);
                });
            });
        });
    }

    /**
     * 获取组消息。
     */
    getMessages(groupId, memberId, contentType, msgStartId, msgEndId, count) {
        let self = this;
        gmRepo.findAllMessages(groupId, !contentType ? "1,2,3,5,6" : contentType, msgStartId, msgEndId, count, function (err, rows) {
            if (err) {
                modelUtil.emitDbError(self.eventEmitter, 'Get group message failed', err);
                return;
            }

            // 先给客户端返回数据
            let messages = GroupMessage.fillMessages(rows);
            modelUtil.emitData(self.eventEmitter, messages);

            // 清空统计信息
            statsRepo.clearGroupChatSummary(memberId, groupId, function (err, result) {
                if (err) console.log(err);
            });
        });
    }

    /**
     * 获取组内未读消息。
     * @param groupId
     */
    getUnreadMessages(groupId, memberId) {
        let self = this;
        statsRepo.getGroupChatSummary(memberId, groupId, function (err, summary) {
                if (err) {
                    modelUtil.emitDbError(self.eventEmitter, "Get unread group messages failed", err);
                    return;
                }

                let messages = {startId: 0, count: 0, records: []};
                if (summary.length == 0 || summary[0].new_msg_count === 0) {
                    modelUtil.emitData(messages);
                    return;
                }

                messages.count = summary[0].new_msg_count;
                gmRepo.findUnread(groupId, MAX_INT, messages.count, function (err, rows) {
                    if (err) {
                        modelUtil.emitDbError(self.eventEmitter, "Get unread group messages failed", err);
                        return;
                    }

                    let feedback = Patient.fillMessages(rows);
                    modelUtil.emitData(feedback);
                });
            }
        )
        ;
    }

    /**
     * 获取未读消息数量。
     *
     * @param memberId
     */
    getUnreadMessageCount(memberId) {
        let self = this;
        statsRepo.getGroupChatAllUnReadCount(memberId, function (err, result) {
            if (err) {
                modelUtil.emitDbError(self.eventEmitter, 'Get all unread messages failed', err);
                return;
            }

            let data = {
                userId: memberId,
                messageType: 2,
                newMessageCount: 0
            };

            if (result.length > 0) {
                for (let index = 0; index < result.length; index++) {
                    data.newMessageCount += result[index].new_msg_count;
                }
            }

            modelUtil.emitData(self.eventEmitter, data);
        });
    }

    /**
     * 获取特定群组消息统计情况.
     *
     * @param groupId
     * @param memberId
     */
    getChatSummary(groupId, memberId) {
        let self = this;
        statsRepo.getGroupChatSummary(memberId, groupId, function (err, result) {
            if (err) {
                modelUtil.emitDbError(self.eventEmitter, 'Get group stats failed', err);
                return;
            }

            let data = {
                userId: userId,
                from: "",
                groupId: groupId,
                atMe: 0,
                lastContentType: 1,
                lastContent: "",
                newMessageCount: 0,
                timestamp: 0
            };

            if (result.length > 0) {
                let row = result[0];
                data.from = row.from_uid;
                data.groupId = row.gid;
                data.atMe = row.at_me;
                data.lastContentType = row.last_content_type;
                data.lastContent = row.lastContent;
                data.newMessageCount = row.new_msg_count;
                data.timestamp = objectUtil.timestampToLong(row.timestamp)
            }

            modelUtil.emitData(self.eventEmitter, data);
        });
    }

    /**
     * 获取成员头像。
     *
     * @param groups 要获取的组ID列表。
     */
    getMemberAvatars(groups) {
        let self = this;
        let avatars = [];
        groupRepo.getMembersAvatar(groups, function (err, members) {
            if (err) {
                modelUtil.emitDbError(self.eventEmitter, "Get group member's avatar list failed", err);
                return;
            }

            var lastGroup;
            var lastGroupCode = '';
            for (var i = 0; i < members.length; ++i) {
                var member = members[i];
                var groupCode = member.g_code;
                if (lastGroupCode !== groupCode) {
                    lastGroupCode = groupCode;
                    lastGroup = {groupCode: groupCode, avatars: []};

                    if (lastGroupCode !== '') {
                        avatars.push(lastGroup);
                    }
                }

                lastGroup.avatars.push({
                    code: member.code,
                    name: member.name,
                    avatar: member.photo === null ? "" : member.photo,
                    role: member.type
                });
            }

            modelUtil.emitData(self.eventEmitter, avatars);
        });
    }
}

module.exports = GroupMessage;