const CHAT = Symbol.for("My.App.Namespace.chat");

var globalSymbols = Object.getOwnPropertySymbols(global);
var hasChat = (globalSymbols.indexOf(CHAT) > -1);

if (!hasChat) {
    global[CHAT] = {
        ROLES: {
            OPERATOR: 'OPERATOR',
            CUSTOMER: 'CUSTOMER'
        },

        DEFAULT_ROOMS: {
            OPERATORS: 'OPERATORS'
        },

        EVENTS: {
            CONNECTION: {
                OPEN: 'CONNECTION:OPEN',
                CLOSE: 'CONNECTION:CLOSE'
            },
            ROOM: {
                CREATED: 'ROOM:CREATED',
                JOIN: 'ROOM:JOIN',
                LEAVE: 'ROOM:LEAVE'
            },
            SEND: {
                MESSAGE: 'SEND:MESSAGE',
                IMAGE: 'SEND:IMAGE',
                ATTACHMENT: 'SEND:FILE',
                LINK: 'SEND:LINK'
            },
            OPERATORS: {
                LIST: {
                    UPDATE: 'OPERATORS:LIST:UPDATE'
                }
            },
            CUSTOMERS: {
                LIST: {
                    UPDATE: 'CUSTOMERS:LIST:UPDATE'
                }
            },
            ROOMS: {
                LIST: {
                    UPDATE: 'ROOMS:LIST:UPDATE'
                }
            }
        },

        ERRORS: {
            USER:
                {
                    NOT_FOUND: 'ERROR:USER:NOTFOUND'
                }
        },

        users: [],

        rooms: {
            CUSTOMER: {},
            OPERATOR: {}
        },

        isRoomAllowed(from, to) {
            if (from.role === _this.ROLES.OPERATOR) {

            }
        },

        usersMap: {},

        getUser(id) {
            const user = this.usersMap[id];
            return {
                id: user.id,
                name: user.name
            }
        },

        createUser(name, role, id) {
            const _this = this;
            const user = {
                name: name,
                role: role,
                room: id,
            }

            this.addUser(user);

            return user;
        },

        addUser(user) {
            this.usersMap[user.room] = user;
            this.users.push(user);
            this.rooms[user.role][user.room] = [];
        },

        deleteUser(user) {
            this.users.splice(this.users.indexOf(user), 1);
            delete this.usersMap[user.room];
        },
        
        getUsersByRole(role) {
            return this.users.filter((user) => {
                return user.role === role
            });
        },
        
        countUsersByRole(role) {
            this.getUsersByRole(role).length
        },
        
        isUserInRoom(owner, guest) {
            return this.rooms[owner.role][owner.room].indexOf(guest) > - 1;
        },

        joinOwnerRoom(owner, user) {
            if (user && user.role === this.ROLES.OPERATOR) {
                if (!this.isUserInRoom(owner, user) && !this.isUserInRoom(user, owner)) {
                    this.rooms[owner.role][owner.room].push(user);
                    return owner.room;
                } else {
                    return this.rooms[owner.role][owner.room] ? owner.room : user.room;
                }
            }
        },

        event(type, data) {
            return {
                type,
                data,
                ts: Date.now()
            }
        },

        message(data, room, from) {
            return {
                from,
                room: room,
                content: data.content,
                contentType: data.contentType
            }
        }
    };
}

var singleton = {};

Object.defineProperty(singleton, "instance", {
    get: function () {
        return global[CHAT];
    }
});

Object.freeze(singleton);


module.exports = singleton;