module.exports = async (argv) => {
    const installed = JSON.parse(fs.readFileSync(home + "/installed.json").toString());

    let spinner = ora("Reading package lists...").start();
    let packages = JSON.parse(fs.readFileSync(home + "/repository/list.json").toString());
    spinner.succeed("Reading packages lists... done");
    let updated = false;

    for (let pack of installed) {
        if (!packages.includes(pack.id)) {
            console.log(c.yellow("warn: ") + "package '" + pack.id + "' not in repository anymore");
        } else {
            let installable = true;
            let dir = pack.id.substring(0, 1).replace(/[^a-zA-Z0-9]/gm, "#");
            let pkg = JSON.parse(fs.readFileSync(home + "/repository/" + dir + "/" + pack.id + ".json").toString());
            if ((argv.package !== undefined && argv.package === pack.id) || argv.package === undefined) {
                updated = true;
                if (os.platform() === "win32" && pkg.platforms.windows === 0) {
                    console.log(c.yellow("warn: ") + "package '" + pack.id + "' not available on platform 'win32' anymore");
                    installable = false;
                } else if (os.platform() === "linux" && pkg.platforms.linux === 0) {
                    console.log(c.yellow("warn: ") + "package '" + pack.id + "' not available on platform 'linux' anymore");
                    installable = false;
                } else if (os.platform() === "darwin" && pkg.platforms.mac === 0) {
                    console.log(c.yellow("warn: ") + "package '" + pack.id + "' not available on platform 'macos' anymore");
                    installable = false;
                }

                if (os.platform() === "win32" && pkg.platforms.windows === 1) {
                    console.log(c.yellow("warn: ") + "package '" + pack.id + "' is experimental on platform 'win32'");
                } else if (os.platform() === "linux" && pkg.platforms.linux === 1) {
                    console.log(c.yellow("warn: ") + "package '" + pack.id + "' is experimental on platform 'linux'");
                } else if (os.platform() === "darwin" && pkg.platforms.mac === 1) {
                    console.log(c.yellow("warn: ") + "package '" + pack.id + "' is experimental on platform 'macos'");
                }

                spinner = ora("Checking dependencies...").start();
                for (let dependency of pkg.depends) {
                    let cmd = "which";
                    if (os.platform() === "win32") { cmd = "where"; }
                    try {
                        if (require('child_process').spawnSync(cmd, [dependency]).status !== 0) {
                            spinner.fail("Checking dependencies... failed")
                            die(c.red("error: ") + "package '" + pack.id + "' depends on '" + dependency + "' which is not installed");
                        }
                    } catch (e) {
                        spinner.fail("Checking dependencies... failed")
                        die(c.red("error: ") + "unable to check for '" + dependency + "'");
                    }
                }
                spinner.succeed("Checking dependencies... done")

                if (installable) {
                    let version = pkg.verdata.latest;
                    let publisher = pkg.verdata.publisher.name;
                    let publisherMail = pkg.verdata.publisher.email;
                    let date = moment(pkg.verdata.date).fromNow();

                    let signed = false;
                    let signInfo = "";
                    let verified = false;

                    if (pkg.sign.signed) {
                        signed = true;
                        verified = pkg.sign.verified;
                        if (pkg.sign.signer.name && pkg.sign.signer.email && pkg.sign.key) {
                            signInfo = pkg.sign.signer.name + " <" + pkg.sign.signer.email + "> " + c.gray("(" + pkg.sign.key + ")");
                        } else if (pkg.sign.signer.name && pkg.sign.key) {
                            signInfo = pkg.sign.signer.name + c.gray(" (" + pkg.sign.key + ")");
                        } else if (pkg.sign.signer.email && pkg.sign.key) {
                            signInfo = pkg.sign.signer.email + c.gray(" (" + pkg.sign.key + ")");
                        } else if (pkg.sign.key) {
                            signInfo = pkg.sign.key;
                        }
                    }

                    if (pack.version !== version) {
                        console.log("  Installing '" + pkg.name + "'...")
                        console.log("      version:   " + pack.version + " -> " + version);
                        console.log("      release:   " + date);
                        console.log("      publisher: " + publisher + " <" + publisherMail + ">");

                        if (signed) {
                            if (verified) {
                                console.log("      security:  " + c.green("verified") + " " + signInfo);
                            } else {
                                console.log("      security:  " + c.yellow("unverified") + " " + signInfo);
                            }
                        } else {
                            console.log("      security:  " + c.red.inverse("unsafe"));
                        }

                        try {
                            if (!signed && !(await prompts.confirm({
                                message: "This package is unsafe, installing it may damage your system. Are you sure you want to continue?",
                                initial: false
                            }))) {
                                installable = false;
                            }
                        } catch (e) {
                            installable = false;
                        }

                        if (installable) {
                            if (fs.existsSync(home + "/buildroot")) { fs.rmSync(home + "/buildroot", { recursive: true }) }
                            require('../hooks/clone')(pkg.repo, pkg.branch, () => {
                                spinner = ora("Extracting package...").start();
                                if (fs.existsSync(home + "/packages/" + pkg.id + "--update-" + version)) fs.rmSync(home + "/packages/" + pkg.id + "--update-" + version, { recursive: true })
                                fs.renameSync(home + "/buildroot", home + "/packages/" + pkg.id + "--update-" + version);
                                let change = require('../hooks/diff')(pkg.id, pkg.id + "--update-" + version);
                                require('../hooks/apply_update')(pkg.id, pkg.id + "--update-" + version);
                                fs.rmSync(home + "/packages/" + pkg.id + "--update-" + version, { recursive: true });
                                delete installed[installed.map(i => i.id).indexOf(pkg.id)];
                                installed.push({
                                    id: pkg.id,
                                    date: new Date().toISOString(),
                                    version,
                                    files: require('../hooks/files')(pkg.id)
                                })
                                fs.writeFileSync(os.homedir() + "/.twilight/installed.json", JSON.stringify(installed));
                                spinner.succeed("Extracting package... done");
                                console.log("  Size change: " + change);
                            })
                        }
                    } else if (argv.package !== undefined && argv.package === pack.id) {
                        die(c.red("error: ") + "package '" + argv.package + "' is up to date");
                    } else {
                        console.log("      up to date");
                    }
                } else if (argv.package !== undefined && argv.package === pack.id) {
                    die(c.red("error: ") + "package '" + argv.package + "' cannot be updated");
                }
            }
        }
    }

    if (!updated) {
        die(c.red("error: ") + "package '" + argv.package + "' not installed");
    }
}