const os = require("os")
const path = require("path")
const osmeta = require("./osmeta")
const { exec } = require("child_process")
const files = require("./files")
const config = require("../config.json")
const settings = require("./settings")
const { dialog, BrowserWindow, shell } = require("electron")
const AdmZip = require("adm-zip")

function isJavaInstalled() {
    return new Promise((resolve, reject) => {
        try {
            exec(`"${settings.get("javaPath") == "" ? "java" : settings.get("javaPath")}" -version`, (error, stdout, stderr) => {
                if (error) {
                    reject({
                        java: false
                    })
                }
                const output = `${stdout}\n${stderr}`
                const lines = output.split("\n")
                const version = lines.filter(line => line.includes("version \""))[0]
                try {
                    let matchRegEx
                    if (version.includes("_")) {
                        matchRegEx = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)\_(?<update>\d+)/
                    } else {
                        matchRegEx = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/
                    }
                    const versionMatch = version.match(matchRegEx)
                    const { major, minor, patch, update } = versionMatch.groups
                    resolve({
                        java: true,
                        version: {
                            major: parseInt(major),
                            minor: parseInt(minor),
                            patch: parseInt(patch),
                            update: update ? parseInt(update) : null
                        }
                    })
                } catch (error) {
                    reject({
                        java: false,
                        error
                    })
                }
            })
        } catch (error) {
            reject({
                java: false,
                error
            })
        }
    })
}

async function showJavaErrorBox() {
    const javaErrorBox = await dialog.showMessageBox(BrowserWindow.getFocusedWindow(), {
        title: "Mauvaise version de Java",
        message: "Mauvaise version de Java",
        detail: "La version de java installé sur votre ordinateur n'est pas compatible avec la version de minecraft utilisé",
        icon: path.join(__dirname, "code/app/assets/img/java.png"),
        buttons: [
            "Fermer",
            "Installer automatiquement java",
            "Installer manuellement java",
            "Utilise un chemin d'accès personnalié",
        ],
        cancelId: 0,
        defaultId: 1
    })
    return javaErrorBox
}
function installJava(dest) {
    return new Promise(async (resolve, reject) => {
        const response = await fetch(`${config.apiServicesURL}/api/java`)
        const java = await response.json()
        const arch = osmeta.arch() == "unknow" ? "x64" : osmeta.arch()
        if (java.downloads[os.platform()]) {
            if (java.downloads[os.platform()][arch]) {
                files.downloadFile(config.apiServicesURL + java.downloads[os.platform()][arch].url, path.join(dest, "java.zip"), (error, file) => {
                    if (error) throw error
                    try {
                        const zip = new AdmZip(path.join(dest, "java.zip"))
                        zip.extractAllTo(path.join(dest, "java"), true)
                        files.removeFile(path.join(dest, "java.zip"))
                        if (os.platform() == "darwin") {
                            exec(`chmod +x "${path.join(dest, "java", "jre-1.8.0_411.jre", "Contents", "Home", "bin", "java")}"`, (error) => {
                                if (error) reject(error)
                                resolve(path.join(dest, "java", "jre-1.8.0_411.jre", "Contents", "Home", "bin", "java"))
                            })
                        } else {
                            exec(`chmod +x "${path.join(dest, "java", "bin", "java")}"`, (error) => {
                                if (error) reject(error)
                                resolve(path.join(dest, "java", "bin", "java"))
                            })
                        }
                    } catch (err) {
                        reject(err)
                    }
                })
            } else {
                reject(new Error("Java are not supported for your OS arch"))
            }
        } else {
            reject(new Error("Java are not supported for your OS"))
        }
    })
}

async function main(requiredJavaVersionMinor, dest) {
    return new Promise(async (resolve, reject) => {
        try {
            const java = await isJavaInstalled()
            if (java.version.minor < parseInt(requiredJavaVersionMinor)) {
                const javaErrorBox = await showJavaErrorBox()
                switch (javaErrorBox.response) {
                    case 0:
                        resolve()
                        break
                    case 1:
                        installJava(dest).then(javaPath => {
                            resolve(javaPath)
                        })
                        break
                    case 2:
                        shell.openExternal(`https://www.java.com/fr/download/manual.jsp`)
                        resolve()
                        break
                    case 3:
                        const javaBinPathSelect = await dialog.showOpenDialog(BrowserWindow.getFocusedWindow(), {
                            filters: [
                                {
                                    name: "java",
                                }
                            ]
                        })
                        if (javaBinPathSelect.canceled) {
                            showJavaErrorBox()
                        } else {
                            resolve(javaBinPathSelect.filePaths[0])
                        }
                        break
                }
            } else {
                resolve()
            }
        } catch (error) {
            const javaErrorBox = await showJavaErrorBox()
            switch (javaErrorBox.response) {
                case 0:
                    resolve()
                    break
                case 1:
                    installJava(dest).then(javaPath => {
                        resolve(javaPath)
                    })
                    break
                case 2:
                    shell.openExternal(`https://www.java.com/fr/download/manual.jsp`)
                    resolve()
                    break
                case 3:
                    const javaBinPathSelect = await dialog.showOpenDialog(BrowserWindow.getFocusedWindow(), {
                        filters: [
                            {
                                name: "java",
                            }
                        ]
                    })
                    if (javaBinPathSelect.canceled) {
                        showJavaErrorBox()
                    } else {
                        resolve(javaBinPathSelect.filePaths[0])
                    }
                    break
            }
        }
    })
}

module.exports.java = main