import {createErrorModal, createInfoModal, createInputModal, createModal, Modal} from "tc-shared/ui/elements/Modal";
import {sliderfy} from "tc-shared/ui/elements/Slider";
import {settings, Settings} from "tc-shared/settings";
import * as sound from "tc-shared/audio/Sounds";
import {manager, setSoundMasterVolume, Sound} from "tc-shared/audio/Sounds";
import * as profiles from "tc-shared/profiles/ConnectionProfile";
import {ConnectionProfile} from "tc-shared/profiles/ConnectionProfile";
import {IdentitifyType} from "tc-shared/profiles/Identity";
import {TeaForumIdentity} from "tc-shared/profiles/identities/TeaForumIdentity";
import {TeaSpeakIdentity} from "tc-shared/profiles/identities/TeamSpeakIdentity";
import {NameIdentity} from "tc-shared/profiles/identities/NameIdentity";
import {LogCategory, logDebug, logError, logTrace, logWarn} from "tc-shared/log";
import * as i18n from "tc-shared/i18n/localize";
import {RepositoryTranslation, TranslationRepository} from "tc-shared/i18n/localize";
import {Registry} from "tc-shared/events";
import * as i18nc from "../../i18n/CountryFlag";
import * as forum from "tc-shared/profiles/identities/teaspeak-forum";
import {formatMessage, set_icon_size} from "tc-shared/ui/frames/chat";
import {spawnTeamSpeakIdentityImport, spawnTeamSpeakIdentityImprove} from "tc-shared/ui/modal/ModalIdentity";
import {getAudioBackend, OutputDevice} from "tc-shared/audio/Player";
import {KeyMapSettings} from "tc-shared/ui/modal/settings/Keymap";
import * as React from "react";
import * as ReactDOM from "react-dom";
import {NotificationSettings} from "tc-shared/ui/modal/settings/Notifications";
import {initialize_audio_microphone_controller} from "tc-shared/ui/modal/settings/Microphone";
import {MicrophoneSettings} from "tc-shared/ui/modal/settings/MicrophoneRenderer";
import {getBackend} from "tc-shared/backend";
import {MicrophoneSettingsEvents} from "tc-shared/ui/modal/settings/MicrophoneDefinitions";
import {promptYesNo} from "tc-shared/ui/modal/yes-no/Controller";

type ProfileInfoEvent = {
    id: string,
    name: string,
    nickname: string,
    identity_type: "teaforo" | "teamspeak" | "nickname",

    identity_forum?: {
        valid: boolean,
        fallback_name: string
    },
    identity_nickname?: {
        name: string,
        fallback_name: string
    },
    identity_teamspeak?: {
        unique_id: string,
        fallback_name: string
    }
}

export interface SettingProfileEvents {
    "reload-profile": { profile_id?: string },
    "select-profile": { profile_id: string },

    "query-profile-list": { },
    "query-profile-list-result": {
        status: "error" | "success" | "timeout",

        error?: string;
        profiles?: ProfileInfoEvent[]
    }

    "query-profile": { profile_id: string },
    "query-profile-result": {
        status: "error" | "success" | "timeout",
        profile_id: string,

        error?: string;
        info?: ProfileInfoEvent
    },

    "select-identity-type": {
        profile_id: string,
        identity_type: "teamspeak" | "teaforo" | "nickname" | "unset"
    },

    "query-profile-validity": { profile_id: string },
    "query-profile-validity-result": {
        profile_id: string,
        status: "error" | "success" | "timeout",

        error?: string,
        valid?: boolean
    }

    "create-profile": { name: string },
    "create-profile-result": {
        status: "error" | "success" | "timeout",
        name: string;

        profile_id?: string;
        error?: string;
    },

    "delete-profile": { profile_id: string },
    "delete-profile-result": {
        status: "error" | "success" | "timeout",
        profile_id: string,
        error?: string
    }

    "set-default-profile": { profile_id: string },
    "set-default-profile-result": {
        status: "error" | "success" | "timeout",

        /* the profile which now has the id "default" */
        old_profile_id: string,

        /* the "default" profile which now has a new id */
        new_profile_id?: string

        error?: string;
    }

    /* profile name events */
    "set-profile-name": {
        profile_id: string,
        name: string
    },
    "set-profile-name-result": {
        status: "error" | "success" | "timeout",
        profile_id: string,
        name?: string
    },

    /* profile nickname events */
    "set-default-name": {
        profile_id: string,
        name: string | null
    },
    "set-default-name-result": {
        status: "error" | "success" | "timeout",
        profile_id: string,
        name?: string | null
    },

    "query-identity-teamspeak": { profile_id: string },
    "query-identity-teamspeak-result": {
        status: "error" | "success" | "timeout",
        profile_id: string,

        error?: string,
        level?: number
    }

    "set-identity-name-name": { profile_id: string, name: string },
    "set-identity-name-name-result": {
        status: "error" | "success" | "timeout",
        profile_id: string,

        error?: string,
        name?: string
    },

    "generate-identity-teamspeak": { profile_id: string },
    "generate-identity-teamspeak-result": {
        profile_id: string,
        status: "error" | "success" | "timeout",

        error?: string,

        level?: number
        unique_id?: string
    },

    "improve-identity-teamspeak-level": { profile_id: string },
    "improve-identity-teamspeak-level-update": {
        profile_id: string,
        new_level: number
    },

    "import-identity-teamspeak": { profile_id: string },
    "import-identity-teamspeak-result": {
        profile_id: string,

        level?: number
        unique_id?: string
    }

    "export-identity-teamspeak": {
        profile_id: string,
        filename: string
    },


    "setup-forum-connection": {}
}

export function spawnSettingsModal(default_page?: string): Modal {
    let modal: Modal;
    modal = createModal({
        header: tr("Settings"),
        body: () => {
            const tag = $("#tmpl_settings").renderTag().dividerfy();

            /* general "tab" mechanic */
            const left = tag.find("> .left");
            const right = tag.find("> .right");
            {
                left.find(".entry:not(.group)").on('click', event => {
                    const entry = $(event.target);
                    right.find("> .container").addClass("hidden");
                    left.find(".selected").removeClass("selected");

                    const target = entry.attr("container");
                    if (!target) return;

                    right.find("> .container." + target).removeClass("hidden");
                    entry.addClass("selected");
                })
            }

            /* initialize all tabs */

            /* enable one tab */
            {
                left.find(".entry[container" + (default_page ? ("='" + default_page + "'") : "") + "]").first().trigger('click');
            }

            return tag;
        },
        footer: null
    });
    modal.htmlTag.find(".modal-body").addClass("modal-settings");

    settings_general_application(modal.htmlTag.find(".right .container.general-application"), modal);
    settings_general_language(modal.htmlTag.find(".right .container.general-language"), modal);
    settings_general_chat(modal.htmlTag.find(".right .container.general-chat"), modal);
    settings_general_keymap(modal.htmlTag.find(".right .container.general-keymap"), modal);
    settings_general_notifications(modal.htmlTag.find(".right .container.general-notifications"), modal);
    settings_audio_microphone(modal.htmlTag.find(".right .container.audio-microphone"), modal);
    settings_audio_speaker(modal.htmlTag.find(".right .container.audio-speaker"), modal);
    settings_audio_sounds(modal.htmlTag.find(".right .container.audio-sounds"), modal);
    const update_profiles = settings_identity_profiles(modal.htmlTag.find(".right .container.identity-profiles"), modal);
    settings_identity_forum(modal.htmlTag.find(".right .container.identity-forum"), modal, update_profiles as any);

    modal.close_listener.push(() => {
        if (profiles.requires_save())
            profiles.save();
    });

    modal.open();
    return modal;
}

function settings_general_application(container: JQuery, modal: Modal) {
    /* hostbanner */
    {
        const option = container.find(".option-hostbanner-background") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_HOSTBANNER_BACKGROUND, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_HOSTBANNER_BACKGROUND));
    }

    /* font size */
    {
        const current_size = parseInt(getComputedStyle(document.body).fontSize); //settings.static_global(Settings.KEY_FONT_SIZE, 12);
        const select = container.find(".option-font-size");

        if (select.find("option[value='" + current_size + "']").length) {
            select.find("option[value='" + current_size + "']").prop("selected", true);
        } else {
            select.find("option[value='-1']").prop("selected", true);
        }

        select.on('change', event => {
            const value = parseInt(select.val() as string);
            settings.setValue(Settings.KEY_FONT_SIZE, value);
            logDebug(LogCategory.GENERAL, "Changed font size to %dpx", value);
        });
    }

    /* all permissions */
    {
        const option = container.find(".option-all-permissions") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_HOSTBANNER_BACKGROUND, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_PERMISSIONS_SHOW_ALL));
    }
}

function settings_general_language(container: JQuery, modal: Modal) {

    const container_entries = container.find(".container-list .entries");

    const tag_loading = container.find(".cover-loading");
    const template = $("#settings-translations-list-entry");

    const restart_hint = container.find(".restart-note").hide();

    const display_repository_info = (repository: TranslationRepository) => {
        const info_modal = createModal({
            header: tr("Repository info"),
            body: () => {
                return $("#settings-translations-list-entry-info").renderTag({
                    type: "repository",
                    name: repository.name,
                    url: repository.url,
                    contact: repository.contact,
                    translations: repository.translations || [],
                });
            },
            footer: () => {
                let footer = $.spawn("div");
                footer.addClass("modal-button-group");
                footer.css("margin-top", "5px");
                footer.css("margin-bottom", "5px");
                footer.css("text-align", "right");

                let buttonOk = $.spawn("button");
                buttonOk.text(tr("Close"));
                buttonOk.click(() => info_modal.close());
                footer.append(buttonOk);

                return footer;
            }
        });
        info_modal.open()
    };
    const display_translation_info = (translation: RepositoryTranslation, repository: TranslationRepository) => {
        const info_modal = createModal({
            header: tr("Translation info"),
            body: () => {
                const tag = $("#settings-translations-list-entry-info").renderTag({
                    type: "translation",
                    name: translation.name,
                    url: translation.path,
                    repository_name: repository.name,
                    contributors: translation.contributors || []
                });

                tag.find(".button-info").on('click', () => display_repository_info(repository));

                return tag;
            },
            footer: () => {
                let footer = $.spawn("div");
                footer.addClass("modal-button-group");
                footer.css("margin-top", "5px");
                footer.css("margin-bottom", "5px");
                footer.css("text-align", "right");

                let buttonOk = $.spawn("button");
                buttonOk.text(tr("Close"));
                buttonOk.click(() => info_modal.close());
                footer.append(buttonOk);

                return footer;
            }
        });
        info_modal.open()
    };

    const update_current_selected = () => {
        const container_current = container.find(".selected-language");
        container_current.empty().text(tr("Loading"));

        let current_translation: RepositoryTranslation;
        i18n.iterate_repositories(repository => {
            if (current_translation) return;
            for (const entry of repository.translations)
                if (i18n.config.translation_config().current_translation_path == entry.path) {
                    current_translation = entry;
                    return;
                }
        }).then(() => {
            container_current.empty();

            const language = current_translation ? current_translation.country_code : "gb";
            $.spawn("div").addClass("country flag-" + language.toLowerCase()).attr('title', i18nc.getCountryName(language, tr("Unknown language"))).appendTo(container_current);
            $.spawn("a").text(current_translation ? current_translation.name : tr("English (Default)")).appendTo(container_current);
        }).catch(error => {
            /* This shall never happen */
        });
    };

    const initially_selected = i18n.config.translation_config().current_translation_url;
    const update_list = () => {
        container_entries.empty();

        const currently_selected = i18n.config.translation_config().current_translation_url;
        //Default translation
        {
            const tag = template.renderTag({
                type: "default",
                selected: !currently_selected || currently_selected == "default",
                fallback_country_name: i18nc.getCountryName('gb'),
            });
            tag.on('click', () => {
                i18n.select_translation(undefined, undefined);
                container_entries.find(".selected").removeClass("selected");
                tag.addClass("selected");

                update_current_selected();
                restart_hint.toggle(initially_selected !== i18n.config.translation_config().current_translation_url);
            });
            tag.appendTo(container_entries);
        }

        {
            tag_loading.show();
            i18n.iterate_repositories(repo => {
                let repo_tag = container_entries.find("[repository=\"" + repo.unique_id + "\"]");
                if (repo_tag.length == 0) {
                    repo_tag = template.renderTag({
                        type: "repository",
                        name: repo.name || repo.url,
                        id: repo.unique_id
                    });

                    repo_tag.find(".button-delete").on('click', e => {
                        e.preventDefault();

                        promptYesNo({
                            title: tr("Are you sure?"),
                            question: tr("Do you really want to delete this repository?"),
                        }).then(answer => {
                            if (answer) {
                                i18n.delete_repository(repo);
                                update_list();
                            }
                        });
                    });
                    repo_tag.find(".button-info").on('click', e => {
                        e.preventDefault();
                        display_repository_info(repo);
                    });

                    container_entries.append(repo_tag);
                }

                for (const translation of repo.translations) {
                    const tag = template.renderTag({
                        type: "translation",
                        name: translation.name || translation.path,
                        id: repo.unique_id,
                        country_code: translation.country_code,
                        selected: i18n.config.translation_config().current_translation_path == translation.path,
                        fallback_country_name: i18nc.getCountryName('gb'),
                        country_name: i18nc.getCountryName((translation.country_code || "XX").toLowerCase()),
                    });
                    tag.find(".button-info").on('click', e => {
                        e.preventDefault();
                        display_translation_info(translation, repo);
                    });
                    tag.on('click', e => {
                        if (e.isDefaultPrevented()) return;
                        i18n.select_translation(repo, translation);
                        container_entries.find(".selected").removeClass("selected");
                        tag.addClass("selected");

                        update_current_selected();
                        restart_hint.toggle(initially_selected !== i18n.config.translation_config().current_translation_url);
                    });
                    tag.insertAfter(repo_tag);
                }
            }).then(() => tag_loading.hide()).catch(error => {
                logError(LogCategory.GENERAL, "Enexpected error happened: %o", error);
                /* this should NEVER happen */
            })
        }

    };

    /* button add repository */
    {
        container.find(".button-add-repository").on('click', () => {
            createInputModal(tr("Enter repository URL"), tr("Enter repository URL:"), text => {
                try {
                    new URL(text);
                    return true;
                } catch (error) {
                    return false;
                }
            }, url => {
                if (!url) return;

                tag_loading.show();
                i18n.load_repository(url as string).then(repository => {
                    i18n.register_repository(repository);
                    update_list();
                }).catch(error => {
                    tag_loading.hide();
                    createErrorModal("Failed to load repository", tr("Failed to query repository.<br>Ensure that this repository is valid and reachable.<br>Error: ") + error).open();
                })
            }).open();
        });
    }

    container.find(".button-restart").on('click', () => {
        if (__build.target === "web") {
            location.reload();
        } else {
            getBackend("native").reloadWindow();
        }
    });

    update_list();
    update_current_selected();
}

function settings_general_keymap(container: JQuery, modal: Modal) {
    const entry = <KeyMapSettings/>;
    ReactDOM.render(entry, container[0]);
    modal.close_listener.push(() => ReactDOM.unmountComponentAtNode(container[0]));
}

function settings_general_notifications(container: JQuery, modal: Modal) {
    const entry = <NotificationSettings/>;
    ReactDOM.render(entry, container[0]);
    modal.close_listener.push(() => ReactDOM.unmountComponentAtNode(container[0]));
}

function settings_general_chat(container: JQuery, modal: Modal) {
    /* timestamp format */
    {
        const option_fixed = container.find(".option-fixed-timestamps") as JQuery<HTMLInputElement>;
        const option_colloquial = container.find(".option-colloquial-timestamps") as JQuery<HTMLInputElement>;

        option_colloquial.on('change', event => {
            settings.setValue(Settings.KEY_CHAT_COLLOQUIAL_TIMESTAMPS, option_colloquial[0].checked);
        });

        option_fixed.on('change', event => {
            settings.setValue(Settings.KEY_CHAT_FIXED_TIMESTAMPS, option_fixed[0].checked);
            option_colloquial
                .prop("disabled", option_fixed[0].checked)
                .parents("label").toggleClass("disabled", option_fixed[0].checked);
            if (option_fixed[0].checked) {
                option_colloquial.prop("checked", false);
            } else {
                option_colloquial.prop("checked", settings.getValue(Settings.KEY_CHAT_COLLOQUIAL_TIMESTAMPS));
            }
        }).prop("checked", settings.getValue(Settings.KEY_CHAT_FIXED_TIMESTAMPS)).trigger('change');
    }

    {
        const option = container.find(".option-instant-channel-switch") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_SWITCH_INSTANT_CHAT, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_SWITCH_INSTANT_CHAT));
    }
    {
        const option = container.find(".option-instant-client-switch") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_SWITCH_INSTANT_CLIENT, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_SWITCH_INSTANT_CLIENT));
    }
    {
        const option = container.find(".option-colored-emojies") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_CHAT_COLORED_EMOJIES, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_CHAT_COLORED_EMOJIES));
    }

    {
        const option = container.find(".option-support-markdown") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_CHAT_ENABLE_MARKDOWN, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_CHAT_ENABLE_MARKDOWN));
    }
    {
        const option = container.find(".option-support-bbcode") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_CHAT_ENABLE_BBCODE, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_CHAT_ENABLE_BBCODE));
    }
    {
        const option = container.find(".option-url-tagging") as JQuery<HTMLInputElement>;
        option.on('change', event => {
            settings.setValue(Settings.KEY_CHAT_TAG_URLS, option[0].checked);
        }).prop("checked", settings.getValue(Settings.KEY_CHAT_TAG_URLS));
    }
    /* Icon size */
    {
        const container_slider = container.find(".container-icon-size .container-slider");
        const container_value = container.find(".container-icon-size .value");

        sliderfy(container_slider, {
            unit: '%',
            min_value: 25,
            max_value: 300,
            step: 5,
            initial_value: settings.getValue(Settings.KEY_ICON_SIZE),
            value_field: container_value
        });

        container_slider.on('change', event => {
            const value = parseInt(container_slider.attr("value") as string);
            settings.setValue(Settings.KEY_ICON_SIZE, value);
            logDebug(LogCategory.GENERAL, "Changed icon size to %sem", (value / 100).toFixed(2));

            set_icon_size((value / 100).toFixed(2) + "em");
        });
    }
}

function settings_audio_microphone(container: JQuery, modal: Modal) {
    const registry = new Registry<MicrophoneSettingsEvents>();
    initialize_audio_microphone_controller(registry);

    const entry = <MicrophoneSettings events={registry}/>;
    ReactDOM.render(entry, container[0]);
    modal.close_listener.push(() => {
        ReactDOM.unmountComponentAtNode(container[0]);
        registry.fire("notify_destroy");
    });

    return;
}

function settings_identity_profiles(container: JQuery, modal: Modal) {
    const registry = new Registry<SettingProfileEvents>();
    //registry.enable_debug("settings-identity");
    modal_settings.initialize_identity_profiles_controller(registry);
    modal_settings.initialize_identity_profiles_view(container, registry, {
        forum_setuppable: true
    });

    registry.on("setup-forum-connection", event => {
        modal.htmlTag.find('.entry[container="identity-forum"]').trigger('click');
    });
    return () => registry.fire("reload-profile");
}

function settings_audio_speaker(container: JQuery, modal: Modal) {
    /* devices */
    {
        const container_devices = container.find(".left .container-devices");
        const contianer_error = container.find(".left .container-error");

        const update_devices = () => {
            container_devices.children().remove();

            const current_selected = getAudioBackend().getCurrentDevice();
            const generate_device = (device: OutputDevice | undefined) => {
                const selected = device === current_selected || (typeof (current_selected) !== "undefined" && typeof (device) !== "undefined" && current_selected.deviceId == device.deviceId);

                const tag = $.spawn("div").addClass("device").toggleClass("selected", selected).append(
                    $.spawn("div").addClass("container-selected").append(
                        $.spawn("div").addClass("icon_em client-apply")
                    ),
                    $.spawn("div").addClass("container-name").append(
                        $.spawn("div").addClass("device-driver").text(
                            device ? (device.driver || "Unknown driver") : "No device"
                        ),
                        $.spawn("div").addClass("device-name").text(
                            device ? (device.name || "Unknown name") : "No device"
                        )
                    )
                );

                tag.on('click', event => {
                    if (tag.hasClass("selected"))
                        return;

                    const _old = container_devices.find(".selected");
                    _old.removeClass("selected");
                    tag.addClass("selected");

                    const targetDeviceId = device.deviceId || OutputDevice.NoDeviceId;
                    getAudioBackend().setCurrentDevice(targetDeviceId).then(() => {
                        logDebug(LogCategory.AUDIO, tr("Changed default speaker device"));
                        settings.setValue(Settings.KEY_SPEAKER_DEVICE_ID, targetDeviceId);
                    }).catch((error) => {
                        _old.addClass("selected");
                        tag.removeClass("selected");

                        logError(LogCategory.AUDIO, tr("Failed to change speaker to device %o: %o"), device, error);
                        createErrorModal(tr("Failed to change speaker"), formatMessage(tr("Failed to change the speaker device to the target speaker{:br:}{}"), error)).open();
                    });
                });

                return tag;
            };

            generate_device(undefined).appendTo(container_devices);
            getAudioBackend().getAvailableDevices().then(result => {
                contianer_error.text("").hide();
                result.forEach(e => generate_device(e).appendTo(container_devices));
            }).catch(error => {
                if (typeof (error) === "string")
                    contianer_error.text(error).show();

                logDebug(LogCategory.GENERAL, tr("Failed to query available speaker devices: %o"), error);
                contianer_error.text(tr("Errors occurred (View console)")).show();
            });
        };
        update_devices();

        const button_update = container.find(".button-update");
        button_update.on('click', async event => {
            button_update.prop("disabled", true);
            try {
                update_devices();
            } catch (error) {
                logError(LogCategory.GENERAL, tr("Failed to build new speaker device list: %o"), error);
            }
            button_update.prop("disabled", false);
        });
    }

    /* slider */
    {

        {
            const container_master = container.find(".container-volume-master");
            const slider = container_master.find(".container-slider");
            sliderfy(slider, {
                min_value: 0,
                max_value: 100,
                step: 1,
                initial_value: settings.getValue(Settings.KEY_SOUND_MASTER, 100),
                value_field: [container_master.find(".container-value")]
            });
            slider.on('change', event => {
                const volume = parseInt(slider.attr('value'));

                getAudioBackend().setMasterVolume(volume / 100);
                settings.setValue(Settings.KEY_SOUND_MASTER, volume);
            });
        }

        {
            const container_soundpack = container.find(".container-volume-soundpack");
            const slider = container_soundpack.find(".container-slider");
            sliderfy(slider, {
                min_value: 0,
                max_value: 100,
                step: 1,
                initial_value: settings.getValue(Settings.KEY_SOUND_MASTER_SOUNDS, 100),
                value_field: [container_soundpack.find(".container-value")]
            });
            slider.on('change', event => {
                const volume = parseInt(slider.attr('value'));
                setSoundMasterVolume(volume / 100);
                settings.setValue(Settings.KEY_SOUND_MASTER_SOUNDS, volume);
            });
        }
    }

    /* button test sound */
    {
        container.find(".button-test-sound").on('click', event => {
            manager.play(Sound.SOUND_TEST, {
                default_volume: 1,
                ignore_muted: true,
                ignore_overlap: true
            })
        });
    }
}

function settings_audio_sounds(contianer: JQuery, modal: Modal) {
    /* initialize sound list */
    {
        const container_sounds = contianer.find(".container-sounds");
        let scrollbar;
        /*
        let scrollbar: SimpleBar;
        if("SimpleBar" in window)
            scrollbar = new SimpleBar(container_sounds[0]);
        */

        const generate_sound = (_sound: Sound) => {
            let tag_play_pause: JQuery, tag_play: JQuery, tag_pause: JQuery, tag_input_muted: JQuery;
            let tag = $.spawn("div").addClass("sound").append(
                tag_play_pause = $.spawn("div").addClass("container-button-play_pause").append(
                    tag_play = $.spawn("img").attr("src", "img/icon_sound_play.svg"),
                    tag_pause = $.spawn("img").attr("src", "img/icon_sound_pause.svg")
                ),
                $.spawn("div").addClass("container-name").text(_sound),
                $.spawn("label").addClass("container-button-toggle").append(
                    $.spawn("div").addClass("switch").append(
                        tag_input_muted = $.spawn("input").attr("type", "checkbox"),
                        $.spawn("span").addClass("slider").append(
                            $.spawn("div").addClass("dot")
                        )
                    )
                )
            );

            tag_play_pause.on('click', event => {
                if (tag_pause.is(":visible"))
                    return;
                tag_play.hide();
                tag_pause.show();

                const _done = flag => {
                    tag_pause.hide();
                    tag_play.show();
                };
                const _timeout = setTimeout(() => _done(false), 10 * 1000); /* the sounds are not longer than 10 seconds */

                sound.manager.play(_sound, {
                    ignore_overlap: true,
                    ignore_muted: true,
                    default_volume: 1,

                    callback: flag => {
                        clearTimeout(_timeout);
                        _done(flag);
                    }
                });
            });
            tag_pause.hide();

            tag_input_muted.prop("checked", sound.get_sound_volume(_sound, 1) > 0);
            tag_input_muted.on('change', event => {
                const volume = tag_input_muted.prop("checked") ? 1 : 0;
                sound.set_sound_volume(_sound, volume);
                logDebug(LogCategory.GENERAL, tr("Changed sound volume to %o for sound %o"), volume, _sound);
            });

            return tag;
        };

        //container-sounds
        for (const sound_key in Sound)
            generate_sound(Sound[sound_key as any] as any).appendTo(scrollbar ? scrollbar.getContentElement() : container_sounds);

        /* the filter */
        const input_filter = contianer.find(".input-sounds-filter");
        input_filter.on('change keyup', event => {
            const filter = input_filter.val() as string;

            container_sounds.find(".sound").each((_, _element) => {
                const element = $(_element);
                element.toggle(filter.length == 0 || element.text().toLowerCase().indexOf(filter) !== -1);
            })
        });
    }

    const overlap_tag = contianer.find(".option-overlap-same");
    overlap_tag.on('change', event => {
        const activated = (event.target as HTMLInputElement).checked;
        sound.set_overlap_activated(activated);
    }).prop("checked", sound.overlap_activated());

    const mute_tag = contianer.find(".option-mute-output");
    mute_tag.on('change', event => {
        const activated = (event.target as HTMLInputElement).checked;
        sound.set_ignore_output_muted(!activated);
    }).prop("checked", !sound.ignore_output_muted());

    modal.close_listener.push(sound.save);
}

export namespace modal_settings {
    export interface ProfileViewSettings {
        forum_setuppable: boolean
    }

    export function initialize_identity_profiles_controller(event_registry: Registry<SettingProfileEvents>) {
        const send_error = (event, profile, text) => event_registry.fire_react(event, {
            status: "error",
            profile_id: profile,
            error: text
        });
        event_registry.on("create-profile", event => {
            const profile = profiles.createConnectProfile(event.name);
            profiles.mark_need_save();
            event_registry.fire_react("create-profile-result", {
                status: "success",
                name: event.name,
                profile_id: profile.id
            });
        });

        event_registry.on("delete-profile", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("delete-profile-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            profiles.delete_profile(profile);
            event_registry.fire_react("delete-profile-result", {status: "success", profile_id: event.profile_id});
        });

        const build_profile_info = (profile: ConnectionProfile) => {
            const forum_data = profile.selectedIdentity(IdentitifyType.TEAFORO) as TeaForumIdentity;
            const teamspeak_data = profile.selectedIdentity(IdentitifyType.TEAMSPEAK) as TeaSpeakIdentity;
            const nickname_data = profile.selectedIdentity(IdentitifyType.NICKNAME) as NameIdentity;

            return {
                id: profile.id,
                name: profile.profileName,
                nickname: profile.defaultUsername,
                identity_type: profile.selectedIdentityType as any,
                identity_forum: !forum_data ? undefined : {
                    valid: forum_data.valid(),
                    fallback_name: forum_data.fallback_name()
                },
                identity_nickname: !nickname_data ? undefined : {
                    name: nickname_data.name(),
                    fallback_name: nickname_data.fallback_name()
                },
                identity_teamspeak: !teamspeak_data ? undefined : {
                    unique_id: teamspeak_data.uid(),
                    fallback_name: teamspeak_data.fallback_name()
                }
            }
        };
        event_registry.on("query-profile-list", event => {
            event_registry.fire_react("query-profile-list-result", {
                status: "success",
                profiles: profiles.availableConnectProfiles().map(e => build_profile_info(e))
            });
        });

        event_registry.on("query-profile", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("query-profile-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            event_registry.fire_react("query-profile-result", {
                status: "success",
                profile_id: event.profile_id,
                info: build_profile_info(profile)
            });
        });

        event_registry.on("set-default-profile", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("set-default-profile-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            const old = profiles.set_default_profile(profile);
            event_registry.fire_react("set-default-profile-result", {
                status: "success",
                old_profile_id: event.profile_id,
                new_profile_id: old.id
            });
        });

        event_registry.on("set-profile-name", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("set-profile-name-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            profile.profileName = event.name;
            profiles.mark_need_save();
            event_registry.fire_react("set-profile-name-result", {
                name: event.name,
                profile_id: event.profile_id,
                status: "success"
            });
        });

        event_registry.on("set-default-name", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("set-default-name-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            profile.defaultUsername = event.name;
            profiles.mark_need_save();
            event_registry.fire_react("set-default-name-result", {
                name: event.name,
                profile_id: event.profile_id,
                status: "success"
            });
        });

        event_registry.on("set-identity-name-name", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("set-identity-name-name-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            let identity = profile.selectedIdentity(IdentitifyType.NICKNAME) as NameIdentity;
            if (!identity)
                profile.setIdentity(IdentitifyType.NICKNAME, identity = new NameIdentity());
            identity.set_name(event.name);
            profiles.mark_need_save();

            event_registry.fire_react("set-identity-name-name-result", {
                name: event.name,
                profile_id: event.profile_id,
                status: "success"
            });
        });

        event_registry.on("query-profile-validity", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("query-profile-validity-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            event_registry.fire_react("query-profile-validity-result", {
                status: "success",
                profile_id: event.profile_id,
                valid: profile.valid()
            });
        });

        event_registry.on("query-identity-teamspeak", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("query-identity-teamspeak-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            const ts = profile.selectedIdentity(IdentitifyType.TEAMSPEAK) as TeaSpeakIdentity;
            if (!ts) {
                event_registry.fire_react("query-identity-teamspeak-result", {
                    status: "error",
                    profile_id: event.profile_id,
                    error: tr("Missing identity")
                });
                return;
            }

            ts.level().then(level => {
                event_registry.fire_react("query-identity-teamspeak-result", {
                    status: "success",
                    level: level,
                    profile_id: event.profile_id
                });
            }).catch(error => {
                send_error("query-identity-teamspeak-result", event.profile_id, tr("failed to calculate level"));
            })
        });

        event_registry.on("select-identity-type", event => {
            if(!event.identity_type) {
                /* dummy event for UI init */
                return;
            }

            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                return;
            }

            profile.selectedIdentityType = event.identity_type;
            profiles.mark_need_save();
        });

        event_registry.on("generate-identity-teamspeak", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                send_error("generate-identity-teamspeak-result", event.profile_id, tr("Unknown profile"));
                return;
            }

            TeaSpeakIdentity.generateNew().then(identity => {
                profile.setIdentity(IdentitifyType.TEAMSPEAK, identity);
                profiles.mark_need_save();

                identity.level().then(level => {
                    event_registry.fire_react("generate-identity-teamspeak-result", {
                        status: "success",
                        profile_id: event.profile_id,
                        unique_id: identity.uid(),
                        level: level
                    });
                }).catch(error => {
                    logError(LogCategory.GENERAL, tr("Failed to calculate level for a new identity. Error object: %o"), error);
                    send_error("generate-identity-teamspeak-result", event.profile_id, tr("failed to calculate level: ") + error);
                })
            }).catch(error => {
                logError(LogCategory.GENERAL, tr("Failed to generate a new identity. Error object: %o"), error);
                send_error("generate-identity-teamspeak-result", event.profile_id, tr("failed to generate identity: ") + error);
            });
        });

        event_registry.on("import-identity-teamspeak", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                return;
            }

            spawnTeamSpeakIdentityImport(identity => {
                profile.setIdentity(IdentitifyType.TEAMSPEAK, identity);
                profiles.mark_need_save();

                identity.level().catch(error => {
                    logError(LogCategory.GENERAL, tr("Failed to calculate level for a new imported identity. Error object: %o"), error);
                    return Promise.resolve(undefined);
                }).then(level => {
                    event_registry.fire_react("import-identity-teamspeak-result", {
                        profile_id: event.profile_id,
                        unique_id: identity.uid(),
                        level: level
                    });
                });
            });
        });

        event_registry.on("improve-identity-teamspeak-level", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                return;
            }

            const identity = profile.selectedIdentity(IdentitifyType.TEAMSPEAK) as TeaSpeakIdentity;
            if (!identity) return;

            spawnTeamSpeakIdentityImprove(identity, profile.profileName).close_listener.push(() => {
                profiles.mark_need_save();

                identity.level().then(level => {
                    event_registry.fire_react("improve-identity-teamspeak-level-update", {
                        profile_id: event.profile_id,
                        new_level: level
                    });
                }).catch(error => {
                    logError(LogCategory.CLIENT, tr("Failed to calculate identity level after improvement (%o)"), error);
                });
            });
        });

        event_registry.on("export-identity-teamspeak", event => {
            const profile = profiles.findConnectProfile(event.profile_id);
            if (!profile) {
                logWarn(LogCategory.CLIENT, tr("Received profile event with unknown profile id (event: %s, id: %s)"), event.type, event.profile_id);
                return;
            }

            const identity = profile.selectedIdentity(IdentitifyType.TEAMSPEAK) as TeaSpeakIdentity;
            if (!identity) return;

            identity.export_ts(true).then(data => {
                const element = $.spawn("a")
                    .text("donwload")
                    .attr("href", "data:test/plain;charset=utf-8," + encodeURIComponent(data))
                    .attr("download", name + ".ini")
                    .css("display", "none")
                    .appendTo($("body"));
                element[0].click();
                element.remove();
            }).catch(error => {
                logError(LogCategory.IDENTITIES, tr("Failed to export identity: %o"), error);
                createErrorModal(tr("Failed to export identity"), tr("Failed to export and save identity.<br>Error: ") + error).open();
            });
        });
    }

    export function initialize_identity_profiles_view(container: JQuery, event_registry: Registry<SettingProfileEvents>, settings: ProfileViewSettings) {
        /* profile list */
        {
            const container_profiles = container.find(".container-profiles");
            let selected_profile;

            const overlay_error = container_profiles.find(".overlay-error");
            const overlay_timeout = container_profiles.find(".overlay-timeout");
            const overlay_empty = container_profiles.find(".overlay-empty");

            const build_profile = (profile: ProfileInfoEvent, selected: boolean) => {
                let tag_avatar: JQuery, tag_default: JQuery;
                let tag = $.spawn("div").addClass("profile").attr("profile-id", profile.id).append(
                    tag_avatar = $.spawn("div").addClass("container-avatar"),
                    $.spawn("div").addClass("container-info").append(
                        $.spawn("div").addClass("container-type").append(
                            $.spawn("div").addClass("identity-type").text(profile.identity_type || tr("Type unset")),
                            tag_default = $.spawn("div").addClass("tag-default").text(tr("(Default)")),
                            $.spawn("div").addClass("icon_em icon-status").hide()
                        ),
                        $.spawn("div").addClass("profile-name").text(profile.name || tr("Unnamed"))
                    )
                );
                tag_avatar.hide(); /* no avatars yet */

                tag.on('click', event => event_registry.fire("select-profile", {profile_id: profile.id}));
                tag.toggleClass("selected", selected);
                tag_default.toggle(profile.id === "default");

                event_registry.fire("query-profile-validity", {profile_id: profile.id});
                return tag;
            };

            event_registry.on("select-profile", event => {
                container_profiles.find(".profile").removeClass("selected");
                container_profiles.find(".profile[profile-id='" + event.profile_id + "']").addClass("selected");
                selected_profile = event.profile_id;
            });


            event_registry.on("query-profile-list", event => {
                container_profiles.find(".profile").remove();
            });

            event_registry.on("query-profile-list-result", event => {
                container_profiles.find(".overlay").hide();
                if (event.status === "error") {
                    overlay_error.show().find(".error").text(event.error || tr("unknown error"));
                    return;
                } else if (event.status === "timeout") {
                    overlay_timeout.show();
                    return;
                }
                if (!event.profiles.length) {
                    overlay_empty.show();
                    return;
                }

                container_profiles.find(".overlay").hide();
                container_profiles.find(".profile").remove();
                event.profiles.forEach(e => build_profile(e, e.id == selected_profile).appendTo(container_profiles));
            });

            event_registry.on("delete-profile-result", event => {
                if (event.status !== "success") return;

                //TODO: Animate removal?
                container_profiles.find(".profile[profile-id='" + event.profile_id + "']").remove();
            });

            event_registry.on('create-profile-result', event => {
                if (event.status !== "success") return;

                event_registry.fire("query-profile-list");
                event_registry.one("query-profile-list-result", e => event_registry.fire("select-profile", {profile_id: event.profile_id}));
            });

            event_registry.on("set-profile-name-result", event => {
                if (event.status !== "success") return;

                const profile = container_profiles.find(".profile[profile-id='" + event.profile_id + "']");
                profile.find(".profile-name").text(event.name || tr("Unnamed"));
            });

            event_registry.on("set-default-profile-result", event => {
                if (event.status !== "success") return;

                const old_profile = container_profiles.find(".profile[profile-id='default']");
                const new_profile = container_profiles.find(".profile[profile-id='" + event.old_profile_id + "']");
                old_profile.attr("profile-id", event.new_profile_id).find(".tag-default").hide();
                new_profile.attr("profile-id", "default").find(".tag-default").show();
            });

            event_registry.on("select-identity-type", event => {
                if (!event.identity_type) return;

                const profile = container_profiles.find(".profile[profile-id='" + event.profile_id + "']");
                profile.find(".identity-type").text(event.identity_type.toUpperCase() || tr("Type unset"));
            });

            event_registry.on("query-profile-validity-result", event => {
                const profile = container_profiles.find(".profile[profile-id='" + event.profile_id + "']");
                profile.find(".icon-status")
                    .show()
                    .toggleClass("client-apply", event.status === "success" && event.valid)
                    .toggleClass("client-delete", event.status !== "success" || !event.valid)
                    .attr("title", event.status === "success" ? event.valid ? tr("Profile is valid") : tr("Provile is invalid") : event.error || tr("failed to query status"));
            });

            /* status indicator updaters */
            event_registry.on("select-identity-type", event => {
                if (!event.profile_id) return;

                /* we need a short delay so everything could apply*/
                setTimeout(() => {
                    event_registry.fire("query-profile-validity", {profile_id: event.profile_id});
                }, 100);
            });
            event_registry.on(["set-default-name-result", "set-profile-name-result", "set-identity-name-name-result", "generate-identity-teamspeak-result"], event => {
                if (!('status' in event) || !('profile_id' in event)) {
                    logWarn(LogCategory.CLIENT, tr("Profile status watcher encountered an unuseal event!"));
                    return;
                }
                if ((event as any).status !== "success") return;
                event_registry.fire("query-profile-validity", {profile_id: (event as any).profile_id});
            })
        }

        /* list buttons */
        {
            /* reload */
            {
                const button = container.find(".button-reload-list");

                button.on('click', event => event_registry.fire("query-profile-list"));

                event_registry.on("query-profile-list", event => button.prop("disabled", true));
                event_registry.on("query-profile-list-result", event => button.prop("disabled", false));
            }

            /* set default */
            {
                const button = container.find(".button-set-default");
                let current_profile;

                button.on('click', event => event_registry.fire("set-default-profile", {profile_id: current_profile}));
                event_registry.on("select-profile", event => {
                    current_profile = event.profile_id;
                    button.prop("disabled", !event.profile_id || event.profile_id === "default");
                });

                event_registry.on("set-default-profile-result", event => {
                    if (event.status === "success") return;

                    createErrorModal(tr("Failed to set default profile"), tr("Failed to set default profile:") + "<br>" + (event.status === "timeout" ? tr("request timeout") : (event.error || tr("unknown error")))).open();
                });
                button.prop("disabled", true);
            }

            /* delete button */
            {
                const button = container.find(".button-delete");
                let current_profile;

                button.on('click', event => {
                    if (!current_profile || current_profile === "default") return;

                    promptYesNo({
                        title: tr("Are you sure?"),
                        question: tr("Do you really want to delete this profile?"),
                    }).then(result => {
                        if (result)
                            event_registry.fire("delete-profile", {profile_id: current_profile});
                    });
                });

                event_registry.on("delete-profile-result", event => {
                    if (event.status === "success") return;

                    createErrorModal(tr("Failed to delete profile"), tr("Failed to delete profile:") + "<br>" + (event.status === "timeout" ? tr("request timeout") : (event.error || tr("unknown error")))).open();
                });

                event_registry.on("select-profile", event => {
                    current_profile = event.profile_id;

                    button.prop("disabled", !event.profile_id || event.profile_id === "default");
                });
            }

            /* create button */
            {
                const button = container.find(".button-create");
                button.on('click', event => {
                    createInputModal(tr("Please enter a name"), tr("Please enter a name for the new profile:"), text => text.length >= 3 && !profiles.find_profile_by_name(text), value => {
                        if (value)
                            event_registry.fire("create-profile", {name: value as string});
                    }).open();
                });

                event_registry.on('create-profile', event => button.prop("disabled", true));
                event_registry.on("create-profile-result", event => {
                    button.prop("disabled", false);
                    if (event.status === "success") {
                        event_registry.fire("select-profile", {profile_id: event.profile_id});
                        return;
                    }

                    createErrorModal(tr("Failed to create profile"), tr("Failed to create new profile:") + "<br>" + (event.status === "timeout" ? tr("request timeout") : (event.error || tr("unknown error")))).open();
                })
            }
        }


        /* profile info */
        {
            let current_profile;
            const error_text = event => event.status === "timeout" ? tr("request timeout") : (event.error || tr("unknown error"));

            /* general info */
            {
                /* profile name */
                {
                    const input = container.find(".profile-name");
                    let last_name;

                    const update_name = () => input.prop("disabled", false)
                        .val(last_name)
                        .attr("placeholder", tr("Profile name"))
                        .parent().removeClass("is-invalid");

                    const info_name = text => input.prop("disabled", true)
                        .val(null)
                        .attr("placeholder", text)
                        .parent().removeClass("is-invalid");

                    event_registry.on("query-profile", event => {
                        if (event.profile_id !== current_profile) return;

                        info_name(tr("loading"));
                    });

                    event_registry.on("query-profile-result", event => {
                        if (event.profile_id !== current_profile) return;

                        if (event.status === "success") {
                            last_name = event.info.name;
                            update_name();
                        } else {
                            info_name(error_text(event));
                        }
                    });

                    event_registry.on("set-profile-name", event => {
                        if (event.profile_id !== current_profile) return;

                        info_name(tr("saving"));
                    });

                    event_registry.on("set-profile-name-result", event => {
                        if (event.status !== "success") {
                            createErrorModal(tr("Failed to change profile name"), tr("Failed to create apply new name:") + "<br>" + error_text(event)).open();
                        } else {
                            last_name = event.name;
                        }
                        update_name();
                    });

                    input.on('keyup', event => {
                        const text = input.val() as string;
                        const profile = profiles.find_profile_by_name(text);
                        input.parent().toggleClass("is-invalid", text.length < 3 || (profile && profile.id != current_profile));
                    }).on('change', event => {
                        const text = input.val() as string;
                        const profile = profiles.find_profile_by_name(text);
                        if (text.length < 3 || (profile && profile.id != current_profile)) return;

                        event_registry.fire("set-profile-name", {profile_id: current_profile, name: text});
                    });
                }

                /* nickname name */
                {
                    const input = container.find(".profile-default-name");
                    let last_name = null, fallback_names = {}, current_identity_type = "";

                    const update_name = () => input.prop("disabled", false)
                        .val(last_name)
                        .attr("placeholder", fallback_names[current_identity_type] || tr("Another TeaSpeak user"))
                        .parent().removeClass("is-invalid");

                    const info_name = text => input.prop("disabled", true)
                        .val(null)
                        .attr("placeholder", text)
                        .parent().removeClass("is-invalid");

                    event_registry.on("query-profile", event => {
                        if (event.profile_id !== current_profile) return;

                        input.prop("disabled", true).val(null).attr("placeholder", tr("loading"));
                    });

                    event_registry.on("query-profile-result", event => {
                        if (event.profile_id !== current_profile) return;
                        if (event.status === "success") {
                            current_identity_type = event.info.identity_type;
                            fallback_names["nickname"] = event.info.identity_nickname ? event.info.identity_nickname.fallback_name : undefined;
                            fallback_names["teaforo"] = event.info.identity_forum ? event.info.identity_forum.fallback_name : undefined;
                            fallback_names["teamspeak"] = event.info.identity_teamspeak ? event.info.identity_teamspeak.fallback_name : undefined;

                            last_name = event.info.nickname;
                            update_name();
                        } else {
                            info_name(error_text(event));
                        }
                    });

                    event_registry.on("select-identity-type", event => {
                        if (current_identity_type === event.identity_type) return;

                        current_identity_type = event.identity_type;
                        update_name();
                    });

                    event_registry.on("set-default-name", event => {
                        if (event.profile_id !== current_profile) return;

                        info_name(tr("saving"));
                    });

                    event_registry.on("set-default-name-result", event => {
                        if (event.status !== "success") {
                            createErrorModal(tr("Failed to change nickname"), tr("Failed to create apply new nickname:") + "<br>" + error_text(event)).open();
                        } else {
                            last_name = event.name;
                        }
                        update_name();
                    });

                    input.on('keyup', event => {
                        const text = input.val() as string;
                        input.parent().toggleClass("is-invalid", text.length != 0 && text.length < 3);
                    }).on('change', event => {
                        const text = input.val() as string;
                        if (text.length != 0 && text.length < 3) return;

                        event_registry.fire("set-default-name", {profile_id: current_profile, name: text});
                    });
                }

                /* identity type */
                {
                    const select_identity_type = container.find(".profile-identity-type");

                    const show_message = (text, is_invalid) => select_identity_type
                        .toggleClass("is-invalid", is_invalid)
                        .prop("disabled", true)
                        .find("option[value=error]")
                        .text(text)
                        .prop("selected", true);

                    const set_type = type => select_identity_type
                        .toggleClass("is-invalid", type === "unset")
                        .prop("disabled", false)
                        .find("option[value=" + type + "]")
                        .prop("selected", true);

                    event_registry.on("query-profile", event => show_message(tr("loading"), false));

                    event_registry.on("select-identity-type", event => {
                        if (event.profile_id !== current_profile) return;

                        set_type(event.identity_type || "unset");
                    });

                    event_registry.on("query-profile-result", event => {
                        if (event.profile_id !== current_profile) return;

                        if (event.status === "success")
                            event_registry.fire("select-identity-type", {
                                profile_id: event.profile_id,
                                identity_type: event.info.identity_type
                            });
                        else
                            show_message(error_text(event), false);
                    });

                    select_identity_type.on('change', event => {
                        const type = (select_identity_type.val() as string).toLowerCase();
                        if (type === "error" || type == "unset") return;

                        event_registry.fire("select-identity-type", {
                            profile_id: current_profile,
                            identity_type: type as any
                        });
                    });
                }

                /* avatar */
                {
                    container.find(".button-change-avatar").hide();
                }
            }

            /* special info TeamSpeak */
            {
                const container_settings = container.find(".container-teamspeak");
                const container_valid = container_settings.find(".container-valid");
                const container_invalid = container_settings.find(".container-invalid");

                const input_current_level = container_settings.find(".current-level");
                const input_unique_id = container_settings.find(".unique-id");

                const button_new = container_settings.find(".button-new");
                const button_improve = container_settings.find(".button-improve");

                const button_import = container_settings.find(".button-import");
                const button_export = container_settings.find(".button-export");

                let is_profile_generated = false;

                event_registry.on("select-identity-type", event => {
                    if (event.profile_id !== current_profile) return;

                    container_settings.toggle(event.identity_type === "teamspeak");
                });

                event_registry.on("query-profile", event => {
                    input_unique_id.val(null).attr("placeholder", tr("loading"));
                    input_current_level.val(null).attr("placeholder", tr("loading"));

                    button_new.prop("disabled", true);
                    button_improve.prop("disabled", true);
                    button_import.prop("disabled", true);
                    button_export.prop("disabled", true);
                });

                const update_identity = (state: "not-created" | "created", unique_id?: string, level?: number) => {
                    if (state === "not-created") {
                        container_invalid.show();
                        container_valid.hide();

                        button_improve.prop("disabled", true);
                        button_export.prop("disabled", true);
                    } else {
                        container_invalid.hide();
                        container_valid.show();

                        input_unique_id.val(unique_id).attr("placeholder", null);
                        if (typeof level !== "number")
                            event_registry.fire("query-identity-teamspeak", {profile_id: current_profile});
                        else
                            input_current_level.val(level).attr("placeholder", null);

                        button_improve.prop("disabled", false);
                        button_export.prop("disabled", false);
                    }

                    is_profile_generated = state === "created";
                    button_new.toggleClass("btn-blue", !is_profile_generated).toggleClass("btn-red", is_profile_generated);
                    button_import.toggleClass("btn-blue", !is_profile_generated).toggleClass("btn-red", is_profile_generated);

                    button_new.prop("disabled", false);
                    button_import.prop("disabled", false);
                };

                event_registry.on("query-profile-result", event => {
                    if (event.profile_id !== current_profile) return;

                    if (event.status !== "success") {
                        input_unique_id.val(null).attr("placeholder", error_text(event));
                        return;
                    }

                    if (!event.info.identity_teamspeak)
                        update_identity("not-created");
                    else
                        update_identity("created", event.info.identity_teamspeak.unique_id);
                });

                event_registry.on("query-identity-teamspeak-result", event => {
                    if (event.profile_id !== current_profile) return;

                    if (event.status === "success") {
                        input_current_level.val(event.level).attr("placeholder", null);
                    } else {
                        input_current_level.val(null).attr("placeholder", error_text(event));
                    }
                });

                /* the new button */
                {
                    button_new.on('click', event => {
                        if (is_profile_generated) {
                            promptYesNo({
                                title: tr("Are you sure"),
                                question: tr("Do you really want to generate a new identity and override the old identity?"),
                            }).then(result => {
                                if (result) event_registry.fire("generate-identity-teamspeak", {profile_id: current_profile});
                            });
                        } else {
                            event_registry.fire("generate-identity-teamspeak", {profile_id: current_profile});
                        }
                    });

                    event_registry.on("generate-identity-teamspeak-result", event => {
                        if (event.profile_id !== current_profile) return;

                        if (event.status !== "success") {
                            createErrorModal(tr("Failed to generate a new identity"), tr("Failed to create a new identity:") + "<br>" + error_text(event)).open();
                            return;
                        }

                        update_identity("created", event.unique_id, event.level);
                        createInfoModal(tr("Identity generated"), tr("A new identity had been successfully generated")).open();
                    });
                }

                /* the import identity */
                {
                    button_import.on('click', event => {
                        if (is_profile_generated) {
                            promptYesNo({
                                title: tr("Are you sure"),
                                question: tr("Do you really want to import a new identity and override the old identity?"),
                            }).then(result => {
                                if (result) event_registry.fire("import-identity-teamspeak", {profile_id: current_profile});
                            });
                        } else {
                            event_registry.fire("import-identity-teamspeak", {profile_id: current_profile});
                        }
                    });

                    event_registry.on("improve-identity-teamspeak-level-update", event => {
                        if (event.profile_id !== current_profile) return;

                        input_current_level.val(event.new_level).attr("placeholder", null);
                    });

                    event_registry.on("import-identity-teamspeak-result", event => {
                        if (event.profile_id !== current_profile) return;

                        event_registry.fire_react("query-profile", {profile_id: event.profile_id}); /* we do it like this so the default nickname changes as well */
                        createInfoModal(tr("Identity imported"), tr("Your identity had been successfully imported generated")).open();
                    });
                }

                /* identity export */
                {
                    button_export.on('click', event => {
                        createInputModal(tr("File name"), tr("Please enter the file name"), text => !!text, name => {
                            if (name)
                                event_registry.fire("export-identity-teamspeak", {
                                    profile_id: current_profile,
                                    filename: name as string
                                });
                        }).open();
                    });
                }

                /* the improve button */
                button_improve.on('click', event => event_registry.fire("improve-identity-teamspeak-level", {profile_id: current_profile}));
            }

            /* special info TeaSpeak - Forum */
            {
                const container_settings = container.find(".container-teaforo");
                const container_valid = container_settings.find(".container-valid");
                const container_invalid = container_settings.find(".container-invalid");

                const button_setup = container_settings.find(".button-setup");

                event_registry.on("select-identity-type", event => {
                    if (event.profile_id !== current_profile) return;

                    container_settings.toggle(event.identity_type === "teaforo");
                });

                event_registry.on("query-profile", event => {
                    container_valid.toggle(false);
                    container_invalid.toggle(false);
                });

                event_registry.on("query-profile-result", event => {
                    if (event.profile_id !== current_profile) return;

                    const valid = event.status === "success" && event.info.identity_forum && event.info.identity_forum.valid;
                    container_valid.toggle(!!valid);
                    container_invalid.toggle(!valid);
                });

                button_setup.on('click', event => event_registry.fire_react("setup-forum-connection"));
                button_setup.toggle(settings.forum_setuppable);
            }

            /* special info nickname */
            {
                const container_settings = container.find(".container-nickname");
                const input_nickname = container_settings.find(".nickname");
                let last_name;

                const update_name = () => input_nickname.prop("disabled", false)
                    .val(last_name)
                    .attr("placeholder", tr("Identity base name"))
                    .parent().removeClass("is-invalid");

                const show_info = text => input_nickname.prop("disabled", true)
                    .val(null)
                    .attr("placeholder", text)
                    .parent().removeClass("is-invalid");

                event_registry.on("select-identity-type", event => event.profile_id === current_profile && container_settings.toggle(event.identity_type === "nickname"));

                event_registry.on("query-profile", event => {
                    if (event.profile_id !== current_profile) return;

                    show_info(tr("loading"));
                });

                event_registry.on("query-profile-result", event => {
                    if (event.profile_id !== current_profile) return;

                    if (event.status === "success") {
                        last_name = event.info.identity_nickname ? event.info.identity_nickname.name : null;
                        update_name();
                    } else {
                        show_info(error_text(event));
                    }
                });

                event_registry.on("set-identity-name-name", event => {
                    if (event.profile_id !== current_profile) return;
                    show_info(tr("saving"));
                });

                event_registry.on("set-identity-name-name-result", event => {
                    if (event.status !== "success") {
                        createErrorModal(tr("Failed to change name"), tr("Failed to create new name:") + "<br>" + error_text(event)).open();
                    } else {
                        last_name = event.name;
                    }
                    update_name();
                });

                input_nickname.on('keyup', event => {
                    const text = input_nickname.val() as string;
                    const profile = profiles.find_profile_by_name(text);
                    input_nickname.parent().toggleClass("is-invalid", text.length < 3 || (profile && profile.id != current_profile));
                }).on('change', event => {
                    const text = input_nickname.val() as string;
                    const profile = profiles.find_profile_by_name(text);
                    if (text.length < 3 || (profile && profile.id != current_profile)) return;

                    event_registry.fire("set-identity-name-name", {profile_id: current_profile, name: text});
                });
            }
            event_registry.on("select-profile", e => current_profile = e.profile_id);
        }

        /* timeouts */
        {
            /* profile list */
            {
                let timeout;
                event_registry.on("query-profile-list", event => timeout = setTimeout(() => event_registry.fire("query-profile-list-result", {status: "timeout"}), 5000));
                event_registry.on("query-profile-list-result", event => {
                    clearTimeout(timeout);
                    timeout = undefined;
                });
            }

            /* profile create */
            {
                const timeouts = {};
                event_registry.on("create-profile", event => {
                    clearTimeout(timeouts[event.name]);
                    timeouts[event.name] = setTimeout(() => {
                        event_registry.fire("create-profile-result", {name: event.name, status: "timeout"});
                    }, 5000);
                });

                event_registry.on("create-profile-result", event => {
                    clearTimeout(timeouts[event.name]);
                    delete timeouts[event.name];
                });
            }

            /* profile set default create */
            {
                const timeouts = {};
                event_registry.on("set-default-profile", event => {
                    clearTimeout(timeouts[event.profile_id]);
                    timeouts[event.profile_id] = setTimeout(() => {
                        event_registry.fire("set-default-profile-result", {
                            old_profile_id: event.profile_id,
                            status: "timeout"
                        });
                    }, 5000);
                });

                event_registry.on("set-default-profile-result", event => {
                    clearTimeout(timeouts[event.old_profile_id]);
                    delete timeouts[event.old_profile_id];
                });
            }

            const create_standard_timeout = (event: keyof SettingProfileEvents, response_event: keyof SettingProfileEvents, key: string) => {
                const timeouts = {};
                event_registry.on(event, event => {
                    clearTimeout(timeouts[event[key]]);
                    timeouts[event[key]] = setTimeout(() => {
                        const timeout_event = {status: "timeout"};
                        timeout_event[key] = event[key];
                        event_registry.fire(response_event, timeout_event as any);
                    }, 5000);
                });

                event_registry.on(response_event, event => {
                    clearTimeout(timeouts[event[key]]);
                    delete timeouts[event[key]];
                });
            };

            create_standard_timeout("query-profile", "query-profile-result", "profile_id");
            create_standard_timeout("query-identity-teamspeak", "query-identity-teamspeak-result", "profile_id");
            create_standard_timeout("delete-profile", "delete-profile-result", "profile_id");
            create_standard_timeout("set-profile-name", "set-profile-name-result", "profile_id");
            create_standard_timeout("set-default-name", "set-default-name-result", "profile_id");
            create_standard_timeout("query-profile-validity", "query-profile-validity-result", "profile_id");
            create_standard_timeout("set-identity-name-name", "set-identity-name-name-result", "profile_id");
            create_standard_timeout("generate-identity-teamspeak", "generate-identity-teamspeak-result", "profile_id");
        }

        /* some view semantics */
        {
            let selected_profile;
            event_registry.on("delete-profile-result", event => {
                if (event.status !== "success") return;
                if (event.profile_id !== selected_profile) return;

                /* the selected profile has been deleted, so we need to select another one */
                event_registry.fire("select-profile", {profile_id: "default"});
            });

            /* reselect the default profile or the new default profile */
            event_registry.on("set-default-profile-result", event => {
                if (event.status !== "success") return;
                if (selected_profile === "default")
                    event_registry.fire("select-profile", {profile_id: event.new_profile_id});
                else if (selected_profile === event.old_profile_id)
                    event_registry.fire("select-profile", {profile_id: "default"});
            });

            event_registry.on("select-profile", event => {
                selected_profile = event.profile_id;
                event_registry.fire("query-profile", {profile_id: event.profile_id});
            });

            event_registry.on("reload-profile", event => {
                event_registry.fire("query-profile-list");
                event_registry.fire("select-profile", { profile_id: event.profile_id || selected_profile });
            });
        }

        event_registry.fire("query-profile-list");
        event_registry.fire("select-profile", {profile_id: "default"});
        event_registry.fire("select-identity-type", {profile_id: "default", identity_type: undefined});
    }
}

function settings_identity_forum(container: JQuery, modal: Modal, update_profiles: () => any) {
    const containers_connected = container.find(".show-connected");
    const containers_disconnected = container.find(".show-disconnected");

    const update_state = () => {
        const logged_in = forum.logged_in();
        containers_connected.toggle(logged_in);
        containers_disconnected.toggle(!logged_in);

        if (logged_in) {
            container.find(".forum-username").text(forum.data().name());
            container.find(".forum-premium").text(forum.data().is_premium() ? tr("Yes") : tr("No"));
        }
    };

    /* login */
    {
        const button_login = container.find(".button-login");
        const input_username = container.find(".input-username");
        const input_password = container.find(".input-password");
        const container_error = container.find(".container-login .container-error");

        const container_captcha_g = container.find(".g-recaptcha");
        let captcha: boolean | string = false;

        const update_button_state = () => {
            let enabled = true;
            enabled = enabled && !!input_password.val();
            enabled = enabled && !!input_username.val();
            enabled = enabled && (typeof (captcha) === "boolean" ? !captcha : !!captcha);
            button_login.prop("disabled", !enabled);
        };

        /* username */
        input_username.on('change keyup', update_button_state);

        /* password */
        input_password.on('change keyup', update_button_state);

        button_login.on('click', event => {
            input_username.prop("disabled", true);
            input_password.prop("disabled", true);
            button_login.prop("disabled", true);
            container_error.removeClass("shown");

            forum.login(input_username.val() as string, input_password.val() as string, typeof (captcha) === "string" ? captcha : undefined).then(state => {
                captcha = false;

                logTrace(LogCategory.GENERAL, tr("Forum login result: %o"), state);
                if (state.status === "success") {
                    update_state();
                    update_profiles();
                    return;
                }

                setTimeout(() => {
                    if (!!state.error_message) /* clear password if we have an error */
                        input_password.val("");
                    input_password.focus();
                    update_button_state();
                }, 0);
                if (state.status === "captcha") {
                    //TODO Works currently only with localhost!
                    button_login.hide();
                    container_error.text(state.error_message || tr("Captcha required")).addClass("shown");

                    captcha = "";

                    logDebug(LogCategory.GENERAL, tr("Showing captcha for site-key: %o"), state.captcha.data);
                    forum.gcaptcha.spawn(container_captcha_g, state.captcha.data, token => {
                        captcha = token;
                        logTrace(LogCategory.GENERAL, tr("Got captcha token: %o"), token);
                        container_captcha_g.hide();
                        button_login.show();
                        update_button_state();
                    }).catch(error => {
                        logError(LogCategory.GENERAL, tr("Failed to initialize forum captcha: %o"), error);
                        container_error.text("Failed to initialize GReCaptcha! No authentication possible.").addClass("shown");
                        container_captcha_g.hide();
                        button_login.hide();
                    });
                    container_captcha_g.show();
                } else {
                    container_error.text(state.error_message || tr("Unknown error")).addClass("shown");
                }
            }).catch(error => {
                logError(LogCategory.GENERAL, tr("Failed to login within the forum. Error: %o"), error);
                createErrorModal(tr("Forum login failed."), tr("Forum login failed. Lookup the console for more information")).open();
            }).then(() => {
                input_username.prop("disabled", false);
                input_password.prop("disabled", false);
                update_button_state();
            });
        });
        update_button_state();
    }

    /* logout */
    {
        container.find(".button-logout").on('click', event => {
            forum.logout().catch(error => {
                logError(LogCategory.IDENTITIES, tr("Failed to logout from forum: %o"), error);
                createErrorModal(tr("Forum logout failed"), formatMessage(tr("Failed to logout from forum account.{:br:}Error: {}"), error)).open();
            }).then(() => {
                if (modal.shown)
                    update_state();
                update_profiles();
            });
        });
    }

    update_state();
}