const {app, BrowserWindow, ipcMain, Notification, nativeImage, Tray, Menu, shell} = require("electron")
const { autoUpdater, AppUpdater } = require("electron-updater")
const path = require("path")
const fs = require("fs")
const ipc = ipcMain
const { io } = require("socket.io-client");
const log = require("./sublog");
const { platform } = require("os");


// [Function] Main Window Function

autoUpdater.autoDownload = false;
autoUpdater.autoInstallOnAppQuit = true;

async function createWindow() {
    const win = new BrowserWindow({
        
        width: 300,
        height: 500,
        minWidth: 300,
        minHeight: 500,
        resizable: false,
        movable: true,
        closable: true,
        frame: false,
        icon: path.join(__dirname, './src/logo.ico'),
        title: "Submanager",
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false,
            devTools: true
        }

    })



    await win.loadFile("templates/login/login.html")



    const socket = io("ws://localhost:4000", {
        autoConnect: false,
        reconnection: false

    });

    socket.connect()


    
    socket.on("connect", () => {

        log.client("Connexion au serveur ... Finish !")

        if(!fs.existsSync( __dirname + path.sep + "settings.json")) {
            win.webContents.send("connectSuccess")
        } else {

            const settings = require( __dirname + path.sep + "settings.json")

            if(settings.token) {
                log.client("Auth : Connexion avec le Token Discord !")
                socket.emit("authByToken", settings.token)
            } else {

                win.webContents.send("connectSuccess")
            }
            
        }
        
       

    })

    socket.on("authByTokenAnswer", (resp, token) => {

        if(resp == true) {

            win.loadFile("templates/app/app.html")
           

        } else {
            fs.rmSync( __dirname + path.sep + "settings.json")
            win.webContents.send("connectSuccess")

        }
    })

    socket.io.on("error", () => {
        log.client("Erreur lors de la connexion entre le serveur et le client !")
        win.webContents.send("connectFailed")
    })

    ipc.on("retryLogin", () => {
        log.client("Reconnexion au serveur ... Progressing !")
        socket.connect()
    })

    ipc.on("discordlogin", () => {

        
        socket.emit("authNeedLogin")
        log.client("Discord Auth : Demande du Token vers le serveur !")
        win.minimize()
        
    })

    socket.on("authFailed", () => {
        win.webContents.send("discordFailed")
        log.client("Discord Auth : Erreur lors de la connexion vers Discord !")
    })

    socket.on("authOpenLink", (link) => {
        log.client("Discord Auth : Redirection vers le service Discord !")
        shell.openExternal(link)
        
    })

    socket.on("successLogin", () => {
        log.client("Discord Auth : Redirection fait avec succes !")
        win.loadFile("templates/app/app.html")
        askUpdateState()
        win.restore()
    })

    socket.on("updateState", (data) => {
        
        log.client("State : Update en cours !")
        win.webContents.send("updateData", data)
        

    })

    socket.on("actualize", (data) => {
        
        log.client("Actualisation : Update en cours !")
        win.webContents.send("actualize", data)
        
        
    })

    socket.on("findResult", (data) => {

        log.client("Recherche : Terminé et récupéré")
        win.webContents.send("findResult", data)
    })

    ipc.on("play", () => {

        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Play / Pause Requested !")
        socket.emit("play", settings.token)

    })

    ipc.on("forward", () => {

        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Forward Requested !")
        socket.emit("forward", settings.token)

    })

    ipc.on("backward", () => {

        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Backward Requsted !")
        socket.emit("backward", settings.token)

    })

    ipc.on("exitBot", () => {
        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Exit Bot Requsted !")
        socket.emit("exit", settings.token)

    })

    ipc.on("deleteQueue", (ev, identifier) => {
        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Delete Track queue Bot Requsted !")
        socket.emit("deleteQueue", settings.token, identifier)

    })

    ipc.on("findReq", (ev, value) => {
        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Find search Bot Requsted !")
        socket.emit("find", settings.token, value)

    })

    ipc.on("addQueue", (ev, url) => {
        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Add song Bot Requsted !")
        socket.emit("addQueue", settings.token, url)

    })

    ipc.on("listClear", () => {

        const settings = require( __dirname + path.sep + "settings.json")
        log.client("Control : Clear Queue Bot Requsted !")
        socket.emit("listClear", settings.token)
    })

    ipc.on("signout", () => {

        if(fs.statSync(__dirname + path.sep + "settings.json")) {

            fs.rmSync(__dirname + path.sep + "settings.json")
        }

        win.loadFile("template/login/login.html")
        socket.disconnect()
    
    })

    socket.on("registerToken", (token) => {

        const settings = {}
        settings["token"] = token

        fs.writeFileSync(  __dirname + path.sep + "settings.json", JSON.stringify(settings, null, 2))
        log.client("Saving token in settings !")
    })

    if (process.defaultApp) {
        if (process.argv.length >= 2) {
          app.setAsDefaultProtocolClient('submanager', process.execPath, [path.resolve(process.argv[1])])
        }
      } else {
        app.setAsDefaultProtocolClient('submanager')
      }

    ipc.on("close", () => {
        socket.disconnect()
        app.quit()
    })

    ipc.on("minimize", () => {
        win.minimize()
    })

    ipc.on("askUpdateState", () => {

    askUpdateState()
    })  

    function askUpdateState() {

        const settings = require( __dirname + path.sep + "settings.json")
        socket.emit("getState", settings.token)
    }

    socket.on("disconnect", async () => {
        await win.loadFile("templates/login/login.html")
        await win.webContents.send("connectFailed")
        socket.connect()
    });

}



function sts() {

    const settings = require( __dirname + path.sep + "settings.json")
    return settings
}

app.on("open-url", (ev, url) => {
    app.quit() 
 })

app.whenReady().then(() => {

    const icon = nativeImage.createFromPath('src/logo.png')
    tray = new Tray(icon)


    const contextMenu = Menu.buildFromTemplate([
         { label:"Quitter", click() { app.quit()}}
      ])
    
    tray.setToolTip("Submanager")
    tray.setContextMenu(contextMenu)

    //[Operation] - Check settings

    createWindow()
    log.client("Starting Application")
        
    app.on('activate', () => {

        autoUpdater.checkForUpdates()
        if(BrowserWindow.getAllWindows().length === 0) {
                createWindow()   

        }

    }) 

    

    

})





//EXPORT COMMAND : npx electron-packager . submanager-beta-1 --platform="win32" --out="C:\Users\picot\OneDrive\Bureau\"