export function readText(text: string): void {
    if (window.speechSynthesis.getVoices().length === 0) {
        // should try to warn user? This apparently can happen on some machines
        // TODO: Implement when there's an error feedback mechanism
        throw new Error("No voice found: cannot use Text-To-Speech API")
    }

    const utterance = new SpeechSynthesisUtterance(text)

    const pitch = Config.get("ttspitch")
    const voice = Config.get("ttsvoice")
    const volume = Config.get("ttsvolume")
    const rate = Config.get("ttsrate")

    if (pitch >= 0 && pitch < 2) utterance.pitch = pitch

    if (volume >= 0 && volume <= 1) utterance.volume = volume

    if (rate >= 0.1 && rate <= 10) utterance.rate = rate

    const voiceObj = getVoiceFromName(voice)
    if (voiceObj) {
        utterance.voice = voiceObj
    }

    window.speechSynthesis.speak(utterance)
}

    addContentStateChangedListener((property, oldMode, oldValue, newValue) => {
        let mode = newValue
        let suffix = ""
        let result = ""
        if (property !== "mode") {
            if (property === "suffix") {
                mode = oldMode
                suffix = newValue
            } else {
                return
            }
        }

        const privateMode = browser.extension.inIncognitoContext
            ? "TridactylPrivate"
            : ""
        statusIndicator.className =
            "cleanslate TridactylStatusIndicator " + privateMode
        if (
            dom.isTextEditable(document.activeElement) &&
            !["input", "ignore"].includes(mode)
        ) {
            statusIndicator.textContent = "insert"
            // this doesn't work; statusIndicator.style is full of empty string
            // statusIndicator.style.borderColor = "green !important"
            // need to fix loss of focus by click: doesn't do anything here.
        } else if (
            mode === "insert" &&
            !dom.isTextEditable(document.activeElement)
        ) {
            statusIndicator.textContent = "normal"
            // statusIndicator.style.borderColor = "lightgray !important"
        } else {
            result = mode
        }
        const modeindicatorshowkeys = Config.get("modeindicatorshowkeys")
        if (modeindicatorshowkeys === "true" && suffix !== "") {
            result = mode + " " + suffix
        }
        logger.debug(
            "statusindicator: ",
            result,
            ";",
            "config",
            modeindicatorshowkeys,
        )
        statusIndicator.textContent = result
        statusIndicator.className +=
            " TridactylMode" + statusIndicator.textContent

        if (config.get("modeindicator") !== "true") statusIndicator.remove()
    })

    /**
     * Config-aware logging function.
     *
     * @param level         the level of the logging - if <= configured, the message
     *                      will be shown
     *
     * @return              logging function: this is returned as a function to
     *                      retain the call site
     */
    private log(level: Config.LoggingLevel) {
        const configedLevel = Config.get("logging", this.logModule)

        if (LevelToNum.get(level) <= LevelToNum.get(configedLevel)) {
            // hand over to console.log, error or debug as needed
            switch (level) {
                case "error":
                    // TODO: replicate this for other levels, don't steal focus
                    // work out how to import messaging/webext without breaking everything
                    return async (...message) => {
                        console.error(...message)
                        return browser.runtime.sendMessage({
                            type: "controller_background",
                            command: "acceptExCmd",
                            args: ["fillcmdline_nofocus # " + message.join(" ")],
                        })
                    }
                case "warning":
                    return console.warn
                case "info":
                    return console.log
                case "debug":
                    return console.debug
            }
        }

        // do nothing with the message
        return function(...args) {}
    }

export function expandExstr(
    exstr: string,
    aliases = config.get("exaliases"),
    prevExpansions: string[] = [],
): string {
    // Split on whitespace
    const [command] = exstr.trim().split(/\s+/)

    // Base case: alias not found; return original command
    if (aliases[command] === undefined) {
        return exstr
    }

    // Infinite loop detected
    if (prevExpansions.includes(command)) {
        throw `Infinite loop detected while expanding aliases. Stack: ${prevExpansions}.`
    }

    // Add command to expansions used so far
    prevExpansions.push(command)

    // Alias exists; expand it recursively
    return expandExstr(
        exstr.replace(command, aliases[command]),
        aliases,
        prevExpansions,
    )
}

export function shouldNagForVersion(version: TriVersionFeedItem) {
    const timeSinceRelease = (Date.now() - version.releaseDate.getTime()) / 1000
    const updateNagWaitSeconds = Config.get("update", "nagwait") * 24 * 60 * 60
    const newerThanInstalled = SemverCompare(version.version, getInstalledPatchVersion()) > 0

    return newerThanInstalled && timeSinceRelease > updateNagWaitSeconds
}

export function parser(conf, keys): keyseq.ParserResponse {
    let maps: any = config.get(conf)
    if (maps === undefined) throw new Error("No binds defined for this mode. Reload page with <C-r> and add binds, e.g. :bind --mode=[mode] <Esc> mode normal")

    // If so configured, translate keys using the key translation map
    if (config.get("keytranslatemodes")[conf] === "true") {
        const translationmap = config.get("keytranslatemap")
        keyseq.translateKeysUsingKeyTranslateMap(keys, translationmap)
    }

    // Remove unbound keys
    maps = Object.entries(maps).filter(([k, v]) => v !== "")
    // Convert to KeyMap
    maps = keyseq.mapstrMapToKeyMap(new Map(maps))

    return keyseq.parse(keys, maps)
}

export async function getLatestVersion(force_check = false) {
    const pastUpdateInterval = secondsSinceLastCheck() > Config.get("update", "checkintervalsecs")
    if (force_check || pastUpdateInterval) {
        await updateVersion()
    }

    return highestKnownVersion
}

export async function editor(file: string, line: number, col: number, content?: string) {
    if (content !== undefined) await write(file, content)
    const editorcmd =
        (config.get("editorcmd") === "auto"
            ? await getBestEditor()
            : config.get("editorcmd"))
        .replace(/%l/, line)
        .replace(/%c/, col)
    let exec
    if (editorcmd.indexOf("%f") !== -1) {
        exec = await run(editorcmd.replace(/%f/, file))
    } else {
        exec = await run(editorcmd + " " + file)
    }
    if (exec.code != 0)
        return exec
    return read(file)
}

function protectSlash(e) {
    config.get("blacklistkeys").map(
        protkey => {
            if (protkey.indexOf(e.key) !== -1 && contentState.mode === "normal") {
                e.cancelBubble = true
                e.stopImmediatePropagation()
            }
        }
    )
}

export function naggedForVersion(version: TriVersionFeedItem) {
    const lastNaggedVersion = Config.get("update", "lastnaggedversion")
    if (lastNaggedVersion) {
        // If the version is <= the last nagged version, we've already
        // nagged for it.
        return SemverCompare(version.version, lastNaggedVersion) <= 0
    } else {
        return false
    }
}