var app     = require('express')();
var server  = require('http').Server(app);
var io      = require('socket.io')(server);

app.get('/', function (req, res) {
  res.send("Hello world");
});


var clients = {};
var Rooms = {};

// Function qui retourne les pseudos des utilisateurs d'une room.
function GetClientFromRoom(room) {
    var connectedClients = io.nsps["/"].adapter.rooms[room];
    var tmp_user = [];
    for(var a in connectedClients) {
        for(var b in clients) {
            if(a == b) {
                tmp_user.push(clients[b].login);
            }
        }
    }

    return tmp_user;
}

// Connexion a socket.io
io.on('connection', function (socket) {

    clients[socket.id] = {
        login : null,
        avatar : null,
        points : null,
        active_room : null
    }

    socket.on('setUser',function(req) {
        clients[socket.id].login = req.username;
        socket.emit("connectedUser",{username:req.username});
    });

    socket.on('resetUser', function(req) {
        clients[socket.id].login = null;
        socket.emit("disconnectUser",{message:null});
    });


    socket.on('createGame',function(req) {
        req.name = req.name.split(' ').join('_').toLowerCase().toString();
        if(Rooms[req.name] == undefined) {
            var tmp_password = (req.password === undefined || req.password === null) ? null : req.password;
            req.name = req.name.split(' ').join('_').toLowerCase();
            Rooms[req.name] = {
                name : req.name,
                administrator : socket.id,
                started : false,
                gameMode : req.gameMode,
                password : tmp_password,
                playerConnected : 1,
                playerMAX : req.playerMAX,
                team : {}
            }

            console.log("Game create with name "+req.name);

            socket.emit('connectLobby',{
                lobby: req.name,
                username: clients[socket.id].login,
                isAdmin : true,
                state: true
            });

            socket.broadcast.emit('setRooms',{rooms:Rooms[req.name],unique:true});

            socket.join(req.name);
            clients[socket.id].active_room = req.name;
        }
        else {
            console.log("client '"+clients[socket.id].login+"' failed to create a game!")
        }
    });

    function ConnectPlayer(roomID) {
        var RoomPlayerConnected = Rooms[roomID].playerConnected;
        var RoomPlayerConnected_After = Rooms[roomID].playerConnected + 1;

        if(RoomPlayerConnected_After <= Rooms[roomID].playerMAX) {
            console.log("client '"+clients[socket.id].login+"' is now connedted to the lobby "+roomID);
            socket.emit('connectLobby',{
                lobby: roomID,
                username: clients[socket.id].login,
                state: true
            });
            clients[socket.id].active_room = roomID;

            Rooms[roomID].playerConnected += 1
            var connectedClients = GetClientFromRoom(roomID);

            socket.emit('adduserToLobby',{userlist:connectedClients});
            socket.broadcast.emit('updateRooms',{
                roomID : roomID,
                playerConnected : Rooms[roomID].playerConnected,
                playerMAX : Rooms[roomID].playerMAX
            });
            socket.broadcast.to(roomID).emit('adduserToLobby',{userlist:clients[socket.id].login});

            socket.join(roomID);
        }
        else {
            console.log("client '"+clients[socket.id].login+"' fail connection to the lobby "+roomID);
            socket.emit('connectLobby',{state: false,err:"The game is full!"});
        }
    }

    socket.on('joinRoom',function(req) {
        if(Rooms[req.roomID] !== undefined) {

            if(Rooms[req.roomID].password == null) {
                ConnectPlayer(req.roomID);
            }
            else {
                console.log("client '"+clients[socket.id].login+"' requested password for room -> "+req.roomID);
                socket.emit('needPassword',{roomID:req.roomID});
            }

        }
    });

    socket.on('joinRoom_Password', function(req) {
        console.log("client '"+clients[socket.id].login+"' trying to join lobby with password");
        if(Rooms[req.roomID] != undefined) {
            if(Rooms[req.roomID].password == req.password) {
                ConnectPlayer(req.roomID);
            }
            else {
                socket.emit('invalidPassword',{});
            }
        }
        else {
            socket.emit('connectLobby',{state: false,err:"Server timed out."});
        }
    });

    // Function for testing and removing player from lobby. (or destroying empty lobby).
    function RemovePlayer() {
        var RoomExited = clients[socket.id].active_room;
        if(Rooms[RoomExited] != undefined) {
            var RoomPlayerConnected_After = Rooms[RoomExited].playerConnected - 1;

            // On vérifie que le lobby n'est pas vide, sinon on le supprime.
            if(RoomPlayerConnected_After <= 0) {
                Rooms[RoomExited] = undefined;
                console.log("destroying room "+RoomExited);
                io.sockets.emit('destroyRooms', {rooms:RoomExited});
            }
            else {
                socket.leave(RoomExited);
                clients[socket.id].active_room = null;

                console.log("client '"+clients[socket.id].login+"' leave the room -> "+RoomExited);
                socket.broadcast.to(RoomExited).emit('removeuserFromLobby',{name:clients[socket.id].login});
                if(Rooms[RoomExited].administrator == socket.id) {
                    // On définie un nouvelle administrator.
                    var connectedClients = io.nsps["/"].adapter.rooms[RoomExited];
                    for(var i in connectedClients) {
                        Rooms[RoomExited].administrator = i;
                        break;
                    }
                    console.log("room -> "+RoomExited+" switching Administrator for client -> "+clients[Rooms[RoomExited].administrator].login);
                    socket.broadcast.to(RoomExited).emit('newAdministrator',{userID:clients[Rooms[RoomExited].administrator].login});
                    io.to(Rooms[RoomExited].administrator).emit('adminAttribution', {});
                }
                Rooms[RoomExited].playerConnected -= 1;

                socket.broadcast.emit('updateRooms',{
                    roomID : RoomExited,
                    playerConnected : Rooms[RoomExited].playerConnected,
                    playerMAX : Rooms[RoomExited].playerMAX
                });
            }
        }
    }

    socket.on('exitRoom',function(req) {
        RemovePlayer();
        socket.emit('exitLobby',{});
    });

    socket.on('getRooms',function(req) {
        socket.emit('setRooms',{rooms:Rooms});
    });


    // Lorsque l'utilisateur ce déconnecte.
    socket.on('disconnect', function () {
        if(clients[socket.id].active_room != null) {
            RemovePlayer();
        }
        clients[socket.id] = undefined;
    });

});

server.listen(7076,"0.0.0.0");