const fs = require('fs');
const sharp = require('sharp');

const CHAT = Symbol.for("net.nextrek.chattrek");

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: {},

        socketsMap: {},

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

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

            this.addUser(user, socket);

            return user;
        },

        addUser(user, socket) {
            this.usersMap[user.room] = user;
            this.socketsMap[user.room] = socket;
            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];
            delete this.socketsMap[user.room];
            return this.leaveRoom(user, user);
        },
        
        getUsersByRole(role) {
            return this.users.filter((user) => {
                return user.role === role
            });
        },
        
        countUsersByRole(role) {
            this.getUsersByRole(role).length
        },
        
        isUserInRoom(host, guest) {
            return this.rooms[host.role][host.room].indexOf(guest) > - 1;
        },

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

        leaveRoom(host, guest) {
            /**
             * tbd: check leaving permissions
             */
            const promises = [];
            if (host.room === guest.room) {
                // host leaving his own room means throw out guest(s)
                if (this.rooms[host.role][host.room]) {
                    this.rooms[host.role][host.room].forEach(user => {
                        if (this.socketsMap[user.room]) {
                            promises.push(new Promise(resolve => {
                                resolve(this.socketsMap[user.room]);
                            }));
                        }
                    });
                }
                delete this.rooms[host.role][host.room];
            } else {
                // operators are only allowed to leave other operators' rooms
                if (host.role === this.ROLES.OPERATOR) {
                    const ix = this.rooms[host.role][host.room].indexOf(guest);
                    this.rooms[host.role][host.room].splice(ix, 1);
                }
            }
            return promises;
        },

        storeImage(data, user) {
            return new Promise((resolve, reject) => {
                const matchExtension = /^data:image\/(\w+)/i.exec(data.content);
                if (matchExtension === null) {
                    reject('Invalid data type');
                }
    
                const extension = matchExtension[1];
                const filename = `${user.room}_${Date.now()}.${extension}`;
    
                console.log('user ' + user.room + ' saving file name: ' + filename);
    
                const dir = `./public/imagesFull/${user.room}`;
                const dir2 = `./public/imagesThumb/${user.room}`;
                if (!fs.existsSync(dir)){
                    fs.mkdirSync(dir);
                }
                if (!fs.existsSync(dir2)){
                    fs.mkdirSync(dir2);
                }
    
                const base64Data = data.content.replace(/^data:image\/\w+;base64,/, '');
    
                fs.writeFile(dir +"/"+filename, base64Data, 'base64', function(err) {
                    console.log(err);
                });
                
                let imgBuffer = Buffer.from(base64Data, 'base64');
               
                sharp(imgBuffer)
                    .resize(160, 120)
                    .toFile(dir2 + "/" + filename, (err, info) => {
                        resolve(filename);
                    });
            })
        },

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

        message(data, room, from) {
            return new Promise((resolve, reject) => {
                switch (data.contentType) {
                    case 'IMAGE':
                        this.storeImage(data, from)
                        .then(filename => {
                            resolve({
                                from,
                                room: room,
                                content: filename,
                                contentType: data.contentType
                            });
                        })
                        .catch(error => {
                            data.content = error;
                        });
                        break;
                
                    default:
                        resolve({
                            from,
                            room: room,
                            content: data.content,
                            contentType: data.contentType
                        });
                        break;
                }
            });
        }
    };
}

var singleton = {};

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

Object.freeze(singleton);


module.exports = singleton;