import * as React from "react";
import {ConnectionHandler, ConnectionState} from "tc-shared/ConnectionHandler";
import {EventHandler, Registry} from "tc-shared/events";
import * as log from "tc-shared/log";
import {LogCategory} from "tc-shared/log";
import {CommandResult, ErrorID} from "tc-shared/connection/ServerConnectionDeclaration";
import {ServerCommand} from "tc-shared/connection/ConnectionBase";
import {Settings} from "tc-shared/settings";
import {tra, traj} from "tc-shared/i18n/localize";
import {createErrorModal} from "tc-shared/ui/elements/Modal";
import {helpers} from "tc-shared/ui/frames/side/chat_helper";
import ReactDOM = require("react-dom");
import {
    ChatEvent,
    ChatEventMessage, ChatHistoryState,
    ChatMessage, ConversationHistoryResponse,
    ChatState,
    ConversationUIEvents
} from "tc-shared/ui/frames/side/ConversationDefinitions";
import {ConversationPanel} from "tc-shared/ui/frames/side/ConversationUI";
import {preprocessChatMessageForSend} from "tc-shared/text/chat";
import {spawnExternalModal} from "tc-shared/ui/react-elements/external-modal";

const kMaxChatFrameMessageSize = 50; /* max 100 messages, since the server does not support more than 100 messages queried at once */

export abstract class AbstractChat<Events extends ConversationUIEvents> {
    protected readonly connection: ConnectionHandler;
    protected readonly chatId: string;
    protected readonly events: Registry<Events>;
    protected presentMessages: ChatEvent[] = [];
    protected presentEvents: Exclude<ChatEvent, ChatEventMessage>[] = []; /* everything excluding chat messages */

    protected mode: ChatState = "unloaded";
    protected failedPermission: string;
    protected errorMessage: string;

    protected conversationPrivate: boolean = false;
    protected crossChannelChatSupported: boolean = true;

    protected unreadTimestamp: number | undefined = undefined;
    protected lastReadMessage: number = 0;

    protected historyErrorMessage: string;
    protected historyRetryTimestamp: number = 0;
    protected executingUIHistoryQuery = false;

    protected messageSendEnabled: boolean = true;

    protected hasHistory = false;

    protected constructor(connection: ConnectionHandler, chatId: string, events: Registry<Events>) {
        this.connection = connection;
        this.events = events;
        this.chatId = chatId;
    }

    public currentMode() : ChatState { return this.mode; };

    protected registerChatEvent(event: ChatEvent, triggerUnread: boolean) {
        if(event.type === "message") {
            let index = 0;
            while(index < this.presentMessages.length && this.presentMessages[index].timestamp <= event.timestamp)
                index++;

            this.presentMessages.splice(index, 0, event);

            const deleteMessageCount = Math.max(0, this.presentMessages.length - kMaxChatFrameMessageSize);
            this.presentMessages.splice(0, deleteMessageCount);
            if(deleteMessageCount > 0)
                this.hasHistory = true;
            index -= deleteMessageCount;

            if(event.isOwnMessage)
                this.setUnreadTimestamp(undefined);
            else if(!this.unreadTimestamp)
                this.unreadTimestamp = event.message.timestamp;

            /* let all other events run before */
            this.events.fire_async("notify_chat_event", {
                chatId: this.chatId,
                triggerUnread: triggerUnread,
                event: event
            });
        } else {
            this.presentEvents.push(event);
            this.presentEvents.sort((a, b) => a.timestamp - b.timestamp);
            /* TODO: Cutoff too old events! */

            this.events.fire("notify_chat_event", {
                chatId: this.chatId,
                triggerUnread: triggerUnread,
                event: event
            });
        }
    }

    protected registerIncomingMessage(message: ChatMessage, isOwnMessage: boolean, uniqueId: string) {
        this.registerChatEvent({
            type: "message",
            isOwnMessage: isOwnMessage,
            uniqueId: uniqueId,
            timestamp: message.timestamp,
            message: message
        }, !isOwnMessage);
    }

    public reportStateToUI() {
        let historyState: ChatHistoryState;
        if(Date.now() < this.historyRetryTimestamp && this.historyErrorMessage) {
            historyState = "error";
        } else if(this.executingUIHistoryQuery) {
            historyState = "loading";
        } else if(this.hasHistory) {
            historyState = "available";
        } else {
            historyState = "none";
        }

        switch (this.mode) {
            case "normal":
                if(this.conversationPrivate && !this.canClientAccessChat()) {
                    this.events.fire_async("notify_conversation_state", {
                        chatId: this.chatId,
                        state: "private",
                        crossChannelChatSupported: this.crossChannelChatSupported
                    });
                    return;
                }

                this.events.fire_async("notify_conversation_state", {
                    chatId: this.chatId,
                    state: "normal",

                    historyState: historyState,
                    historyErrorMessage: this.historyErrorMessage,
                    historyRetryTimestamp: this.historyRetryTimestamp,

                    chatFrameMaxMessageCount: kMaxChatFrameMessageSize,
                    unreadTimestamp: this.unreadTimestamp,

                    showUserSwitchEvents: this.conversationPrivate || !this.crossChannelChatSupported,
                    sendEnabled: this.messageSendEnabled,

                    events: [...this.presentEvents, ...this.presentMessages]
                });
                break;

            case "loading":
            case "unloaded":
                this.events.fire_async("notify_conversation_state", {
                    chatId: this.chatId,
                    state: "loading"
                });
                break;

            case "error":
                this.events.fire_async("notify_conversation_state", {
                    chatId: this.chatId,
                    state: "error",
                    errorMessage: this.errorMessage
                });
                break;

            case "no-permissions":
                this.events.fire_async("notify_conversation_state", {
                    chatId: this.chatId,
                    state: "no-permissions",
                    failedPermission: this.failedPermission
                });
                break;

        }
    }

    protected doSendMessage(message: string, targetMode: number, target: number) : Promise<boolean> {
        let msg = preprocessChatMessageForSend(message);
        return this.connection.serverConnection.send_command("sendtextmessage", {
            targetmode: targetMode,
            cid: target,
            target: target,
            msg: msg
        }, { process_result: false }).then(async () => true).catch(error => {
            if(error instanceof CommandResult) {
                if(error.id === ErrorID.PERMISSION_ERROR) {
                    this.registerChatEvent({
                        type: "message-failed",
                        uniqueId: "msf-" + this.chatId + "-" + Date.now(),
                        timestamp: Date.now(),
                        error: "permission",
                        failedPermission: this.connection.permissions.resolveInfo(parseInt(error.json["failed_permid"]))?.name || tr("unknown")
                    }, false);
                } else {
                    this.registerChatEvent({
                        type: "message-failed",
                        uniqueId: "msf-" + this.chatId + "-" + Date.now(),
                        timestamp: Date.now(),
                        error: "error",
                        errorMessage: error.formattedMessage()
                    }, false);
                }
            } else if(typeof error === "string") {
                this.registerChatEvent({
                    type: "message-failed",
                    uniqueId: "msf-" + this.chatId + "-" + Date.now(),
                    timestamp: Date.now(),
                    error: "error",
                    errorMessage: error
                }, false);
            } else {
                log.warn(LogCategory.CHAT, tr("Failed to send channel chat message to %s: %o"), this.chatId, error);
                this.registerChatEvent({
                    type: "message-failed",
                    uniqueId: "msf-" + this.chatId + "-" + Date.now(),
                    timestamp: Date.now(),
                    error: "error",
                    errorMessage: tr("lookup the console")
                }, false);
            }
            return false;
        });
    }

    public isUnread() {
        return this.unreadTimestamp !== undefined;
    }

    public setUnreadTimestamp(timestamp: number | undefined) {
        if(timestamp === undefined)
            this.lastReadMessage = Date.now();

        if(this.unreadTimestamp === timestamp)
            return;

        this.unreadTimestamp = timestamp;
        this.events.fire_async("notify_unread_timestamp_changed", { chatId: this.chatId, timestamp: timestamp });
    }

    public jumpToPresent() {
        this.reportStateToUI();
    }

    public uiQueryHistory(timestamp: number, enforce?: boolean) {
        if(this.executingUIHistoryQuery && !enforce)
            return;

        this.executingUIHistoryQuery = true;
        this.queryHistory({ end: 1, begin: timestamp, limit: kMaxChatFrameMessageSize }).then(result => {
            this.executingUIHistoryQuery = false;
            this.historyErrorMessage = undefined;
            this.historyRetryTimestamp = result.nextAllowedQuery;

            switch (result.status) {
                case "success":
                    this.events.fire_async("notify_conversation_history", {
                        chatId: this.chatId,
                        state: "success",

                        hasMoreMessages: result.moreEvents,
                        retryTimestamp: this.historyRetryTimestamp,

                        events: result.events
                    });
                    break;

                case "private":
                    this.events.fire_async("notify_conversation_history", {
                        chatId: this.chatId,
                        state: "error",
                        errorMessage: this.historyErrorMessage = tr("chat is private"),
                        retryTimestamp: this.historyRetryTimestamp
                    });
                    break;

                case "no-permission":
                    this.events.fire_async("notify_conversation_history", {
                        chatId: this.chatId,
                        state: "error",
                        errorMessage: this.historyErrorMessage = tra("failed on {}", result.failedPermission || tr("unknown permission")),
                        retryTimestamp: this.historyRetryTimestamp
                    });
                    break;

                case "error":
                    this.events.fire_async("notify_conversation_history", {
                        chatId: this.chatId,
                        state: "error",
                        errorMessage: this.historyErrorMessage = result.errorMessage,
                        retryTimestamp: this.historyRetryTimestamp
                    });
                    break;
            }
        });
    }

    protected lastEvent() : ChatEvent | undefined {
        if(this.presentMessages.length === 0)
            return this.presentEvents.last();
        else if(this.presentEvents.length === 0 || this.presentMessages.last().timestamp > this.presentEvents.last().timestamp)
            return this.presentMessages.last();
        else
            return this.presentEvents.last();
    }

    protected sendMessageSendingEnabled(enabled: boolean) {
        if(this.messageSendEnabled === enabled)
            return;

        this.messageSendEnabled = enabled;
        this.events.fire("notify_send_enabled", { chatId: this.chatId, enabled: enabled });
    }

    protected abstract canClientAccessChat() : boolean;
    public abstract queryHistory(criteria: { begin?: number, end?: number, limit?: number }) : Promise<ConversationHistoryResponse>;
    public abstract queryCurrentMessages();
    public abstract sendMessage(text: string);
}

export abstract class AbstractChatManager<Events extends ConversationUIEvents> {
    protected readonly uiEvents: Registry<Events>;

    protected constructor() {
        this.uiEvents = new Registry<Events>();
    }

    handlePanelShow() {
        this.uiEvents.fire("notify_panel_show");
    }

    protected abstract findChat(id: string) : AbstractChat<Events>;

    @EventHandler<ConversationUIEvents>("query_conversation_state")
    protected handleQueryConversationState(event: ConversationUIEvents["query_conversation_state"]) {
        const conversation = this.findChat(event.chatId);
        if(!conversation) {
            this.uiEvents.fire_async("notify_conversation_state", {
                state: "error",
                errorMessage: tr("Unknown conversation"),

                chatId: event.chatId
            });
            return;
        }

        if(conversation.currentMode() === "unloaded")
            conversation.queryCurrentMessages();
        else
            conversation.reportStateToUI();
    }

    @EventHandler<ConversationUIEvents>("query_conversation_history")
    protected handleQueryHistory(event: ConversationUIEvents["query_conversation_history"]) {
        const conversation = this.findChat(event.chatId);
        if(!conversation) {
            this.uiEvents.fire_async("notify_conversation_history", {
                state: "error",
                errorMessage: tr("Unknown conversation"),
                retryTimestamp: Date.now() + 10 * 1000,

                chatId: event.chatId
            });

            log.error(LogCategory.CLIENT, tr("Tried to query history for an unknown conversation with id %s"), event.chatId);
            return;
        }

        conversation.uiQueryHistory(event.timestamp);
    }

    @EventHandler<ConversationUIEvents>("action_clear_unread_flag")
    protected handleClearUnreadFlag(event: ConversationUIEvents["action_clear_unread_flag"]) {
        this.findChat(event.chatId)?.setUnreadTimestamp(undefined);
    }

    @EventHandler<ConversationUIEvents>("action_self_typing")
    protected handleActionSelfTyping(event: ConversationUIEvents["action_self_typing"]) {
        if(this.findChat(event.chatId)?.isUnread())
            this.uiEvents.fire("action_clear_unread_flag", { chatId: event.chatId });
    }

    @EventHandler<ConversationUIEvents>("action_send_message")
    protected handleSendMessage(event: ConversationUIEvents["action_send_message"]) {
        const conversation = this.findChat(event.chatId);
        if(!conversation) {
            log.error(LogCategory.CLIENT, tr("Tried to send a chat message to an unknown conversation with id %s"), event.chatId);
            return;
        }

        conversation.sendMessage(event.text);
    }

    @EventHandler<ConversationUIEvents>("action_jump_to_present")
    protected handleJumpToPresent(event: ConversationUIEvents["action_jump_to_present"]) {
        const conversation = this.findChat(event.chatId);
        if(!conversation) {
            log.error(LogCategory.CLIENT, tr("Tried to jump to present for an unknown conversation with id %s"), event.chatId);
            return;
        }

        conversation.jumpToPresent();
    }
}

const kSuccessQueryThrottle = 5 * 1000;
const kErrorQueryThrottle = 30 * 1000;
export class Conversation extends AbstractChat<ConversationUIEvents> {
    private readonly handle: ConversationManager;
    public readonly conversationId: number;

    private conversationVolatile: boolean = false;

    private executingHistoryQueries = false;
    private pendingHistoryQueries: (() => Promise<any>)[] = [];
    public historyQueryResponse: ChatMessage[] = [];

    constructor(handle: ConversationManager, events: Registry<ConversationUIEvents>, id: number) {
        super(handle.connection, id.toString(), events);
        this.handle = handle;
        this.conversationId = id;

        this.lastReadMessage = handle.connection.settings.server(Settings.FN_CHANNEL_CHAT_READ(id), Date.now());
    }

    destroy() { }

    queryHistory(criteria: { begin?: number, end?: number, limit?: number }) : Promise<ConversationHistoryResponse> {
        return new Promise<ConversationHistoryResponse>(resolve => {
            this.pendingHistoryQueries.push(() => {
                this.historyQueryResponse = [];

                return this.handle.connection.serverConnection.send_command("conversationhistory", {
                    cid: this.conversationId,
                    timestamp_begin: criteria.begin,
                    message_count: criteria.limit,
                    timestamp_end: criteria.end
                }, { flagset: [ "merge" ], process_result: false }).then(() => {
                    resolve({ status: "success", events: this.historyQueryResponse.map(e => {
                        return {
                            type: "message",
                            message: e,
                            timestamp: e.timestamp,
                            uniqueId: "cm-" + this.conversationId + "-" + e.timestamp + "-" + Date.now(),
                            isOwnMessage: false
                        }
                    }), moreEvents: false, nextAllowedQuery: Date.now() + kSuccessQueryThrottle });
                }).catch(error => {
                    let errorMessage;
                    if(error instanceof CommandResult) {
                        if(error.id === ErrorID.CONVERSATION_MORE_DATA || error.id === ErrorID.EMPTY_RESULT) {
                            resolve({ status: "success", events: this.historyQueryResponse.map(e => {
                                    return {
                                        type: "message",
                                        message: e,
                                        timestamp: e.timestamp,
                                        uniqueId: "cm-" + this.conversationId + "-" + e.timestamp + "-" + Date.now(),
                                        isOwnMessage: false
                                    }
                                }), moreEvents: error.id === ErrorID.CONVERSATION_MORE_DATA, nextAllowedQuery: Date.now() + kSuccessQueryThrottle });
                            return;
                        } else if(error.id === ErrorID.PERMISSION_ERROR) {
                            resolve({
                                status: "no-permission",
                                failedPermission: this.handle.connection.permissions.resolveInfo(parseInt(error.json["failed_permid"]))?.name || tr("unknwon"),
                                nextAllowedQuery: Date.now() + kErrorQueryThrottle
                            });
                            return;
                        } else if(error.id === ErrorID.CONVERSATION_IS_PRIVATE) {
                            resolve({
                                status: "private",
                                nextAllowedQuery: Date.now() + kErrorQueryThrottle
                            });
                            return;
                        } else if(error.id === ErrorID.COMMAND_NOT_FOUND) {
                            resolve({
                                status: "unsupported",
                                nextAllowedQuery: Date.now() + kErrorQueryThrottle
                            });
                            return;
                        } else {
                            errorMessage = error.formattedMessage();
                        }
                    } else {
                        log.error(LogCategory.CHAT, tr("Failed to fetch conversation history. %o"), error);
                        errorMessage = tr("lookup the console");
                    }
                    resolve({
                        status: "error",
                        errorMessage: errorMessage,
                        nextAllowedQuery: Date.now() + 5 * 1000
                    });
                });
            });

            this.executeHistoryQuery();
        });
    }

    queryCurrentMessages() {
        this.presentMessages = [];
        this.mode = "loading";

        this.reportStateToUI();
        this.queryHistory({ end: 1, limit: kMaxChatFrameMessageSize }).then(history => {
            this.conversationPrivate = false;
            this.conversationVolatile = false;
            this.failedPermission = undefined;
            this.errorMessage = undefined;
            this.hasHistory = !!history.moreEvents;
            this.presentMessages = history.events?.map(e => Object.assign({ uniqueId: "m-" + this.conversationId + "-" + e.timestamp }, e)) || [];

            switch (history.status) {
                case "error":
                    this.mode = "normal";
                    this.presentEvents.push({
                        type: "query-failed",
                        timestamp: Date.now(),
                        uniqueId: "qf-" + this.conversationId + "-" + Date.now() + "-" + Math.random(),
                        message: history.errorMessage
                    });
                    break;

                case "no-permission":
                    this.mode = "no-permissions";
                    this.failedPermission = history.failedPermission;
                    break;

                case "private":
                    this.conversationPrivate = true;
                    this.mode = "normal";
                    break;

                case "success":
                    this.mode = "normal";
                    break;

                case "unsupported":
                    this.crossChannelChatSupported = false;
                    this.conversationPrivate = true;
                    this.mode = "normal";
                    break;
            }

            /* only update the UI if needed */
            if(this.handle.selectedConversation() === this.conversationId)
                this.reportStateToUI();
        });
    }

    protected canClientAccessChat() {
        return this.conversationId === 0 || this.handle.connection.getClient().currentChannel()?.channelId === this.conversationId;
    }

    private executeHistoryQuery() {
        if(this.executingHistoryQueries || this.pendingHistoryQueries.length === 0)
            return;

        this.executingHistoryQueries = true;
        try {
            const promise = this.pendingHistoryQueries.pop_front()();
            promise
                .catch(error => log.error(LogCategory.CLIENT, tr("Conversation history query task threw an error; this should never happen: %o"), error))
                .then(() => { this.executingHistoryQueries = false; this.executeHistoryQuery(); });
        } catch (e) {
            this.executingHistoryQueries = false;
            throw e;
        }
    }

    public updateIndexFromServer(info: any) {
        if('error_id' in info) {
            /* TODO: Parse error, may be flag private or similar */
            return;
        }

        const timestamp = parseInt(info["timestamp"]);
        if(isNaN(timestamp))
            return;

        if(timestamp > this.lastReadMessage) {
            this.setUnreadTimestamp(this.lastReadMessage);

            /* TODO: Move the whole last read part to the channel entry itself? */
            this.handle.connection.channelTree.findChannel(this.conversationId)?.setUnread(true);
        }
    }

    public handleIncomingMessage(message: ChatMessage, isOwnMessage: boolean) {
        this.registerIncomingMessage(message, isOwnMessage, "m-" + this.conversationId + "-" + message.timestamp + "-" + Math.random());
    }

    public handleDeleteMessages(criteria: { begin: number, end: number, cldbid: number, limit: number }) {
        let limit = { current: criteria.limit };

        this.presentMessages = this.presentMessages.filter(message => {
            if(message.type !== "message")
                return;

            if(message.message.sender_database_id !== criteria.cldbid)
                return true;

            if(criteria.end != 0 && message.timestamp > criteria.end)
                return true;

            if(criteria.begin != 0 && message.timestamp < criteria.begin)
                return true;

            return --limit.current < 0;
        });

        this.events.fire("notify_chat_message_delete", { chatId: this.conversationId.toString(), criteria: criteria });
    }

    public deleteMessage(messageUniqueId: string) {
        const message = this.presentMessages.find(e => e.uniqueId === messageUniqueId);
        if(!message) {
            log.warn(LogCategory.CHAT, tr("Tried to delete an unknown message (id: %s)"), messageUniqueId);
            return;
        }

        if(message.type !== "message")
            return;

        this.handle.connection.serverConnection.send_command("conversationmessagedelete", {
            cid: this.conversationId,
            timestamp_begin: message.timestamp - 1,
            timestamp_end: message.timestamp + 1,
            limit: 1,
            cldbid: message.message.sender_database_id
        }, { process_result: false }).catch(error => {
            log.error(LogCategory.CHAT, tr("Failed to delete conversation message for conversation %d: %o"), this.conversationId, error);
            if(error instanceof CommandResult)
                error = error.extra_message || error.message;

            createErrorModal(tr("Failed to delete message"), traj("Failed to delete conversation message{:br:}Error: {}", error)).open();
        });
    }

    setUnreadTimestamp(timestamp: number | undefined) {
        super.setUnreadTimestamp(timestamp);

        /* we've to update the last read timestamp regardless of if we're having actual unread stuff */
        this.handle.connection.settings.changeServer(Settings.FN_CHANNEL_CHAT_READ(this.conversationId), typeof timestamp === "number" ? timestamp : Date.now());
    }

    public localClientSwitchedChannel(type: "join" | "leave") {
        this.presentEvents.push({
            type: "local-user-switch",
            uniqueId: "us-" + this.conversationId + "-" + Date.now() + "-" + Math.random(),
            timestamp: Date.now(),
            mode: type
        });

        if(this.conversationId === this.handle.selectedConversation())
            this.reportStateToUI();
    }

    sendMessage(text: string) {
        this.doSendMessage(text, this.conversationId ? 2 : 3, this.conversationId);
    }
}

export class ConversationManager extends AbstractChatManager<ConversationUIEvents> {
    readonly connection: ConnectionHandler;
    readonly htmlTag: HTMLDivElement;

    private conversations: {[key: number]: Conversation} = {};
    private selectedConversation_: number;

    constructor(connection: ConnectionHandler) {
        super();
        this.connection = connection;

        this.htmlTag = document.createElement("div");
        this.htmlTag.style.display = "flex";
        this.htmlTag.style.flexDirection = "column";
        this.htmlTag.style.justifyContent = "stretch";
        this.htmlTag.style.height = "100%";

        ReactDOM.render(React.createElement(ConversationPanel, {
            events: this.uiEvents,
            handlerId: this.connection.handlerId,
            noFirstMessageOverlay: false,
            messagesDeletable: true
        }), this.htmlTag);
        /*
        spawnExternalModal("conversation", this.uiEvents, {
            handlerId: this.connection.handlerId,
            noFirstMessageOverlay: false,
            messagesDeletable: true
        }).open().then(() => {
            console.error("Opened");
        });
        */

        this.uiEvents.on("action_select_chat", event => this.selectedConversation_ = parseInt(event.chatId));
        this.uiEvents.on("notify_destroy", connection.events().on("notify_connection_state_changed", event => {
            if(ConnectionState.socketConnected(event.old_state) !== ConnectionState.socketConnected(event.new_state)) {
                this.conversations = {};
                this.setSelectedConversation(-1);
            }
        }));
        this.uiEvents.on("notify_destroy", connection.events().on("notify_visibility_changed", event => {
            if(!event.visible)
                return;

            this.handlePanelShow();
        }));

        connection.events().one("notify_handler_initialized", () => this.uiEvents.on("notify_destroy", connection.getClient().events.on("notify_client_moved", event => {
            this.findOrCreateConversation(event.oldChannel.channelId).localClientSwitchedChannel("leave");
            this.findOrCreateConversation(event.newChannel.channelId).localClientSwitchedChannel("join");
        })));

        this.uiEvents.register_handler(this, true);
        this.uiEvents.on("notify_destroy", connection.serverConnection.command_handler_boss().register_explicit_handler("notifyconversationhistory", this.handleConversationHistory.bind(this)));
        this.uiEvents.on("notify_destroy", connection.serverConnection.command_handler_boss().register_explicit_handler("notifyconversationindex", this.handleConversationIndex.bind(this)));
        this.uiEvents.on("notify_destroy", connection.serverConnection.command_handler_boss().register_explicit_handler("notifyconversationmessagedelete", this.handleConversationMessageDelete.bind(this)));

        this.uiEvents.on("notify_destroy", this.connection.channelTree.events.on("notify_channel_list_received", () => {
            this.queryUnreadFlags();
        }));

        this.uiEvents.on("notify_destroy", this.connection.channelTree.events.on("notify_channel_updated", event => {
            /* TODO private flag! */
        }));
    }

    destroy() {
        ReactDOM.unmountComponentAtNode(this.htmlTag);
        this.htmlTag.remove();

        this.uiEvents.unregister_handler(this);
        this.uiEvents.fire("notify_destroy");
        this.uiEvents.destroy();
    }

    selectedConversation() {
        return this.selectedConversation_;
    }

    setSelectedConversation(id: number) {
        this.findOrCreateConversation(id);

        this.uiEvents.fire("notify_selected_chat", { chatId: id.toString() });
    }

    @EventHandler<ConversationUIEvents>("action_select_chat")
    private handleActionSelectChat(event: ConversationUIEvents["action_select_chat"]) {
        this.setSelectedConversation(parseInt(event.chatId));
    }

    findConversation(id: number) : Conversation {
        for(const conversation of Object.values(this.conversations))
            if(conversation.conversationId === id)
                return conversation;
        return undefined;
    }

    protected findChat(id: string): AbstractChat<ConversationUIEvents> {
        return this.findConversation(parseInt(id));
    }

    findOrCreateConversation(id: number) {
        let conversation = this.findConversation(id);
        if(!conversation) {
            conversation = new Conversation(this, this.uiEvents, id);
            this.conversations[id] = conversation;
        }

        return conversation;
    }

    destroyConversation(id: number) {
        delete this.conversations[id];

        if(id === this.selectedConversation_)
            this.uiEvents.fire("action_select_chat", { chatId: "unselected" });
    }

    queryUnreadFlags() {
        /* FIXME: Test for old TeaSpeak servers which don't support this */
        const commandData = this.connection.channelTree.channels.map(e => { return { cid: e.channelId, cpw: e.cached_password() }});
        this.connection.serverConnection.send_command("conversationfetch", commandData).catch(error => {
            log.warn(LogCategory.CHAT, tr("Failed to query conversation indexes: %o"), error);
        });
    }

    private handleConversationHistory(command: ServerCommand) {
        const conversation = this.findConversation(parseInt(command.arguments[0]["cid"]));
        if(!conversation) {
            log.warn(LogCategory.NETWORKING, tr("Received conversation history for an unknown conversation: %o"), command.arguments[0]["cid"]);
            return;
        }


        for(const entry of command.arguments) {
            conversation.historyQueryResponse.push({
                timestamp: parseInt(entry["timestamp"]),

                sender_database_id: parseInt(entry["sender_database_id"]),
                sender_unique_id: entry["sender_unique_id"],
                sender_name: entry["sender_name"],

                message: entry["msg"]
            });
        }
    }

    private handleConversationIndex(command: ServerCommand) {
        for(const entry of command.arguments) {
            const conversation = this.findOrCreateConversation(parseInt(entry["cid"]));
            conversation.updateIndexFromServer(entry);
        }
    }

    private handleConversationMessageDelete(command: ServerCommand) {
        const data = command.arguments[0];
        const conversation = this.findConversation(parseInt(data["cid"]));
        if(!conversation)
            return;

        conversation.handleDeleteMessages({
            limit: parseInt(data["limit"]),
            begin: parseInt(data["timestamp_begin"]),
            end: parseInt(data["timestamp_end"]),
            cldbid: parseInt(data["cldbid"])
        })
    }

    @EventHandler<ConversationUIEvents>("action_delete_message")
    private handleMessageDelete(event: ConversationUIEvents["action_delete_message"]) {
        const conversation = this.findConversation(parseInt(event.chatId));
        if(!conversation) {
            log.error(LogCategory.CLIENT, tr("Tried to delete a chat message from an unknown conversation with id %s"), event.chatId);
            return;
        }

        conversation.deleteMessage(event.uniqueId);
    }

    @EventHandler<ConversationUIEvents>("query_selected_chat")
    private handleQuerySelectedChat(event: ConversationUIEvents["query_selected_chat"]) {
        this.uiEvents.fire_async("notify_selected_chat", { chatId: isNaN(this.selectedConversation_) ? "unselected" : this.selectedConversation_ + ""})
    }

    @EventHandler<ConversationUIEvents>("notify_selected_chat")
    private handleNotifySelectedChat(event: ConversationUIEvents["notify_selected_chat"]) {
        this.selectedConversation_ = parseInt(event.chatId);
    }

    @EventHandler<ConversationUIEvents>("action_clear_unread_flag")
    protected handleClearUnreadFlag1(event: ConversationUIEvents["action_clear_unread_flag"]) {
        this.connection.channelTree.findChannel(parseInt(event.chatId))?.setUnread(false);
    }
}