const {LogType} = require('loguix') 
const wlog = new LogType("Server")

const fs = require("fs")
const path = require("path")
const {Server} = require('socket.io')
const {createServer} = require('http')
const session = require("../server/auth/Session")
const users = require("../server/auth/User")
const players = require("../player/Player")
const {Player} = require("../player/Player")
const discordBot = require("../discord/Bot")
const discordAuth = require("../server/auth/DiscordAuth")
const {Report} = require("../discord/ReportSender")
const Finder = require("../player/Finder")

const {__glob} = require("../utils/GlobalVars")
const playlists = require("../playlists/PlaylistManager")
const history = require("../playlists/History")
const lyrics = require("../lyrics/Lyrics")
const mediaBase = require("../discord/MediaBase")
const googleApis = require("../playlists/Google/OAuth2")
const youtubeApi = require("../playlists/Google/YoutubeList")

const configuration = require("../utils/Database/Configuration")
const { List } = require('../player/List')
const { restart } = require('../utils/Maintenance')
const { isAudioFile } = require('../utils/AudioBufferCheck')
const { Song } = require('../player/Song')
const { getMediaInformationFromUrl } = require('../media/MediaInformation')

const allConnectedUsers = new Array()
const guildConnectedUsers = new Map()
const UsersBySocket = new Map()

//TODO: Refactor this file to implement the fact that server can be joined and leaved and all the events are now handled, so guildId is not required for every event

function init() {
    
    wlog.step.init("server_init", "Initialisation du serveur Socket.IO")

    const httpServer = createServer()   
    const io = new Server(httpServer, {
        cors: {
            origin: "*"
        },
    })
    

    process.on("PLAYERS_UPDATE", () => {
        if(io) {
            // Get all players and send them to client subscribed to the guild
            for(var guild of discordBot.getGuilds().keys()) {
                const player = players.getPlayer(guild)
                if(player) {
                    if(!player.isConnected()) continue;
                    io.to(player.guildId).emit("/PLAYER/UPDATE", player.getState())
                    wlog.log("Envoi de l'état du player de la guilde : " + player.guildId + " à tous les utilisateurs connectés")
                }
            }
        }
    })

    process.on("USERS_UPDATE", () => {
        if(io) {
            // Get all players and send them to client subscribed to the guild
            for(var guild of discordBot.getGuilds().keys()) {
               if(guildConnectedUsers.has(guild)) {
                    io.to(guild).emit("/USERS/UPDATE", {"id": guild, "members": guildConnectedUsers.get(guild)} )
                    io.to("ADMIN").emit("ALL_USERS_UPDATE", allConnectedUsers)  
                    wlog.log("Envoi de la liste des utilisateurs connectés (" + guildConnectedUsers.get(guild).length +") à la guilde : " + guild + " à tous les utilisateurs connectés")
                }
            }
            io.sockets.emit("/USER/READY")
        }
    })

    io.on("connection", async (socket) => {
        var socketUser;

        // Make sure Discord Bot is loaded and make an interruption until it is loaded
        while(!await discordBot.isReady()) {
            wlog.warn("Attente de traitement : "+ socket.id + " : Le bot Discord n'est pas encore chargé, attente de 0.5 seconde... (Avoid Rate Limit)")
            await new Promise(resolve => setTimeout(resolve, 500))
        }

        wlog.log(`Connexion d'un client : ${socket.id}`)

        socket.on("disconnect", () => {
            handleDisconnect()
            wlog.log("Déconnexion du client : " + socket.id)
        })

        socket.on("error", (error) => {
            handleDisconnect()
            wlog.error("Erreur sur le socket : " + socket.id + " - " + error)
        })
       
        if(socket.handshake.auth == undefined || socket.handshake.auth == {}) {
            wlog.warn("Authentification manquant pour le client :" + socket.id)
            sendSession()
            return
        }

        var token = socket.handshake.auth.token
        var sessionId = socket.handshake.auth.sessionId
        var auth_code = socket.handshake.auth.auth_code
        var inLogin = false

        if(sessionId) {
            if(!session.checkSession(sessionId)) {
                wlog.warn("Session invalide pour le client : " + socket.id)
                sendSession()
                return;
            } else {
                if(auth_code) {
                    const discordUser = await discordAuth.getDiscordUser(sessionId, auth_code)
                    session.removeSession(sessionId)
                    if(discordUser == "USER_INFO_ERROR" || discordUser == "ACCESS_TOKEN_ERROR") {
                        wlog.warn("Erreur lors de la récupération des informations de l'utilisateur Discord associé à la session : " + sessionId)
                        socket.emit("AUTH_ERROR", discordUser)
                        socket.disconnect()
                        return
                    } else {
                        const loggedUser = await users.addUser(discordUser.auth, discordUser.identity)
                        for(var guild of discordUser.guilds) {
                            if(guild.owner) {
                                users.setGuildOwner(loggedUser.identity.id, guild.id, true)
                            }
                        }
                        const newToken = await loggedUser.createToken()
                        socket.emit("NEW_TOKEN", newToken)
                        token = newToken
                        inLogin = true
                        wlog.log("Utilisateur Discord associé à la session : " + sessionId + " récupéré avec succès")
                        
                    }
                    
                   
                } else {
                    wlog.warn("Code d'authentification manquant pour le client :" + socket.id)
                    socket.emit("AUTH_ERROR", "Code manquant invalide")
                    socket.disconnect()
                    return
                }
            }
        } 

        if(!token) {
            wlog.warn("Token manquant pour le client :" + socket.id)
            socket.emit("AUTH_ERROR", "Token invalide")
            sendSession()
            return
        }

        socketUser = users.getUserByToken(token)

        if(!socketUser) {
            wlog.warn("Token invalide pour le client :" + socket.id)
            socket.emit("AUTH_ERROR", "Token invalide")
            sendSession()
            return
        } else {
            if(!socketUser.auth) {
                wlog.warn("L'utilisateur '" + socketUser.identity.username + "' n'a pas d'authentification Discord Valide")
                socketUser.clearToken()
                socket.emit("AUTH_ERROR", "L'authentification Discord de l'utilisateur n'est pas valide")
                socket.disconnect()
                return
            }

            if(!inLogin) {
                if(socketUser.needUpdate()) {
                    if (!(await users.updateIdentity(socketUser.identity.id))) {
                        wlog.error("Erreur lors de la mise à jour des informations de l'utilisateur : " + socketUser.identity.id);
                        socket.emit("AUTH_ERROR", "Mise à jour des informations de l'utilisateur impossible");
                        wlog.log("Déconnexion de l'utilisateur : " + socketUser.identity.username + " (" + socketUser.identity.id + ") - Socket : " + socket.id)    
                        socket.disconnect();
                        return;
                     }
                     socketUser.justUpdated()
                } else {
                    wlog.log("Pas de mise à jour des informations de l'utilisateur : " + socketUser.identity.id + " car l'utilisateur vient de se connecter")
                }
            
            } else {
                wlog.log("L'utilisateur '" + socketUser.identity.username + "' s'est connecté via la session : " + sessionId)
            }

        }

        socketUser = users.getUserByToken(token)
            
        if(socketUser) {
            var actualGuildId = null
            if(allConnectedUsers.includes(socketUser.identity)) {
                wlog.warn("L'utilisateur '" + socketUser.identity.username + "' est déjà connecté sur un autre appareil")
                return
            } else {
                allConnectedUsers.push(socketUser.identity)
                UsersBySocket.set(socketUser.identity.id, socket.id)
               
            }

            wlog.log("Utilisateur connecté : " + socketUser.identity.username + " (" + socketUser.identity.id + ") - Socket : " + socket.id)
           

            if(socketUser.isFullBanned()) {
                wlog.warn("Utilisateur banni : " + socketUser.identity.username + " (" + socketUser.identity.id + ") - Socket : " + socket.id)
                socket.emit("AUTH_ERROR", "Vous êtes banni du serveur")
                socket.disconnect()
            }
            if(socketUser.isAdmin()) {
                socket.join("ADMIN")
                wlog.log("Utilisateur admin identifié : " + socketUser.identity.username + " (" + socketUser.identity.id + ")")
            }

            process.emit("USERS_UPDATE")
            // USERS

            // CHECKED : 24/04/2025
            IORequest("/USER/INFO", () => {
                var guildPresents = new Array();
                var guildsOfBot = discordBot.getGuilds()
                for(var guild of guildsOfBot) {
                    if(guild[1].allMembers.includes(socketUser.identity.id)) {
                       const guildData = guild[1]
                       guildData['members'] = new Array()
                       guildData.serverMember = guild[1].allMembers.length
                       for(var user of guildConnectedUsers.get(guild[0]) || []) {
                        const userData = users.getUserById(user.id)
                            if(userData && userData.identity.id != socketUser.identity.id) {
                                let infos = {
                                    id: userData.identity.id,
                                    username: userData.identity.username,
                                    avatar: userData.identity.avatar,
                                    isAdmin: userData.isAdmin(),
                                    isOwner: userData.isOwner(guild[0]),
                                    isMod: userData.isMod(guild[0]),
                                }
                                guildData.members.push(infos)

                            }
                       }
                   
                       // Send if the bot is connected to the guild
                        if(players.getPlayer(guild[0]) && players.getPlayer(guild[0]).isConnected()) {
                            guildData.connected = true
                        } else {
                            guildData.connected = false
                        }
                        // Leave the room if the user is not in the guild
                        if(socket.rooms.has(guild[0]) && !checkUserGuild(socketUser, guild[0])) {
                            socket.leave(guild[0])
                            removeGuildConnectedUser(socketUser.identity)
                            wlog.warn("L'utilisateur '" + socketUser.identity.username + "' quitte la room de la guilde : " + guild[0] + " car il n'est pas dans la guilde) /!\\")
                        }
                        guildPresents.push(guildData)
                    }
                }
                IOAnswer("/USER/INFO", {
                    identity: socketUser.identity,
                    guilds: guildPresents, 
                    labels: socketUser.labels,
                    history: history.getPersonalHistory(socketUser.identity.id),
                })
                wlog.log("Envoi des informations Discord de '" + socketUser.identity.id + "' à '" + socket.id + "'" )
            })

            IORequest("/USER/HISTORY", () => {
                IOAnswer("/USER/HISTORY", history.getPersonalHistory(socketUser.identity.id))
            })

            //CHECKED : 24/04/2025
            IORequest("/USER/SIGNOUT", () => {
                socketUser.removeToken(token)
                IOAnswer("/USER/SIGNOUT", true) 
                socket.disconnect()
            })

            // CHECKED : 24/04/2025 
            IORequest("/USERS/LIST", () => {
                if(!checkUserGuild(socketUser, actualGuildId)) return
                if(!guildConnectedUsers.has(actualGuildId)) return IOAnswer("/USERS/LIST", false)
                IOAnswer("/USERS/LIST", guildConnectedUsers.get(actualGuildId))
            })

            // PLAYERS

            IORequest("/PLAYER/LYRICS", async () => {
                if(!checkUserGuild(socketUser, actualGuildId)) return
                const player = await verifyPlayerAction(actualGuildId)
                if(!player) return IOAnswer("/PLAYER/LYRICS", false)
                if(!player.queue?.current) {
                    wlog.warn("Le player de la guilde : " + actualGuildId + " n'a pas de musique en cours")
                    IOAnswer("/PLAYER/LYRICS", false)
                    return
                }
                const song = player.queue.current
                const lyricsData = await lyrics.getLyrics(song.title + " " + song.author)
                if(!lyricsData) {
                    wlog.warn("Aucune lyrics trouvée pour la musique : " + song.title + " de l'artiste : " + song.author)
                    IOAnswer("/PLAYER/LYRICS", false)
                    return
                }
                IOAnswer("/PLAYER/LYRICS", lyricsData)
            })



            //CHECKED : 03/05/2025
            IORequest("/PLAYER/PREVIOUS/LIST", () => {   
                if(!checkUserGuild(socketUser, actualGuildId)) return
                const list = new List(actualGuildId)
                IOAnswer("/PLAYER/PREVIOUS/LIST", list.getPrevious())
            })

            // ChECKED : 03/05/2025
            IORequest("/GUILD/JOIN", async (guildId) => {
                if(!checkUserGuild(socketUser, guildId)) return IOAnswer("/GUILD/JOIN", "No guild found or not in the guild")  
                if(socket.rooms.has(guildId)) {
                    wlog.warn("L'utilisateur '" + socketUser.identity.username + "' est déjà dans la room de la guilde : " + guildId)
                } else {
                    // Make him to leave all the other rooms except the ADMIN room if he is admin
                    await socket.rooms.forEach((room) => {
                        if(room != "ADMIN" && room != guildId && room != socket.id) {
                            socket.leave(room)
                            wlog.log("L'utilisateur '" + socketUser.identity.username + "' quitte la room de la guilde: " + room)
                            removeGuildConnectedUser(socketUser.identity)
                        }
                    })
                    socket.join(guildId)
                    wlog.log("L'utilisateur '" + socketUser.identity.username + "' rejoint la room de la guilde : " + guildId)
                    addGuildConnectedUser(socketUser.identity, guildId)
                    actualGuildId = guildId
                    IOAnswer("/GUILD/JOIN", true)
                    process.emit("PLAYERS_UPDATE")
                    process.emit("USERS_UPDATE")
                }
 
            })
            



            // CHECKED : 03/05/2025
            IORequest("/PLAYER/STATE", async () => {
                const plaryer = await verifyPlayerAction(actualGuildId)
                if(!player) return IOAnswer("/PLAYER/STATE", false)
                IOAnswer("/PLAYER/STATE", await player.getState())
            })
            

            // CHECKED : 03/05/2025
            IORequest("/PLAYER/PAUSE", () => {
                handlePlayerAction(actualGuildId, (player) => player.pause(), "/PLAYER/PAUSE");
            });

            
            // CHECKED : 03/05/2025
            IORequest("/PLAYER/BACKWARD", () => {
                handlePlayerAction(actualGuildId, (player) => player.previous(), "/PLAYER/BACKWARD");
            });

            
            // CHECKED : 03/05/2025
            IORequest("/PLAYER/FORWARD", () => {
                handlePlayerAction(actualGuildId, (player) => player.skip(), "/PLAYER/FORWARD");
            });

              // CHECKED : 03/05/2025
            IORequest("/PLAYER/LOOP", () => {
                handlePlayerAction(actualGuildId, (player) => player.setLoop(), "/PLAYER/LOOP");
            });

              // CHECKED : 03/05/2025
            IORequest("/PLAYER/SHUFFLE", () => {
                handlePlayerAction(actualGuildId, (player) => player.setShuffle(), "/PLAYER/SHUFFLE");
            });
              // CHECKED : 03/05/2025
            IORequest("/PLAYER/DISCONNECT", () => {
                handlePlayerAction(actualGuildId, (player) => player.leave(), "/PLAYER/DISCONNECT");
            });
              // CHECKED : 03/05/2025
            IORequest("/PLAYER/CHANNEL/CHANGE", () => {
                handlePlayerAction(actualGuildId, (player) => {
                    const channel = getUserChannel()
                    if(!channel) {
                        IOAnswer("/PLAYER/CHANNEL/CHANGE", false)
                        return
                    }
                    player.changeChannel(channel)
                }, "/PLAYER/CHANNEL/CHANGE");
            });

            // CHECKED : 03/05/2025
            IORequest("/PLAYER/SEEK", (time) => {
                if(!time) return IOAnswer("/PLAYER/SEEK", false)
                handlePlayerAction(actualGuildId, (player) => {
                    // Check if current is not null
                    if(player.queue.current == null) {
                        wlog.warn("Le player de la guilde : " + guildId + " n'a pas de musique en cours")
                        IOAnswer("/PLAYER/SEEK", false)
                        return
                    }
                    player.setDuration(time)
                }, "/PLAYER/SEEK");
            });

            // CHECKED : 04/05/2025            
            IORequest("/QUEUE/PLAY", (data) => {
                if(!data) return IOAnswer("/QUEUE/PLAY/NOW", false)
                const {index, listType, now} = data
                if(!index) return IOAnswer("/QUEUE/PLAY/NOW", false)
                if(!listType) return IOAnswer("/QUEUE/PLAY/NOW", false)
                if(!checkUserGuild(socketUser, actualGuildId)) return
                const player = new Player(actualGuildId)
                if(!connectToPlayer(actualGuildId, player)) return IOAnswer("/QUEUE/PLAY", false)
                var song;
                if(listType == "previous") {
                    const previous = player.queue.getPrevious()
                    song = previous[index]
                } else if(listType == "next") {
                    const next = player.queue.getNext()
                    song = next[index]
                }
                if(!song) return IOAnswer("/QUEUE/PLAY/NOW", false)
                if(listType == "next") player.queue.removeNextByIndex(index)
                if(now) {
                    player.play(song)
                } else {
                    player.add(song)
                }
                history.addToPersonalHistory(socketUser.identity.id, song)
                IOAnswer("/QUEUE/PLAY/NOW", true)
            })

            // CHECKED : 04/05/2025
            IORequest("/QUEUE/NEXT/DELETE", (index) => {
                if(!index) return IOAnswer("/QUEUE/NEXT/DELETE", false)
                handlePlayerAction(actualGuildId, (player) => {
                    const next = player.queue.getNext()
                    if(!next[index]) return IOAnswer("/QUEUE/NEXT/DELETE", false);
                    player.queue.removeNextByIndex(index)
                }, "/QUEUE/NEXT/DELETE")
            })

             // CHECKED : 04/05/2025
            IORequest("/QUEUE/NEXT/DELETEALL", () => {
                handlePlayerAction(actualGuildId, (player) => player.queue.clearNext(), "/QUEUE/NEXT/DELETEALL")
            })

             // CHECKED : 04/05/2025
            IORequest("/QUEUE/NEXT/MOVE", (data) => {
                if(!data) return IOAnswer("/QUEUE/NEXT/MOVE", false)
                const {index, newIndex} = data
                if(!index) return IOAnswer("/QUEUE/NEXT/MOVE", false)
                if(!newIndex) return IOAnswer("/QUEUE/NEXT/MOVE", false)
                handlePlayerAction(actualGuildId, (player) => {
                    const next = player.queue.getNext()
                    if(!next[index]) return IOAnswer("/QUEUE/NEXT/MOVE", false);
                    player.queue.moveNext(index, newIndex)
                }, "/QUEUE/NEXT/MOVE")
            })

            // SEARCH

            // CHECKED : 24/04/2025 
            IORequest("/SEARCH", async (query) => {
                IOAnswer("/SEARCH", await Finder.search(query, true)) 
            })

            // CHECKED : 03/05/2025
            IORequest("/SEARCH/PLAY", async (data) => {
                if(!data) return IOAnswer("/SEARCH/PLAY", false)
                var {song, now} = data
                if(!song) return IOAnswer("/SEARCH/PLAY", false)
                if(typeof song == "string") {
                    song = JSON.parse(song)
                }
                if(!checkUserGuild(socketUser, actualGuildId)) return
                const player = new Player(actualGuildId)
                if(!connectToPlayer(actualGuildId, player)) return IOAnswer("/SEARCH/PLAY", false)
                if(now) {
                    player.play(song)
                } else {
                    player.add(song)
                }
                history.addToPersonalHistory(socketUser.identity.id, song)
                IOAnswer("/SEARCH/PLAY", true)
            })

            // CHECKED : 05/05/2025
            IORequest("/SEARCH/PLAYLIST", async (data) => {
                if(!data) return IOAnswer("/SEARCH/PLAYLIST", false)
                const {url, now} = data
                if(!url) return IOAnswer("/SEARCH/PLAYLIST", false)
                const playlist = await Finder.search(url, true, "PLAYLIST")
                if(!playlist) return IOAnswer("/SEARCH/PLAYLIST", false)
                const player = new Player(actualGuildId)
                if(!connectToPlayer(actualGuildId, player)) return IOAnswer("/SEARCH/PLAYLIST", false)
                player.readPlaylist(playlist, now)
                IOAnswer("/SEARCH/PLAYLIST", true)
            })

            IORequest("/SEARCH/LYRICS", async (name) => {
                if(!name) return IOAnswer("/SEARCH/LYRICS", false)
                const lyricsData = await lyrics.getLyrics(name)
                if(!lyricsData) return IOAnswer("/SEARCH/LYRICS", false)
                IOAnswer("/SEARCH/LYRICS", lyricsData)
            })

            // UPLOAD

            // CHECKED : 29/05/2025

            IORequest("/UPLOAD/FILE", async (data) => {
                if(!data) return IOAnswer("/UPLOAD/FILE", false)
                if(!data.name) return IOAnswer("/UPLOAD/FILE", false)
                const file = data.file
                // Check wav or mp3
                if(isAudioFile(file) == false) {
                    wlog.warn("Le fichier envoyé n'est pas un fichier audio valide (MP3/WAV)")
                    return IOAnswer("/UPLOAD/FILE", false)
                }
                const url = await mediaBase.postMedia(data)
                if(!url) return IOAnswer("/UPLOAD/FILE", false)
                IOAnswer("/UPLOAD/FILE", {"url": url, "name": data.name})
            })

            // CHECKED : 29/05/2025
            IORequest("/UPLOAD/FILE/GET_SONG", async (data) => {
                if(!data) return IOAnswer("/UPLOAD/FILE/GET_SONG", false)
                const {name, url} = data
                if(!url) return IOAnswer("/UPLOAD/FILE/GET_SONG", false)
                if(!name) return IOAnswer("/UPLOAD/FILE/GET_SONG", false)
                const song = new Song()
                if(!song) return IOAnswer("/UPLOAD/FILE/GET_SONG", false)
                await getMediaInformationFromUrl(song, url)
                song.type = "attachment"
                song.author = socketUser.identity.username
                song.authorId = socketUser.identity.id
                song.title = name
                song.url = url
                IOAnswer("/UPLOAD/FILE/GET_SONG", song)
            })

            // GOOGLE API

            IORequest("/GOOGLE/AUTH", () => {
                IOAnswer("/GOOGLE/AUTH", googleApis.createAuthUrl(socketUser.identity.id))
            })

            IORequest("/GOOGLE/YOUTUBE/ADD_PLAYLIST", async (code) => {
                if(!code) {
                    IOAnswer("/GOOGLE/YOUTUBE/ADD_PLAYLIST", false)
                }
                const token = await googleApis.getAuthorization(socketUser.identity.id, code)
                if(!token) {
                    IOAnswer("/GOOGLE/YOUTUBE/ADD_PLAYLIST", false)
                    return
                }
                playlists.processYoutubeData(socketUser.identity.id, await youtubeApi.getYoutubePlaylists(socketUser.identity.id))
                IOAnswer("/GOOGLE/YOUTUBE/ADD_PLAYLIST", true)
            })


            // PLAYLISTS

            

            // CHECKED : 30/04/2025
            IORequest("/PLAYLISTS/CREATE", async (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/CREATE", false)
                const {name, url} = data
                if(!name) return IOAnswer("/PLAYLISTS/CREATE", false)
                const playlist = await playlists.addPlaylist(socketUser.identity.id, name, url)
                if(!playlist) return IOAnswer("/PLAYLISTS/CREATE", false)
                IOAnswer("/PLAYLISTS/CREATE", true)
            })

             // CHECKED : 30/04/2025
            IORequest("/PLAYLISTS/DELETE", (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/DELETE", false)
                const {name} = data
                if(!name) return IOAnswer("/PLAYLISTS/DELETE", false)
                playlists.removePlaylist(socketUser.identity.id, name)
                IOAnswer("/PLAYLISTS/DELETE", true)
            })

            // CHECKED : 24/04/2025
            IORequest("/PLAYLISTS/LIST", () => {
                const playlist = playlists.getPlaylistsOfUser(socketUser.identity.id)
                IOAnswer("/PLAYLISTS/LIST", playlist)
            })

            // CHECKED : 30/04/2025
            IORequest("/PLAYLISTS/SEND", (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/SEND", false)
                const {name, toId} = data   
                if(!name || !toId) return IOAnswer("/PLAYLISTS/SEND", false)
                // Check if toId is in the same guilds as the user
                // Check if the toId exists and have a playlist with the same name
                const toUser = users.getUserById(toId)
                if(!toUser) return IOAnswer("/PLAYLISTS/SEND", false)
                const toPlaylists = playlists.getPlaylistsOfUser(toUser.identity.id)
                const fromPlaylist = playlists.getPlaylistOfUser(socketUser.identity.id, name)
                if(!fromPlaylist) return IOAnswer("/PLAYLISTS/SEND", false)
                if(toPlaylists.find(p => p.name == name)) return IOAnswer("/PLAYLISTS/SEND", false)
                playlists.copyPlaylist(socketUser.identity.id, toUser.identity.id, name)
                IOAnswer("/PLAYLISTS/SEND", true)
            })

            // CHECKED : 30/04/2025
            IORequest("/PLAYLISTS/RENAME", (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/RENAME", false)
                const {name, newName} = data
                if(!name || !newName) return IOAnswer("/PLAYLISTS/RENAME", false)
                const playlist = playlists.getPlaylistOfUser(socketUser.identity.id, name)
                if(!playlist) return IOAnswer("/PLAYLISTS/RENAME", false)
                playlists.renamePlaylist(socketUser.identity.id, name, newName)
                IOAnswer("/PLAYLISTS/RENAME", true) 
            })

            // CHECKED : 30/04/2025 
            IORequest("/PLAYLISTS/ADD_SONG", (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/ADD_SONG", false)
                const {name, song} = data
                if(!name || !song) return IOAnswer("/PLAYLISTS/ADD_SONG", false)
                const playlist = playlists.getPlaylistOfUser(socketUser.identity.id, name)
                if(!playlist) return IOAnswer("/PLAYLISTS/ADD_SONG", false)
                playlists.addSong(socketUser.identity.id, name, song)
                IOAnswer("/PLAYLISTS/ADD_SONG", true)
            })

            // CHECKED : 30/04/2025
            IORequest("/PLAYLISTS/REMOVE_SONG", (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/REMOVE_SONG", false)
                const {name, songId} = data
                if(!name || !songId) return IOAnswer("/PLAYLISTS/REMOVE_SONG", false)
                const playlist = playlists.getPlaylistOfUser(socketUser.identity.id, name)
                if(!playlist) return IOAnswer("/PLAYLISTS/REMOVE_SONG", false)
                playlists.removeSong(socketUser.identity.id, name, songId)
                IOAnswer("/PLAYLISTS/REMOVE_SONG", true)
            })

            // CHECKED : 05/05/2025
            IORequest("/PLAYLISTS/PLAY", async (data) => {
                if(!data) return IOAnswer("/PLAYLISTS/PLAY", false)
                const {name, now} = data
                if(!name) return IOAnswer("/PLAYLISTS/PLAY", false)
                if(!checkUserGuild(socketUser, actualGuildId)) return IOAnswer("/PLAYLISTS/PLAY", false)
                const playlist = playlists.getPlaylistOfUser(socketUser.identity.id, name)
                if(!playlist) return IOAnswer("/PLAYLISTS/PLAY", false)
                const player = new Player(actualGuildId)
                if(!await connectToPlayer(actualGuildId, player)) return IOAnswer("/PLAYLISTS/PLAY", false)
                player.readPlaylist(playlist, now)
                IOAnswer("/PLAYLISTS/PLAY", true)
            })


            // ADMIN

            if(socketUser.isAdmin()) {
                // CHECKED : 24/04/2025
                IORequest("/ADMIN/LOGS", () => {
                    if(!socketUser.isAdmin()) return IOAnswer("/ADMIN/LOGS", false)
                    const logs_data = new Array()
                    const logs_folder = fs.readdirSync(__glob.LOGS)
                    for(var log of logs_folder) {
                        logs_data.push({"name":log, "value": fs.readFileSync(__glob.LOGS + path.sep + log).toString()})
                    }
                    IOAnswer("/ADMIN/LOGS", logs_data)
                })

                // CHECKED : 24/04/2025
                IORequest("/ADMIN/MAINTENANCE/RESTART", (reason) => {
                    if(!socketUser.isAdmin()) return IOAnswer("/ADMIN/MAINTENANCE/RESTART", false)
                   if(!reason) return IOAnswer("/ADMIN/MAINTENANCE/RESTART", false)
                   restart(reason)
                })

                // CHECKED : 24/04/2025
                IORequest("/ADMIN/USERS/SWITCH_ADMIN", (userId) => {
                    if(!socketUser.isAdmin()) return IOAnswer("/ADMIN/USERS/SWITCH_ADMIN", false)
                    if(socketUser.identity.id == userId) return IOAnswer("/ADMIN/USERS/SWITCH_ADMIN", false)
                    if(!users.getUserById(userId)) return IOAnswer("/ADMIN/USERS/SWITCH_ADMIN", false)
                    users.setAdmin(userId)
                    IOAnswer("/ADMIN/USERS/SWITCH_ADMIN", true)
                })

                // CHECKED : 24/04/2025
                IORequest("/ADMIN/USERS/FULL_BAN", (userId) => {
                    if(!socketUser.isAdmin()) return IOAnswer("/ADMIN/USERS/FULL_BAN", false)
                    if(socketUser.identity.id == userId) return IOAnswer("/ADMIN/USERS/FULL_BAN", false)
                    if(!users.getUserById(userId)) return IOAnswer("/ADMIN/USERS/FULL_BAN", false)
                    if(users.getUserById(userId).isAdmin()) return IOAnswer("/ADMIN/USERS/FULL_BAN", false)
                    users.setFullBan(userId)
                    IOAnswer("/ADMIN/USERS/FULL_BAN", true)
                })


                // CHECKED : 24/04/2025
                IORequest("/ADMIN/USERS/DELETE", (userId) => {
                    if(!socketUser.isAdmin()) return IOAnswer("/ADMIN/USERS/DELETE", false)
                    if(socketUser.identity.id == userId) return IOAnswer("/ADMIN/USERS/DELETE", false)
                    if(!users.getUserById(userId)) return IOAnswer("/ADMIN/USERS/DELETE", false)
                    if(users.getUserById(userId).isAdmin()) return IOAnswer("/ADMIN/USERS/DELETE", false)
                        
                    users.removeUser(userId)
                    const userSocket = UsersBySocket.get(userId)
                    if(userSocket) {
                        const socket = io.sockets.sockets.get(userSocket)
                        if(socket) {
                            socket.emit("AUTH_ERROR", "Votre compte a été supprimé")
                            socket.disconnect()
                        }
                    }
                    IOAnswer("/ADMIN/USERS/DELETE", true)
                })

                // CHECKED : 24/04/2025
                IORequest("/ADMIN/PLAYER/GETALLSTATE", async () => {
                    if(!socketUser.isAdmin()) return IOAnswer("/ADMIN/PLAYER/GETTALLSTATE", false)
                    const allPlayers = players.getAllPlayers()
                    const states = new Array()
                    for(var player in allPlayers) {
                        await states.push(await player.getState())
                    }
                    IOAnswer("/ADMIN/PLAYER/GETALLSTATE", states)
                })

                
            }
            

            // CHECKED : 24/04/2025
            IORequest("/OWNER/USERS/SWITCH_MOD", (userId) => {
                if(userId || actualGuildId) return IOAnswer("/OWNER/USERS/SWITCH_MOD", false)
                if(socketUser.identity.id == userId) return IOAnswer("/OWNER/USERS/SWITCH_MOD", false)
                if(!socketUser.isOwner(actualGuildId)) return IOAnswer("/OWNER/USERS/SWITCH_MOD", false)
                users.setGuildMod(userId, actualGuildId)
                IOAnswer("/OWNER/USERS/SWITCH_MOD", true)
            })

            
            // CHECKED : 24/04/2025
            IORequest("/MOD/USERS/BAN", (userId) => {
                if(userId || actualGuildId) return IOAnswer("/MOD/USERS/BAN", false)
                if(socketUser.identity.id == userId) return IOAnswer("/MOD/USERS/BAN", false)
                if(!socketUser.isMod(actualGuildId)) return IOAnswer("/MOD/USERS/BAN", false)
                users.setGuildBan(userId, actualGuildId)
                IOAnswer("/MOD/USERS/BAN", true)
            })

            // UTILS

            // CHECKED : 24/04/2025
            IORequest("/REPORT", (data) => {
                if(data.length < 2) return IOAnswer("/REPORT", false)
                if(!data["level"] || !data["desc"]) return IOAnswer("/REPORT", false)
                const report = new Report(socketUser.identity.username, data["level"], data["desc"]).send()
                IOAnswer("/REPORT", true)
            })




            // Functions 

            function getUserChannel() {
                const membersVoices = discordBot.getMembersVoices()
                const member = membersVoices.get(socketUser.identity.id)
                if(member) {
                    const channelId = member.channelId
                    const guildId = member.guildId
                    const channel = discordBot.getChannel(guildId, channelId)
                    if(!channel) {
                        wlog.warn("Le channel vocal n'existe pas : " + channelId)
                        return null
                    }
                    return channel
                } else {
                    wlog.warn("L'utilisateur '" + socketUser.identity.username + "' n'est pas dans un channel vocal")
                    return null
                }
            }

            /**
             * @param {Player} player 
             */
            function connectToPlayer(guildId, player) {
                if(!checkUserGuild(socketUser, guildId)) return false
                if(player.isConnected()) true
                const channel = getUserChannel()
                if(!channel) return false
                player.join(channel)
                return true
            }

            async function verifyPlayerAction(guildId) {
                if (!checkUserGuild(socketUser, guildId)) return null;
                const player = players.getPlayer(guildId);
                if (player) {
                    return player;
                } else {
                    wlog.warn(`Le player de la guilde : ${guildId} n'existe pas`);
                    return null;
                }
            }


            function checkUserGuild(socketUser, guildId) {
                if(!guildId) {
                    wlog.warn("Aucun guildId n'est actif pour l'utilisateur : " + socketUser.identity.username)
                    return false
                }
                // Check if the guildId is referenced in the bot guilds 
                if(!discordBot.getGuilds().has(guildId)) {
                    wlog.warn("La guilde : " + guildId + " n'est pas référencée dans le bot")
                    return false
                }
                if(socketUser.isBanned(guildId)) {
                    wlog.warn("L'utilisateur '" + socketUser.identity.username + "' est banni de la guilde : " + guildId)
                    return false
                }
                const allGuilds = discordBot.getGuilds()
                
                if(!allGuilds.get(guildId).allMembers.includes(socketUser.identity.id)) {
                    wlog.warn("L'utilisateur '" + socketUser.identity.username + "' n'est pas membre de la guilde : " + guildId)
                    // Si user admin, override
                    if(!socketUser.isAdmin()) {
                        return false
                    }
                    wlog.log("L'utilisateur '" + socketUser.identity.username + "' est admin donc à le droit d'accéder à la guilde : " + guildId)
                }

                return true
            }

                    /**
                 * @param {function(Player)} action - The action to perform on the player.
                 */
            async function handlePlayerAction(guildId, action, actionName) {
                if (!checkUserGuild(socketUser, guildId)) return;
                    const player = players.getPlayer(guildId);
                if (player) {
                        await action(player);
                        wlog.log(`L'utilisateur '${socketUser.identity.username}' effectue l'action '${actionName}' sur le player de la guilde : ${guildId}`);
                        IOAnswer(actionName, true);
                } else {
                        wlog.warn(`Le player de la guilde : ${guildId} n'existe pas`);
                        IOAnswer(actionName, false);
                }

               
            }
            
        }
        


        function handleDisconnect() {
            if(socketUser) {
                wlog.log("Déconnexion de l'utilisateur : " + socketUser.identity.username + " (" + socketUser.identity.id + ") - Socket : " + socket.id)
                allConnectedUsers.splice(allConnectedUsers.indexOf(socketUser.identity), 1)
                removeGuildConnectedUser(socketUser.identity)
                process.emit("USERS_UPDATE")
                // Remove every rooms include admin
                socket.rooms.forEach((room) => {
                    socket.leave(room)
                })
                UsersBySocket.delete(socketUser.identity.id)
            }
        }

        function sendSession() {
            const newSession = session.addSession(socket.id)
            socket.emit("NEW_SESSION", newSession)
            wlog.log("Envoi d'une nouvelle session : '" + newSession + "' au client : " + socket.id)
            socket.disconnect()
        }

        
        function IORequest(RequestName, RequestCallback) {
            socket.on(RequestName, (value) => {
                wlog.log(socketUser.identity.username + " - Socket : " + socket.id  + " - " + RequestName + " - [RECIEVED]") 
                RequestCallback(value)
            })
        
        }
        function IOAnswer(AnswerName, AnswerValue) {
        
            wlog.log(socketUser.identity.username + " - Socket : " + socket.id  + " - " + AnswerName + " - [ANSWERED]") 
            socket.emit(AnswerName, AnswerValue)
        }

    })

    httpServer.listen(configuration.getPort(), () => {
        wlog.log(`Le serveur écoute sur le port ${configuration.getPort()}`)
        wlog.step.end("server_init")
    })

    function addGuildConnectedUser(user, guildId) {
        // Check if the user is already connected to the guild
        if(!guildConnectedUsers.has(guildId)) {
            guildConnectedUsers.set(guildId, new Array())
        }
            const users = guildConnectedUsers.get(guildId)
            if(users.includes(user)) {
                wlog.warn("L'utilisateur '" + user.username + "' est déjà connecté à la guilde : " + guildId)
                return
            }
            guildConnectedUsers.get(guildId).push(user)
    }


    function removeGuildConnectedUser(user) {
        for(var guild of guildConnectedUsers.keys()) {
            const users = guildConnectedUsers.get(guild)
            if(users.includes(user)) {
                users.splice(users.indexOf(user), 1)
                if(users.length == 0) {
                    guildConnectedUsers.delete(guild)
                }
            }
        }
    }
        
}

    
    





module.exports = {init}