const express = require("express");
const http = require('http');
const socketIO = require('socket.io');
const mysql = require("mysql");
const util = require('util');

const app = express();
const server = http.createServer(app);
const io = socketIO(server);

// io.attach(server, {
//     pingInterval: 10000,
//     pingTimeout: 5000,
//     cookie: false
// });


const PORT = process.env.PORT || 5005;

let numUsers = 0;

app.use((request, result, next) => {
    result.setHeader("Access-Control-Allow-Origin", "*");
    next();
});

app.use(express.urlencoded({ extended: false }));
app.use(express.json());

const connection = mysql.createConnection({
    "host": "localhost",
    "user": "root",
    "password": "",
    "database": "db_t4b"

    // "host": "localhost",
    // "user": "tech4bizuserone",
    // "password": "Mypassword02#",
    // "database": "tech4biz"
});

connection.connect(function (error) {
    if (error) console.log(error);
    console.log("DB Connected!")
    console.log('==============');

});


io.on("connection", (socket) => {
    let addedUser = true;
    //console.log("User connected:-", socket.id);

    socket.on('disconnect', () => {
        if (addedUser) {
            --numUsers;
        }
    });

    socket.on('user__connected', (data) => {
        if (data.socket && data.email) {
            let checkUser = "SELECT * FROM `chat_users` WHERE `email` = ?";
            connection.query(checkUser, [data.email], (error, user) => {
                if (error) {
                    io.to(data.socket).emit('server__error', `I'm Offline!`);
                } else {
                    //io.to(data.socket).emit('server__error', `Hello `);
                    let isExists = user.length;
                    console.log(isExists)
                    if (isExists > 0) {
                        let updateSocketID = connection.query("UPDATE `chat_users` SET `socket` = ? WHERE `email` = ?", [data.socket, data.email], (error, result) => {
                            if (error) {
                                io.to(data.socket).emit('server__error', `I'm Offline!`);
                            } else {
                                io.to(data.socket).emit('user__connected', `Welcome back ${data.email}`);
                            }
                        });
                    } else {
                        let addUser = "INSERT INTO `chat_users` (`email`, `socket`) VALUES (?, ?)";
                        connection.query(addUser, [data.email, data.socket], (error, result) => {
                            if (error) {
                                io.to(data.socket).emit('server__error', `I'm Offline!`);
                            } else {
                                io.to(data.socket).emit('user__connected', `Welcome ${data.email}, Get Started with us`);
                            }
                        });
                        //io.to(data.socket).emit('user__connected', `Welcome ${data.email}, Get Started with us`);
                    }
                }
            });
        } else {
            io.to(data.socket).emit('server__error', `Refresh and Try again`);
        }
    });


    socket.on('send__message', (data) => {
        if (data.from && data.to && data.msg && data.socket) {
            let storeMsg = "INSERT INTO `chat` (`from`, `to`, `message`, `send_by`) VALUES (?, ?, ?, ?)";
            connection.query(storeMsg, [data.from, data.to, data.msg, data.send_by], (error, result) => {
                if (error) {
                    console.log(error)
                    io.to(data.socket).emit('server__error', `I'm Offline!`);
                } else {
                    io.to(data.socket).emit('send__message', data.msg);

                    let getAdminSocket = "SELECT `socket` FROM `chat_users` WHERE `email` = ?";
                    connection.query(getAdminSocket, ['admin'], (error, admin) => {
                        if (error) {
                            console.log(error);
                        } else {
                            if (admin.length > 0) {
                                let adminSocket = admin[0].socket;
                                console.log(adminSocket);
                                //io.to(adminSocket).emit('receive__user__message', data);

                                let getUserID = "SELECT `id` FROM `chat_users` WHERE `email` = ? LIMIT 1";
                                connection.query(getUserID, [data.from], (error, user) => {
                                    if (error) {
                                        console.log('Error while Fetching UserID on send__message')
                                    } else {
                                        let userID = user[0].id;
                                        data.user_id = userID;
                                        io.to(adminSocket).emit('receive__user__message', data);
                                    }
                                });
                            }
                        }
                    })
                }
            });
        } else {
            io.to(data.socket).emit('server__error', `Refresh and Try again`);
        }
    });

    socket.on('send__message__toAdmin', (data) => {
        if (data.from && data.to && data.msg && data.socket) {
            let storeMsg = "INSERT INTO `chat` (`from`, `to`, `message`, `send_by`) VALUES (?, ?, ?, ?)";
            connection.query(storeMsg, [data.from, data.to, data.msg, data.send_by], (error, result) => {
                if (error) {
                    console.log(error)
                    //io.to(data.socket).emit('server__error', `I'm Offline!`);
                } else {
                    io.to(data.socket).emit('send__message__toAdmin', data.msg);

                    let getUserSocket = "SELECT `socket` FROM `chat_users` WHERE `email` = ?";
                    connection.query(getUserSocket, [data.to], (error, user) => {
                        if (error) {
                            console.log(error);
                        } else {
                            if (user.length > 0) {
                                let userSocket = user[0].socket;
                                console.log(userSocket);
                                io.to(userSocket).emit('receive__admin__message', data);
                            }
                        }
                    })
                }
            });
        } else {
            io.to(data.socket).emit('server__error', `Refresh and Try again`);
        }
    });


    socket.on('fetch__users', async (data) => {

        if (data.email && data.socket) {
            // io.to(data.socket).emit('fetch__users', data);
            const query = util.promisify(connection.query).bind(connection);
            let obj = [];

            await (async () => {
                try {
                    const rows = await query("SELECT * FROM `chat_users` WHERE `email` <> 'admin'");
                    if (rows) {
                        for (let i = 0; i < rows.length; i++) {

                            obj.push({
                                "id": rows[i].id,
                                "email": rows[i].email,
                                "socket": rows[i].socket,
                                "created_at": rows[i].created_at,
                                "updated_at": rows[i].updated_at,
                            });

                            try {
                                let getLastMessage = "SELECT * FROM `chat` WHERE `from` = ? AND `to` = ? OR  `from` = ? AND `to` = ? ORDER BY `id` DESC LIMIT 1";
                                let lm = await query(getLastMessage, [rows[i].email, 'admin', 'admin', rows[i].email]);
                                if (lm.length > 0) {
                                    obj[i].last_msg = lm[0].message;
                                }
                                else {
                                    obj[i].last_msg = '';
                                }
                            } catch (e) {
                                console.log(e.sqlMessage);
                            }
                        }

                    }
                } catch (e) {
                    console.log(e.sqlMessage);
                }
                // finally {
                //     connection.end();
                // }
            })();

            io.to(data.socket).emit('fetch__users', obj);

        }

    });

    socket.on('open__chatBox', (data) => {

        if (data.email && data.socket) {
            let fetchMessages = "SELECT * FROM `chat` WHERE `from` = ? AND `to` = ? OR `from` = ? AND `to` = ? ORDER BY `id`";
            connection.query(fetchMessages, [data.email, 'admin', 'admin', data.email], (error, messages) => {
                if (error) {
                    console.log('Error while fetching Messages');
                } else {
                    let getUserID = "SELECT `id` FROM `chat_users` WHERE `email` = ? LIMIT 1";
                    connection.query(getUserID, [data.email], (error, user) => {
                        if (error) {
                            console.log('Error while Fetching UserID on open__chatBox')
                        } else {
                            let userID = user[0].id;
                            console.log({ data: data, msg: [], user_id: userID })
                            io.to(data.socket).emit('open__chatBox', { data: data, msg: messages, user_id: userID });
                        }
                    });
                    io.to(data.socket).emit('open__chatBox', { data: data, msg: messages });
                }
            });

        }
    });

    socket.on('refreshUsers', (data) => {
        console.log(data)
        if (data.email) {
            let getAdminSocket = "SELECT `socket` FROM `chat_users` WHERE `email` = 'admin'";
            connection.query(getAdminSocket, [], (error, socket) => {
                if (error) {
                    console.log('Error while Fetching Admin Socket on refreshUsers');
                } else {
                    let adminSocket = socket[0].socket;
                    //io.to(adminSocket).emit('refreshUsers', data);
                }
            });

        }
    })


});

app.get('/fetchUsers', (req, res) => {

    let getUsers = "SELECT * FROM `chat_users` WHERE `email` <> 'admin';"
    connection.query(getUsers, [], (error, users) => {
        if (error) {
            res.status(500).json({
                'code': 500
            });
        } else {
            res.status(200).json({
                'code': 200,
                'users': users
            });
        }
    });

});

app.post('/checkUser', (req, res) => {

    let user = req.body.email;

    if (user) {
        let checkUser = "SELECT * FROM `chat` WHERE `from` = ?";
        connection.query(checkUser, [user], (error, user) => {
            let isExists = user.length;
            if (isExists > 0) {
                res.status(200).json({
                    'code': 200
                });
            } else {
                res.status(200).json({
                    'code': 404
                });
            }
        });
    } else {
        res.status(200).json({
            'code': 404
        });
    }

});


app.post('/storeMessages', (req, res) => {

    let msg = req.body.msg;
    let from = req.body.from;

    if (from && msg) {

        let to = 'admin';
        let insertMsg = "INSERT INTO `chat` (`from`, `to`, `message`) VALUES (?, ?, ?)";
        connection.query(insertMsg, [from, to, msg], (err, result) => {
            if (err) {
                return res.status(200).json({
                    'code': 500
                });
            }
            console.log(result);
            return res.status(200).json({
                'code': 200
            });
        });

    } else {
        return res.status(200).json({
            'code': 400
        });
    }

});


server.listen(PORT, () => {
    console.log(`Listening to port ${PORT}`);
});