import * as querystring from "querystring";
import * as request from "request";
import {app, dialog, ipcMain} from "electron";
import * as fs from "fs-extra";
import * as ofs from "original-fs";
import * as os from "os";
import * as tar from "tar-stream";
import * as path from "path";
import * as zlib from "zlib";
import * as child_process from "child_process";
import * as progress from "request-progress";
import * as util from "util";

import {parse_version, Version} from "../../shared/version";

import Timer = NodeJS.Timer;
import MessageBoxOptions = Electron.MessageBoxOptions;
import {Headers} from "tar-stream";
import {Arguments, process_args} from "../../shared/process-arguments";
import * as electron from "electron";
import {PassThrough} from "stream";
import * as _main_windows from "../main_window";
import ErrnoException = NodeJS.ErrnoException;
import {EPERM} from "constants";
import * as winmgr from "../window";

const is_debug = false;
export function server_url() : string {
    const default_path = is_debug ? "http://localhost/home/TeaSpeak/TeaSpeak/Web-Client/client-api/environment/" : "http://clientapi.teaspeak.de/";
    return process_args.has_value(...Arguments.SERVER_URL) ? process_args.value(...Arguments.SERVER_URL) : default_path;
}

export interface UpdateVersion {
    channel: string;
    platform: string,
    arch: string;
    version: Version;
}

export interface UpdateData {
    versions: UpdateVersion[];
    updater_version: UpdateVersion;
}

let version_cache: UpdateData = undefined;
export async function load_data(allow_cached: boolean = true) : Promise<UpdateData> {
    if(version_cache && allow_cached) return Promise.resolve(version_cache);

    return new Promise<UpdateData>((resolve, reject) => {
        const request_url = server_url() + "/api.php?" + querystring.stringify({
            type: "update-info"
        });
        console.log("request: %s", request_url);
        request.get(request_url, {
            timeout: 2000
        }, (error, response, body) => {
            if(!response || response.statusCode != 200) {
                let info;
                try {
                    info = JSON.parse(body) || {msg: error};
                } catch(e) {
                    info = {msg: "!-- failed to parse json --!"};
                }
                setImmediate(reject, "Invalid status code (" + (response || {statusCode: -1}).statusCode + " | " + (info || {msg: "undefined"}).msg + ")");
                return;
            }
            const data = JSON.parse(body);
            if(!data) {
                setImmediate(reject, "Invalid response");
                return;
            }
            if(!data["success"]) {
                setImmediate(reject, "Action failed (" + data["msg"] + ")");
                return;
            }

            let resp: UpdateData = {} as any;
            resp.versions = [];
            for(const channel of Object.keys(data)) {
                if(channel == "success") continue;

                for(const entry of data[channel]) {
                    let version: UpdateVersion = {} as any;
                    version.channel = channel;
                    version.arch = entry["arch"];
                    version.platform = entry["platform"];
                    version.version = new Version(entry["version"]["major"], entry["version"]["minor"], entry["version"]["patch"], entry["version"]["build"], entry["version"]["timestamp"]);
                    if(version.channel == 'updater')
                        resp.updater_version = version;
                    else
                        resp.versions.push(version);
                }
            }
            resolve(resp);
        });
    });
}

export async function newest_version(current_version: Version, channel?: string) : Promise<UpdateVersion | undefined> {
    if(!app.getAppPath().endsWith(".asar")) {
        throw "You cant run an update when you're executing the source code!";
    }
    const data = await load_data();
    let had_data = false;
    for(const version of data.versions) {
        if(version.arch == os.arch() && version.platform == os.platform()) {
            if(!channel || version.channel == channel) {
                if(!current_version || version.version.newer_than(current_version))
                    return version;
                else
                    had_data = true;
            }
        }
    }

    if(!had_data)
        throw "Missing data";
    return undefined;
}

export async function extract_updater(update_file: string) {
    if(!fs.existsSync(update_file)) throw "Missing update file!";


    let parent_path = app.getAppPath();
    if(parent_path.endsWith(".asar")) {
        parent_path = path.join(parent_path, "..", "..");
        parent_path = fs.realpathSync(parent_path);
    }

    let post_path;
    if(os.platform() == "linux")
        post_path = parent_path + "/update-installer";
    else
        post_path = parent_path + "/update-installer.exe";

    const source = fs.createReadStream(update_file);
    const extract = tar.extract();
    await new Promise(resolve => {
        let updater_found = false;
        source.on('end', () => {
            if(!updater_found) {
                console.error("Failed to extract the updater (Updater hasn't been found!)");
                resolve(); //FIXME use reject!
            }
            resolve();
        });

        extract.on('entry', (header: Headers, stream, callback) => {
            stream.on('end', callback);
            console.log("Got entry " + header.name);

            if(header.name == "./update-installer" || header.name == "./update-installer.exe") {
                console.log("Found updater! (" + header.size + ")");
                console.log("Extracting to %s", post_path);
                const s = fs.createWriteStream(post_path);
                stream.pipe(s).on('finish', event => {
                    console.log("Updater extracted and written!");
                    updater_found = true;
                    resolve();
                });
            } else {
                stream.resume(); //Drain the stream
            }
        });


        source.pipe(extract);
    });
}

export async function update_updater() : Promise<void> {
    //TODO here
    return Promise.resolve();
}

function data_directory() : string {
    return electron.app.getPath('userData');
}

function get_update_file(channel: string, version: Version) : string {
    let _path = fs.realpathSync(data_directory());

    const name = channel + "_" + version.major + "_" + version.minor + "_" + version.patch + "_" + version.build + ".tar";
    return path.join(_path, "app_versions", name);
}

export interface ProgressState {
    percent: number, // Overall percent (between 0 to 1)
    speed: number,  // The download speed in bytes/sec
    size: {
        total: number, // The total payload size in bytes
        transferred: number// The transferred payload size in bytes
    },
    time: {
        elapsed: number,// The total elapsed seconds since the start (3 decimals)
        remaining: number // The remaining seconds to finish (3 decimals)
    }
}

export async function download_version(channel: string, version: Version, status?: (state: ProgressState) => any) : Promise<string> {
    const target_path = get_update_file(channel, version);
    console.log("Downloading version %s to %s", version.toString(false), target_path);
    if(fs.existsSync(target_path)) {
        /* TODO test if this file is valid and can be used */
        try {
            await fs.remove(target_path);
        } catch(error) {
            throw "Failed to remove old file: " + error;
        }
    }

    try {
        await fs.mkdirp(path.dirname(target_path));
    } catch(error) {
        throw "Failed to make target directory: " + path.dirname(target_path);
    }

    const url = server_url() + "/api.php?" + querystring.stringify({
        type: "update-download",
        platform: os.platform(),
        arch: os.arch(),
        version: version.toString(),
        channel: channel
    });
    console.log("Downloading update from %s. (%s)", server_url(), url);
    return new Promise<string>((resolve, reject) => {
        let fired = false;
        let stream = progress(request.get(url, {
            timeout: 2000
        }, (error, response, body) => {
            if(!response || response.statusCode != 200) {
                let info;
                try {
                    info = JSON.parse(body)
                } catch(e) {
                    info = {"msg": "!-- failed to parse json --!"};
                }
                if(!fired && (fired = true))
                    setImmediate(reject, "Invalid status code (" + (response || {statusCode: -1}).statusCode + "|" + (info || {"msg": "undefined"}).msg + ")");
                return;
            }
        })).on('progress', _state => status ? status(_state) : {}).on('error', error => {
            console.warn("Encountered error within download pipe. Ignoring error: %o", error);
        }).on('end', function () {
            console.log("Update downloaded successfully. Waiting for write stream to finish.");
            if(status)
                status({
                    percent: 1,
                    speed: 0,
                    size: { total: 0, transferred: 0},
                    time: { elapsed: 0, remaining: 0}
                })
        });

        console.log("Decompressing update package while streaming!");
        stream = stream.pipe(zlib.createGunzip());
        stream.pipe(fs.createWriteStream(target_path, {
            autoClose: true
        })).on('finish', () => {
            console.log("Write stream has finished. Download successfully.");
            if(!fired && (fired = true))
                setImmediate(resolve, target_path);
        }).on('error', error => {
            console.log("Write stream encountered an error while downloading update. Error: %o", error);
            if(!fired && (fired = true))
                setImmediate(reject,"failed to write");
        });
    });
}

if(typeof(String.prototype.trim) === "undefined")
{
    String.prototype.trim = function()
    {
        return String(this).replace(/^\s+|\s+$/g, '');
    };
}

export async function test_file_accessibility(update_file: string) : Promise<string[]> {
    if(os.platform() === "win32")
        return []; /* within windows the update installer request admin privileges if required */

    const original_fs = require('original-fs');
    if(!fs.existsSync(update_file))
        throw "Missing update file (" + update_file + ")";

    let parent_path = app.getAppPath();
    if(parent_path.endsWith(".asar")) {
        parent_path = path.join(parent_path, "..", "..");
        parent_path = fs.realpathSync(parent_path);
    }

    const test_access = async (file: string, mode: number) => {
        return await new Promise<NodeJS.ErrnoException>(resolve => original_fs.access(file, mode, resolve));
    };

    let code = await test_access(update_file, original_fs.constants.R_OK);
    if(code)
        throw "Failed test read for update file. (" + update_file + " results in " + code.code + ")";

    const fstream = original_fs.createReadStream(update_file);
    const tar_stream = tar.extract();

    const errors: string[] = [];
    const tester = async (header: Headers) => {
        const entry_path = path.normalize(path.join(parent_path, header.name));
        if(header.type == "file") {
            if(original_fs.existsSync(entry_path)) {
                code = await test_access(entry_path, original_fs.constants.W_OK);
                if(code)
                    errors.push("Failed to acquire write permissions for file " + entry_path + " (Code " + code.code + ")");
            } else {
                let directory = path.dirname(entry_path);
                while(directory.length != 0 && !original_fs.existsSync(directory))
                    directory = path.normalize(path.join(directory, ".."));

                code = await test_access(directory, original_fs.constants.W_OK);
                if(code) errors.push("Failed to acquire write permissions for directory " + entry_path + " (Code " + code.code + ". Target directory " + directory + ")");
            }
        } else if(header.type == "directory") {
            let directory = path.dirname(entry_path);
            while(directory.length != 0 && !original_fs.existsSync(directory))
                directory = path.normalize(path.join(directory, ".."));

            code = await test_access(directory, original_fs.constants.W_OK);
            if(code) errors.push("Failed to acquire write permissions for directory " + entry_path + " (Code " + code.code + ". Target directory " + directory + ")");
        }
    };

    tar_stream.on('entry', (header: Headers, stream, next) => {
        tester(header).catch(error => {
            console.log("Emit out of tar_stream.on('entry' ...)");
            tar_stream.emit('error', error);
        }).then(() => {
            stream.on('end', next);
            stream.resume();
        });
    });

    fstream.pipe(tar_stream);
    try {
        await new Promise((resolve, reject) => {
            tar_stream.on('finish', resolve);
            tar_stream.on('error', error => { reject(error); });
        });
    } catch(error) {
        throw "Failed to list files within tar: " + error;
    }

    return errors;
}

namespace install_config {
    export interface LockFile {
        filename: string;
        timeout: number;
        "error-id": string;
    }
    export interface MoveFile {
        source: string;
        target: string;
        "error-id": string;
    }
    export interface ConfigFile {
        version: number;

        backup: boolean;
        "backup-directory": string;

        "callback_file": string;
        "callback_argument_fail": string;
        "callback_argument_success": string;

        moves: MoveFile[];
        locks: LockFile[];
    }
}

async function build_install_config(source_root: string, target_root: string) : Promise<install_config.ConfigFile> {
    console.log("Building update install config for target directory: %s. Update source: %o", target_root, source_root);
    const result: install_config.ConfigFile = { } as any;

    result.version = 1;

    result.backup = true;

    {
        const data = path.parse(source_root);
        result["backup-directory"] = path.join(data.dir, data.name + "_backup");
    }

    result.callback_file = app.getPath("exe");
    result.callback_argument_fail = "--no-single-instance --update-failed-new=";
    result.callback_argument_success = "--no-single-instance --update-succeed-new=";

    result.moves = [];
    result.locks = [
        {
            "error-id": "main-exe-lock",
            filename: app.getPath("exe"),
            timeout: 5000
        }
    ];

    const ignore_list = [
        "update-installer.exe", "update-installer"
    ];

    const dir_walker = async (relative_path: string) => {
        const source_directory = path.join(source_root, relative_path);
        const target_directory = path.join(target_root, relative_path);

        let files: string[];
        try {
            files = await util.promisify(ofs.readdir)(source_directory);
        } catch(error) {
            console.warn("Failed to iterate over source directory \"%s\": %o", source_directory, error);
            return;
        }

        for(const file of files) {
            let _exclude = false;
            for(const exclude of ignore_list) {
                if(exclude == file) {
                    console.debug("Ignoring file to update (%s/%s)", relative_path, file);
                    _exclude = true;
                    break;
                }
            }
            if(_exclude)
                continue;

            const source_file = path.join(source_directory, file);
            const target_file = path.join(target_directory, file);

            //TODO check if file content has changed else ignore?

            const info = await util.promisify(ofs.stat)(source_file);
            if(info.isDirectory()) {
                await dir_walker(path.join(relative_path, file));
            } else {
                /* TODO: ensure its a file! */
                result.moves.push({
                    "error-id": "move-file-" + result.moves.length,
                    source: source_file,
                    target: target_file
                });
            }
        }
    };

    await dir_walker(".");
    return result;
}

export async function execute_update(update_file: string, restart_callback: (callback: () => void) => any) : Promise<void> {
    let application_path = app.getAppPath();
    if(application_path.endsWith(".asar")) {
        console.log("App path points to ASAR file (Going up to root directory)");
        application_path = await fs.realpath(path.join(application_path, "..", ".."));
    } else if(await fs.pathExists(application_path) && (await fs.stat(application_path)).isFile())
        application_path = path.dirname(application_path);

    console.log("Located target app path: %s", application_path);
    console.log("Using update file: %s", update_file);

    const temp_directory = path.join(app.getPath("temp"), "teaclient_update_" + Math.random().toString(36).substring(7));
    {
        console.log("Preparing update source directory at %s", temp_directory);
        try {
            await fs.mkdirp(temp_directory)
        } catch(error) {
            console.error("failed to create update source directory: %o", error);
            throw "failed to create update source directory";
        }

        const source = fs.createReadStream(update_file);
        const extract = tar.extract();

        extract.on('entry', (header: Headers, stream: PassThrough, callback) => {
            const extract = async (header: Headers, stream: PassThrough) => {
                const target_file = path.join(temp_directory, header.name);
                console.debug("Extracting entry %s of type %s to %s", header.name, header.type, target_file);

                if(header.type == "directory") {
                    await fs.mkdirp(target_file);
                } else if(header.type == "file") {
                    {
                        const directory = path.parse(target_file).dir;
                        console.debug("Testing for directory: %s", directory);
                        if(!(await util.promisify(ofs.exists)(directory)) || !(await util.promisify(ofs.stat)(directory)).isDirectory()) {
                            console.log("Creating directory %s", directory);
                            try {
                                await fs.mkdirp(directory);
                            } catch(error) {
                                console.warn("failed to create directory for file %s", header.type);
                            }
                        }

                    }
                    const write_stream = ofs.createWriteStream(target_file);
                    try {
                        await new Promise((resolve, reject) => {
                            stream.pipe(write_stream)
                                .on('error', reject)
                                .on('finish', resolve);
                        });
                        return; /* success */
                    } catch(error) {
                        console.error("Failed to extract update file %s: %o", header.name, error);
                    }
                } else {
                    console.debug("Skipping this unknown file type");
                }
                stream.resume(); /* drain the stream */
            };
            extract(header, stream).catch(error => {
                console.log("Ignoring file %s due to an error: %o", header.name, error);
            }).then(() => {
                callback();
            });
        });


        source.pipe(extract);
        try {
            await new Promise((resolve, reject) => {
                extract.on('finish', resolve);
                extract.on('error', reject);
            });
        } catch(error) {
            console.error("Failed to unpack update: %o", error);
            throw "update unpacking failed";
        }
    }
    /* the "new" environment should now be available at 'temp_directory' */
    console.log("Update unpacked successfully. Building update extractor file.");

    let install_config;
    try {
        install_config = await build_install_config(temp_directory, application_path);
    } catch(error) {
        console.error("Failed to build update installer config: %o", error);
        throw "failed to build update installer config";
    }

    const log_file = path.join(temp_directory, "update-log.txt");
    const config_file = path.join(temp_directory, "update_install.json");
    console.log("Writing config to %s", config_file);
    try {
        await fs.writeJSON(config_file, install_config);
    } catch(error) {
        console.error("Failed to write update install config file: %s", error);
        throw "failed to write update install config file";
    }

    const update_installer = path.join(application_path, "update-installer" + (os.platform() === "win32" ? ".exe" : ""));
    if(!(await fs.pathExists(update_installer))) {
        console.error("Missing update installer! Supposed to be at %s", update_installer);
        throw "Missing update installer!";
    } else {
        console.log("Using update installer located at %s", update_installer);
    }

    if(os.platform() == "linux") {
        console.log("Executing update install on linux");

        //We have to unpack it later
        const rest_callback = () => {
            console.log("Executing command %s with args %o", update_installer, [log_file, config_file]);
            try {
                let result = child_process.spawnSync(update_installer, [log_file, config_file]);
                if(result.status != 0) {
                    console.error("Failed to execute update installer! Return code: %d", result.status);
                    dialog.showMessageBox({
                        buttons: ["update now", "remind me later"],
                        title: "Update available",
                        message:
                            "Failed to execute update installer\n" +
                            "Installer exited with code " + result.status
                    } as MessageBoxOptions);
                }
            } catch(error) {
                console.error("Failed to execute update installer (%o)", error);
                if("errno" in error) {
                    const errno = error as ErrnoException;
                    if(errno.errno == EPERM) {
                        dialog.showMessageBox({
                            buttons: ["quit"],
                            title: "Update execute failed",
                            message: "Failed to execute update installer. (No permissions)\nPlease execute the client with admin privileges!"
                        } as MessageBoxOptions);
                        return;
                    }
                    dialog.showMessageBox({
                        buttons: ["quit"],
                        title: "Update execute failed",
                        message: "Failed to execute update installer.\nError: " + errno.message
                    } as MessageBoxOptions);
                    return;
                }
                dialog.showMessageBox({
                    buttons: ["quit"],
                    title: "Update execute failed",
                    message: "Failed to execute update installer.\nLookup console for more detail"
                } as MessageBoxOptions);
                return;
            }

            if(electron.app.hasSingleInstanceLock())
                electron.app.releaseSingleInstanceLock();

            const ids = child_process.execSync("pgrep TeaClient").toString().split(os.EOL).map(e => e.trim()).reverse().join(" ");
            console.log("Executing %s", "kill -9 " + ids);
            child_process.execSync("kill -9 " + ids);
        };
        restart_callback(rest_callback);
    } else {
        console.log("Executing update install on windows");

        //We have to unpack it later
        const rest_callback = () => {
            let pipe = child_process.spawn(update_installer, [log_file, config_file], {
                detached: true,
                cwd: application_path,
                stdio: 'ignore',
            });
            pipe.unref();
            app.quit();
        };
        restart_callback(rest_callback);
    }
}

export async function current_version() : Promise<Version> {
    if(process_args.has_value(Arguments.UPDATER_LOCAL_VERSION))
        return parse_version(process_args.value(Arguments.UPDATER_LOCAL_VERSION));

    let parent_path = app.getAppPath();
    if(parent_path.endsWith(".asar")) {
        parent_path = path.join(parent_path, "..", "..");
        parent_path = fs.realpathSync(parent_path);
    }
    try {
        const info = await fs.readJson(path.join(parent_path, "app_version.json"));
        let result = parse_version(info["version"]);
        result.timestamp = info["timestamp"];
        return result;
    } catch (error) {
        console.log("Got no version!");
        return new Version(0, 0, 0, 0, 0);
    }
}

async function minawait<T>(object: Promise<T>, time: number) : Promise<T> {
    const begin = Date.now();
    const r = await object;
    const end = Date.now();
    if(end - begin < time)
        await new Promise(resolve => setTimeout(resolve, time + begin - end));
    return r;
}

export let update_restart_pending = false;
export async function execute_graphical(channel: string, ask_install: boolean) : Promise<Boolean> {
    const electron = require('electron');

    const ui_debug = process_args.has_flag(Arguments.UPDATER_UI_DEBUG);
    const window = new electron.BrowserWindow({
        show: false,
        width: ui_debug ? 1200 : 600,
        height: ui_debug ? 800 : 400,

        webPreferences: {
            devTools: true,
            nodeIntegration: true,
            javascript: true
        }
    });

    window.loadFile(path.join(path.dirname(module.filename), "ui", "index.html"));
    if(ui_debug) {
        window.webContents.openDevTools();
    }
    await new Promise(resolve => window.on('ready-to-show', resolve));
    window.show();
    await winmgr.apply_bounds('update-installer', window);
    winmgr.track_bounds('update-installer', window);

    const current_vers = await current_version();
    console.log("Current version: " + current_vers.toString(true));

    console.log("Showed");
    const set_text = text => window.webContents.send('status-update-text', text);
    const set_error = text => window.webContents.send('status-error', text);
    const set_progress = progress => window.webContents.send('status-update', progress);
    const await_exit = () => { return new Promise(resolve => window.on('closed', resolve))};
    const await_version_confirm = version => {
        const id = "version-accept-" + Date.now();
        window.webContents.send('status-confirm-update', id, current_vers, version);
        return new Promise((resolve, reject) => {
            window.on('closed', () => resolve(false));
            ipcMain.once(id, (event, result) => {
                console.log("Got response %o", result);
                resolve(result);
            });
        });
    };
    const await_confirm_execute = () => {
        const id = "status-confirm-execute-" + Date.now();
        window.webContents.send('status-confirm-execute', id);
        return new Promise((resolve, reject) => {
            window.on('closed', () => resolve(false));
            ipcMain.once(id, (event, result) => {
                console.log("Got response %o", result);
                resolve(result);
            });
        });
    };

    set_text("Loading data");
    let version: UpdateVersion;
    try {
        version = await minawait(newest_version(process_args.has_flag(Arguments.UPDATER_ENFORCE) ? undefined : current_vers, channel), 3000);
    } catch (error) {
        set_error("Failed to get newest information:<br>" + error);
        await await_exit();
        return false;
    }
    console.log("Got version %o", version);

    if(!version) {
        set_error("You're already on the newest version!");
        await await_exit();
        return false;
    }

    if(ask_install) {
        try {
            const test = await await_version_confirm(version.version);
            if(!test) {
                window.close();
                return false;
            }
        } catch (error) {
            console.dir(error);
            window.close();
            return false;
        }
    }

    set_text("Updating to version " + version.version.toString() + "<br>Downloading....");
    let update_path: string;
    try {
        update_path = await download_version(version.channel, version.version, status => { setImmediate(set_progress, status.percent); });
    } catch (error) {
        set_error("Failed to download version: <br>" + error);
        console.error(error);
        await await_exit();
        return false;
    }

    try {
        const inaccessible = await test_file_accessibility(update_path);
        if(inaccessible.length > 0) {
            console.log("Failed to access the following files:");
            for(const fail of inaccessible)
                console.log(" - " + fail);

            if(os.platform() == "linux") {
                set_error("Failed to access target files.<br>Please execute this app with administrator (sudo) privileges.<br>Use the following command:<br><p>" +
                    "sudo " + path.normalize(app.getAppPath()) + " --update-execute=\"" + path.normalize(update_path) + "\"</p>");
                await await_exit();
                return false;
            } else if(os.platform() == "win32") {
                /* the updater asks for admin rights anyway :/ */
            }
        }
    } catch(error) {
        set_error("Failed to access target files.<br>You may need to execute the TeaClient as Administrator!<br>Error: " + error);
        await await_exit();
        return false;
    }

    if(!await await_confirm_execute()) {
        window.close();
        return false;
    }

    set_text("Extracting update installer...<br>Please wait");
    try {
        await extract_updater(update_path);
    } catch(error) {
        console.error("Failed to update the updater! (%o)", error);
        set_error("Failed to update the update installer.\nUpdate failed!");
        await await_exit();
        return false;
    }
    set_text("Executing update...<br>Please wait");

    try {
        await execute_update(update_path, callback => {
            _main_windows.set_prevent_instant_close(true);
            update_restart_pending = true;
            window.close();
            callback();
        });
    } catch (error) {
        dialog.showErrorBox("Update error", "Failed to execute update!\n" + error);
        return false;
    }
    return true;
}

export let update_question_open = false;
async function check_update(channel: string) {
    let version: UpdateVersion;
    try {
        version = await newest_version(await current_version(), channel);
    } catch(error) {
        console.warn("failed check for newer versions!");
        console.error(error);
        return;
    }
    if(version) {
        update_question_open = true;
        dialog.showMessageBox({
            buttons: ["update now", "remind me later"],
            title: "TeaClient: Update available",
            message:
            "There is an update available!\n" +
            "Should we update now?\n" +
            "\n" +
            "Current version: " + (await current_version()).toString() + "\n" +
            "Target version: " + version.version.toString()
        } as MessageBoxOptions).then(result => {
            if(result.response == 0) {
                execute_graphical(channel, false).then(() => {
                    update_question_open = false;
                });
            } else {
                update_question_open = false;
            }
        });
    }
}

let update_task: Timer;
export function start_auto_update_check() {
    if(update_task) return;
    update_task = setInterval(check_update, 2 * 60 * 60 * 1000);
    setImmediate(check_update);
}

export function stop_auto_update_check() {
    clearInterval(update_task);
    update_task = undefined;
}

export async function selected_channel() : Promise<string> {
    return process_args.has_value(Arguments.UPDATER_CHANNEL) ? process_args.value(Arguments.UPDATER_CHANNEL) : "release";
}