const { BrowserWindow, ipcMain, shell, app, screen } = require("electron")
const { join } = require("path")
const getPort = require("get-port");
const express = require("express");
const path = require("path");
const windowStateKeeper = require("electron-window-state");
const os = require('os');
const yt = require('youtube-search-without-api-key');
const discord = require('./discordrpc');
const lastfm = require('./lastfm');
const { writeFile, writeFileSync, existsSync, mkdirSync } = require('fs');
const fs = require('fs');
const mpris = require('./mpris');
const mm = require('music-metadata');
const fetch = require('electron-fetch').default;
const { Stream } = require('stream');

// Analytics for debugging.
const ElectronSentry = require("@sentry/electron");
ElectronSentry.init({ dsn: "https://68c422bfaaf44dea880b86aad5a820d2@o954055.ingest.sentry.io/6112214" });

const CiderBase = {
    win: null,
    requests: [],
    audiostream: new Stream.PassThrough(),
    async Start() {
        this.clientPort = await getPort({ port: 9000 });
        this.win = this.CreateBrowserWindow()
    },
    clientPort: 0,
    CreateBrowserWindow() {
        this.VerifyFiles()
        // Set default window sizes
        const mainWindowState = windowStateKeeper({
            defaultWidth: 1024,
            defaultHeight: 600
        });

        let win = null
        const options = {
            icon: join(__dirname, `../../resources/icons/icon.` + (process.platform === "win32" ? "ico" : "png")),
            width: mainWindowState.width,
            height: mainWindowState.height,
            x: mainWindowState.x,
            y: mainWindowState.y,
            minWidth: 844,
            minHeight: 410,
            frame: false,
            title: "Cider",
            vibrancy: 'dark',
            //  transparent: true,
            hasShadow: false,
            webPreferences: {
                webviewTag: true,
                plugins: true,
                nodeIntegration: true,
                nodeIntegrationInWorker: false,
                webSecurity: false,
                allowRunningInsecureContent: true,
                enableRemoteModule: true,
                sandbox: true,
                nativeWindowOpen: true,
                contextIsolation: false,
                preload: join(__dirname, '../preload/cider-preload.js')
            }
        }

        CiderBase.InitWebServer()

        // Create the BrowserWindow
        if (process.platform === "darwin" || process.platform === "linux") {
            win = new BrowserWindow(options)
        } else {
            // i don't know why but we have to do this for acrylic to work properly
            if (app.cfg.get("visual.window_transparency") !== "disabled") {
                const { BrowserWindow } = require("electron-acrylic-window");
                win = new BrowserWindow(options)
                win.setVibrancy("dark")
            } else {
                win = new BrowserWindow(options)
                win.setVibrancy("dark")
            }

        }

        // intercept "https://js-cdn.music.apple.com/hls.js/2.141.0/hls.js/hls.js" and redirect to local file "./apple-hls.js" instead
        win.webContents.session.webRequest.onBeforeRequest(
            {
                urls: ["https://*/*.js"]
            },
            (details, callback) => {
                if (details.url.includes("hls.js")) {
                    callback({
                        redirectURL: `http://localhost:${CiderBase.clientPort}/apple-hls.js`
                    })
                } else {
                    callback({
                        cancel: false
                    })
                }
            }
        )

        win.webContents.session.webRequest.onBeforeSendHeaders(async (details, callback) => {
            if (details.url === "https://buy.itunes.apple.com/account/web/info") {
                details.requestHeaders['sec-fetch-site'] = 'same-site';
                details.requestHeaders['DNT'] = '1';
                let itspod = await win.webContents.executeJavaScript(`window.localStorage.getItem("music.ampwebplay.itspod")`)
                if (itspod != null)
                    details.requestHeaders['Cookie'] = `itspod=${itspod}`
            }
            callback({ requestHeaders: details.requestHeaders })
        })

        let location = `http://localhost:${CiderBase.clientPort}/`
        win.loadURL(location)
        win.on("closed", () => {
            win = null
        })

        // Register listeners on Window to track size and position of the Window.
        mainWindowState.manage(win);

        // IPC stuff (senders)
        ipcMain.on("cider-platform", (event) => {
            event.returnValue = process.platform
        })

        ipcMain.on("get-gpu-mode", (event) => {
            event.returnValue = process.platform
        })

        ipcMain.on("is-dev", (event) => {
            event.returnValue = !app.isPackaged
        })

        // IPC stuff (listeners)
        ipcMain.on('close', () => { // listen for close event
            win.close();
        })

        ipcMain.on('put-library-songs', (event, arg) => {
            fs.writeFileSync(join(app.paths.ciderCache, "library-songs.json"), JSON.stringify(arg))
        })

        ipcMain.on('put-library-artists', (event, arg) => {
            fs.writeFileSync(join(app.paths.ciderCache, "library-artists.json"), JSON.stringify(arg))
        })

        ipcMain.on('put-library-albums', (event, arg) => {
            fs.writeFileSync(join(app.paths.ciderCache, "library-albums.json"), JSON.stringify(arg))
        })

        ipcMain.on('put-library-playlists', (event, arg) => {
            fs.writeFileSync(join(app.paths.ciderCache, "library-playlists.json"), JSON.stringify(arg))
        })

        ipcMain.on('put-library-recentlyAdded', (event, arg) => {
            fs.writeFileSync(join(app.paths.ciderCache, "library-recentlyAdded.json"), JSON.stringify(arg))
        })

        ipcMain.on('get-library-songs', (event) => {
            let librarySongs = fs.readFileSync(join(app.paths.ciderCache, "library-songs.json"), "utf8")
            event.returnValue = JSON.parse(librarySongs)
        })

        ipcMain.on('get-library-artists', (event) => {
            let libraryArtists = fs.readFileSync(join(app.paths.ciderCache, "library-artists.json"), "utf8")
            event.returnValue = JSON.parse(libraryArtists)
        })

        ipcMain.on('get-library-albums', (event) => {
            let libraryAlbums = fs.readFileSync(join(app.paths.ciderCache, "library-albums.json"), "utf8")
            event.returnValue = JSON.parse(libraryAlbums)
        })

        ipcMain.on('get-library-playlists', (event) => {
            let libraryPlaylists = fs.readFileSync(join(app.paths.ciderCache, "library-playlists.json"), "utf8")
            event.returnValue = JSON.parse(libraryPlaylists)
        })

        ipcMain.on('get-library-recentlyAdded', (event) => {
            let libraryRecentlyAdded = fs.readFileSync(join(app.paths.ciderCache, "library-recentlyAdded.json"), "utf8")
            event.returnValue = JSON.parse(libraryRecentlyAdded)
        })

        ipcMain.handle('getYTLyrics', async (event, track, artist) => {
            var u = track + " " + artist + " official video";
            const videos = await yt.search(u);
            return videos
        })

        ipcMain.handle('getStoreValue', (event, key, defaultValue) => {
            return (defaultValue ? app.cfg.get(key, true) : app.cfg.get(key));
        });

        ipcMain.handle('setStoreValue', (event, key, value) => {
            app.cfg.set(key, value);
        });

        ipcMain.on('getStore', (event) => {
            event.returnValue = app.cfg.store
        })

        ipcMain.on('setStore', (event, store) => {
            app.cfg.store = store
        })

        ipcMain.handle('setVibrancy', (event, key, value) => {
            win.setVibrancy(value)
        });

        ipcMain.on('maximize', () => { // listen for maximize event
            if (win.isMaximized()) {
                win.unmaximize()
            } else {
                win.maximize()
            }
        })

        ipcMain.on('minimize', () => { // listen for minimize event
            win.minimize();
        })

        ipcMain.on('setFullScreen',(event, flag) => {
            win.setFullScreen(flag)
        })

        if (process.platform === "win32") {
            let WND_STATE = {
                MINIMIZED: 0,
                NORMAL: 1,
                MAXIMIZED: 2,
                FULL_SCREEN: 3
            }
            let wndState = WND_STATE.NORMAL

            win.on("resize", (_event) => {
                const isMaximized = win.isMaximized()
                const isMinimized = win.isMinimized()
                const isFullScreen = win.isFullScreen()
                const state = wndState;
                if (isMinimized && state !== WND_STATE.MINIMIZED) {
                    wndState = WND_STATE.MINIMIZED
                } else if (isFullScreen && state !== WND_STATE.FULL_SCREEN) {
                    wndState = WND_STATE.FULL_SCREEN
                } else if (isMaximized && state !== WND_STATE.MAXIMIZED) {
                    wndState = WND_STATE.MAXIMIZED
                    win.webContents.executeJavaScript(`app.chrome.maximized = true`)
                } else if (state !== WND_STATE.NORMAL) {
                    wndState = WND_STATE.NORMAL
                    win.webContents.executeJavaScript(`app.chrome.maximized = false`)
                }
            })
        }

        // Set window Handler
        win.webContents.setWindowOpenHandler(({ url }) => {
            if (url.includes("apple") || url.includes("localhost")) {
                return { action: "allow" }
            }
            shell.openExternal(url).catch(() => {
            })
            return {
                action: 'deny'
            }
        })

        // Set scale
        ipcMain.on('setScreenScale', (event, scale) => {
            win.webContents.setZoomFactor(parseFloat(scale))
        })

        win.webContents.setZoomFactor(screen.getPrimaryDisplay().scaleFactor)

        mpris.connect(win)

        lastfm.authenticate()
        //  Discord
        discord.connect((app.cfg.get("general.discord_rpc") == 1) ? '911790844204437504' : '886578863147192350');
        ipcMain.on('playbackStateDidChange', (_event, a) => {
            app.media = a;
            discord.updateActivity(a)
            mpris.updateState(a)
            lastfm.scrobbleSong(a)
            lastfm.updateNowPlayingSong(a)
        });

        ipcMain.on('nowPlayingItemDidChange', (_event, a) => {
            app.media = a;
            discord.updateActivity(a)
            mpris.updateAttributes(a)
            lastfm.scrobbleSong(a)
            lastfm.updateNowPlayingSong(a)
        });

        ipcMain.on("getPreviewURL", (_event, url) => {
            fetch(url)
                .then(res => res.buffer())
                .then(async (buffer) => {
                    try {
                        const metadata = await mm.parseBuffer(buffer, 'audio/x-m4a');
                        SoundCheckTag = metadata.native.iTunes[1].value
                        win.webContents.send('SoundCheckTag', SoundCheckTag)
                    } catch (error) {
                        console.error(error.message);
                    }
                })
        });

        ipcMain.on('writeAudio', function (event, buffer) {
            CiderBase.audiostream.write(Buffer.from(buffer));
        })

        return win
    },
    VerifyFiles() {
        const expectedDirectories = [
            "CiderCache"
        ]
        const expectedFiles = [
            "library-songs.json",
            "library-artists.json",
            "library-albums.json",
            "library-playlists.json",
            "library-recentlyAdded.json",
        ]
        for (let i = 0; i < expectedDirectories.length; i++) {
            if (!existsSync(path.join(app.getPath("userData"), expectedDirectories[i]))) {
                mkdirSync(path.join(app.getPath("userData"), expectedDirectories[i]))
            }
        }
        for (let i = 0; i < expectedFiles.length; i++) {
            const file = path.join(app.paths.ciderCache, expectedFiles[i])
            if (!existsSync(file)) {
                writeFileSync(file, JSON.stringify([]))
            }
        }
    },
    EnvironmentVariables: {
        "env": {
            platform: os.platform(),
            dev: app.isPackaged
        }
    },
    LinkHandler: (startArgs) => {
        if (!startArgs) return;
        console.log("lfmtoken", String(startArgs))
        if (String(startArgs).includes('auth')) {
            let authURI = String(startArgs).split('/auth/')[1]
            if (authURI.startsWith('lastfm')) { // If we wanted more auth options
                const authKey = authURI.split('lastfm?token=')[1];
                app.cfg.set('lastfm.enabled', true);
                app.cfg.set('lastfm.auth_token', authKey);
                CiderBase.win.webContents.send('LastfmAuthenticated', authKey);
                lastfm.authenticate()
            }
        } else {
            const formattedSongID = startArgs.replace('ame://', '').replace('/', '');
            console.warn(`[LinkHandler] Attempting to load song id: ${formattedSongID}`);

            // setQueue can be done with album, song, url, playlist id
            this.win.webContents.executeJavaScript(`
                MusicKit.getInstance().setQueue({ song: '${formattedSongID}'}).then(function(queue) {
                    MusicKit.getInstance().play();
                });
            `).catch((err) => console.error(err));
        }

    },

    async InitWebServer() {
        const webapp = express();
        const webRemotePath = path.join(__dirname, '../renderer/');
        webapp.set("views", path.join(webRemotePath, "views"));
        webapp.set("view engine", "ejs");

        webapp.use(function (req, res, next) {
            // if not localhost
            if (req.url.includes("audio.webm") || (req.headers.host.includes("localhost") && req.headers["user-agent"].includes("Cider"))) {
                next();
            }
        });

        webapp.use(express.static(webRemotePath));
        webapp.get('/', function (req, res) {
            //res.sendFile(path.join(webRemotePath, 'index_old.html'));
            res.render("main", CiderBase.EnvironmentVariables)
        });
        webapp.get('/audio.webm', function (req, res) {
            try {
                req.connection.setTimeout(Number.MAX_SAFE_INTEGER);
                // CiderBase.requests.push({req: req, res: res});
                // var pos = CiderBase.requests.length - 1;
                // req.on("close", () => {
                //     console.info("CLOSED", CiderBase.requests.length);
                //     requests.splice(pos, 1);
                //     console.info("CLOSED", CiderBase.requests.length);
                // });
                CiderBase.audiostream.on('data', (data) => {
                    try {
                        res.write(data);
                    } catch (ex) {
                        console.log(ex)
                    }
                })
            } catch (ex) { console.log(ex) }
        });
        webapp.listen(CiderBase.clientPort, function () {
            console.log(`Cider client port: ${CiderBase.clientPort}`);
        });
    },

}

module.exports = CiderBase;