# -*- coding: utf-8 -*-

# Copyright © 2018, 2019 Damir Jelić <poljar@termina.org.uk>
#
# Permission to use, copy, modify, and/or distribute this software for
# any purpose with or without fee is hereby granted, provided that the
# above copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

from __future__ import unicode_literals

import os
import pprint
import socket
import ssl
import time
import copy
from collections import defaultdict, deque
from atomicwrites import atomic_write
from typing import (
    Any,
    Deque,
    Dict,
    Optional,
    List,
    NamedTuple,
    DefaultDict,
    Type,
    Union,
)

from uuid import UUID

from nio import (
    Api,
    HttpClient,
    ClientConfig,
    LocalProtocolError,
    LoginResponse,
    LoginInfoResponse,
    Response,
    Rooms,
    RoomSendResponse,
    RoomSendError,
    SyncResponse,
    ShareGroupSessionResponse,
    ShareGroupSessionError,
    KeysQueryResponse,
    KeysClaimResponse,
    DevicesResponse,
    UpdateDeviceResponse,
    DeleteDevicesAuthResponse,
    DeleteDevicesResponse,
    TransportType,
    RoomMessagesResponse,
    RoomMessagesError,
    EncryptionError,
    GroupEncryptionError,
    OlmTrustError,
    ErrorResponse,
    SyncError,
    LoginError,
    JoinedMembersResponse,
    JoinedMembersError,
    RoomKeyEvent,
    KeyVerificationStart,
    KeyVerificationCancel,
    KeyVerificationKey,
    KeyVerificationMac,
    KeyVerificationEvent,
    ToDeviceMessage,
    ToDeviceResponse,
    ToDeviceError
)

from . import globals as G
from .buffer import OwnAction, OwnMessage, RoomBuffer
from .config import ConfigSection, Option, ServerBufferType
from .globals import SCRIPT_NAME, SERVERS, W, TYPING_NOTICE_TIMEOUT
from .utf import utf8_decode
from .utils import create_server_buffer, key_from_value, server_buffer_prnt
from .uploads import Upload

from .colors import Formatted, FormattedString, DEFAULT_ATTRIBUTES

try:
    from urllib.parse import urlparse
except ImportError:
    from urlparse import urlparse  # type: ignore

try:
    FileNotFoundError  # type: ignore
except NameError:
    FileNotFoundError = IOError


EncryptionQueueItem = NamedTuple(
    "EncryptionQueueItem",
    [
        ("message_type", str),
        ("message", Union[Formatted, Upload]),
    ],
)


class ServerConfig(ConfigSection):
    def __init__(self, server_name, config_ptr):
        # type: (str, str) -> None
        self._server_name = server_name
        self._config_ptr = config_ptr
        self._option_ptrs = {}  # type: Dict[str, str]

        options = [
            Option(
                "autoconnect",
                "boolean",
                "",
                0,
                0,
                "off",
                (
                    "automatically connect to the matrix server when weechat "
                    "is starting"
                ),
            ),
            Option(
                "address",
                "string",
                "",
                0,
                0,
                "",
                (
                    "Hostname or address of the server (note: content is "
                    "evaluated, see /help eval)"
                )
            ),
            Option(
                "port", "integer", "", 0, 65535, "443", "Port for the server"
            ),
            Option(
                "proxy",
                "string",
                "",
                0,
                0,
                "",
                ("Name of weechat proxy to use (see /help proxy) (note: "
                 "content is evaluated, see /help eval)"),
            ),
            Option(
                "ssl_verify",
                "boolean",
                "",
                0,
                0,
                "on",
                ("Check that the SSL connection is fully trusted"),
            ),
            Option(
                "username",
                "string",
                "",
                0,
                0,
                "",
                (
                    "Username to use on the server (note: content is "
                    "evaluated, see /help eval)"
                )
            ),
            Option(
                "password",
                "string",
                "",
                0,
                0,
                "",
                (
                    "Password for the server (note: content is evaluated, see "
                    "/help eval)"
                ),
            ),
            Option(
                "device_name",
                "string",
                "",
                0,
                0,
                "Weechat Matrix",
                (
                    "Device name to use when logging in, this "
                    "is only used on the firt login. Afther that the /devices "
                    "command can be used to change the device name. (note: "
                    "content is evaluated, see /help eval)"
                )
            ),
            Option(
                "autoreconnect_delay",
                "integer",
                "",
                0,
                86400,
                "10",
                ("Delay (in seconds) before trying to reconnect to server"),
            ),
            Option(
                "sso_helper_listening_port",
                "integer",
                "",
                0,
                65535,
                "0",
                ("The port that the SSO helpers web server  should listen on"),
            ),
        ]

        section = W.config_search_section(config_ptr, "server")
        self._ptr = section

        for option in options:
            option_name = "{server}.{option}".format(
                server=self._server_name, option=option.name
            )

            self._option_ptrs[option.name] = W.config_new_option(
                config_ptr,
                section,
                option_name,
                option.type,
                option.description,
                option.string_values,
                option.min,
                option.max,
                option.value,
                option.value,
                0,
                "",
                "",
                "matrix_config_server_change_cb",
                self._server_name,
                "",
                "",
            )

    autoconnect = ConfigSection.option_property("autoconnect", "boolean")
    address = ConfigSection.option_property("address", "string", evaluate=True)
    port = ConfigSection.option_property("port", "integer")
    proxy = ConfigSection.option_property("proxy", "string", evaluate=True)
    ssl_verify = ConfigSection.option_property("ssl_verify", "boolean")
    username = ConfigSection.option_property("username", "string",
        evaluate=True)
    device_name = ConfigSection.option_property("device_name", "string",
        evaluate=True)
    reconnect_delay = ConfigSection.option_property("autoreconnect_delay", "integer")
    password = ConfigSection.option_property(
        "password", "string", evaluate=True
    )
    sso_helper_listening_port = ConfigSection.option_property(
        "sso_helper_listening_port",
        "integer"
    )

    def free(self):
        W.config_section_free_options(self._ptr)


class MatrixServer(object):
    # pylint: disable=too-many-instance-attributes
    def __init__(self, name, config_ptr):
        # type: (str, str) -> None
        # yapf: disable
        self.name = name                     # type: str
        self.user_id = ""
        self.device_id = ""                  # type: str

        self.room_buffers = dict()  # type: Dict[str, RoomBuffer]
        self.buffers = dict()                # type: Dict[str, str]
        self.server_buffer = None            # type: Optional[str]
        self.fd_hook = None                  # type: Optional[str]
        self.ssl_hook = None                 # type: Optional[str]
        self.timer_hook = None               # type: Optional[str]
        self.numeric_address = ""            # type: Optional[str]

        self._connected = False     # type: bool
        self.connecting = False     # type: bool
        self.reconnect_delay = 0    # type: int
        self.reconnect_time = None  # type: Optional[float]
        self.sync_time = None       # type: Optional[float]
        self.socket = None          # type: Optional[ssl.SSLSocket]
        self.ssl_context = ssl.create_default_context()  # type: ssl.SSLContext
        self.transport_type = None  # type: Optional[TransportType]

        self.sso_hook = None

        # Enable http2 negotiation on the ssl context.
        self.ssl_context.set_alpn_protocols(["h2", "http/1.1"])

        self.address = None
        self.homeserver = None
        self.client = None  # type: Optional[HttpClient]
        self.access_token = None                         # type: Optional[str]
        self.next_batch = None                           # type: Optional[str]
        self.transaction_id = 0                          # type: int
        self.lag = 0                                     # type: int
        self.lag_done = False                            # type: bool
        self.busy = False                                # type: bool
        self.first_sync = True

        self.send_fd_hook = None                         # type: Optional[str]
        self.send_buffer = b""                           # type: bytes
        self.device_check_timestamp = None               # type: Optional[int]

        self.device_deletion_queue = dict()              # type: Dict[str, str]

        self.encryption_queue = defaultdict(deque)  \
            # type: DefaultDict[str, Deque[EncryptionQueueItem]]
        self.backlog_queue = dict()      # type: Dict[str, str]

        self.user_gc_time = time.time()    # type: float
        self.member_request_list = []         # type: List[str]
        self.rooms_with_missing_members = []  # type: List[str]
        self.lazy_load_hook = None       # type: Optional[str]

        # These flags remember if we made some requests so that we don't
        # make them again while we wait on a response, the flags need to be
        # cleared when we disconnect.
        self.keys_queried = False                      # type: bool
        self.keys_claimed = defaultdict(bool)          # type: Dict[str, bool]
        self.group_session_shared = defaultdict(bool)  # type: Dict[str, bool]
        self.ignore_while_sharing = defaultdict(bool)  # type: Dict[str, bool]
        self.to_device_sent = []  # type: List[ToDeviceMessage]

        # Try to load the device id, the device id is loaded every time the
        # user changes but some login flows don't use a user so try to load the
        # device for a main user.
        self._load_device_id("main")
        self.config = ServerConfig(self.name, config_ptr)
        self._create_session_dir()
        # yapf: enable

    def _create_session_dir(self):
        path = os.path.join("matrix", self.name)
        if not W.mkdir_home(path, 0o700):
            message = (
                "{prefix}matrix: Error creating server session " "directory"
            ).format(prefix=W.prefix("error"))
            W.prnt("", message)

    @property
    def connected(self):
        return self._connected

    @connected.setter
    def connected(self, value):
        self._connected = value
        W.bar_item_update("buffer_modes")
        W.bar_item_update("matrix_modes")

    def get_session_path(self):
        home_dir = W.info_get("weechat_dir", "")
        return os.path.join(home_dir, "matrix", self.name)

    def _load_device_id(self, user=None):
        user = user or self.config.username

        file_name = "{}{}".format(user, ".device_id")
        path = os.path.join(self.get_session_path(), file_name)

        if not os.path.isfile(path):
            return

        with open(path, "r") as device_file:
            device_id = device_file.readline().rstrip()
            if device_id:
                self.device_id = device_id

    def save_device_id(self):
        file_name = "{}{}".format(self.config.username or "main", ".device_id")
        path = os.path.join(self.get_session_path(), file_name)

        with atomic_write(path, overwrite=True) as device_file:
            device_file.write(self.device_id)

    @staticmethod
    def _parse_url(address, port):
        if not address.startswith("http"):
            address = "https://{}".format(address)

        parsed_url = urlparse(address)

        homeserver = parsed_url._replace(
            netloc=parsed_url.hostname + ":{}".format(port)
        )

        return homeserver

    def _change_client(self):
        homeserver = MatrixServer._parse_url(
            self.config.address,
            self.config.port
        )
        self.address = homeserver.hostname
        self.homeserver = homeserver

        config = ClientConfig(store_sync_tokens=True)

        self.client = HttpClient(
            homeserver.geturl(),
            self.config.username,
            self.device_id,
            self.get_session_path(),
            config=config
        )
        self.client.add_to_device_callback(
            self.key_verification_cb,
            KeyVerificationEvent
        )

    def key_verification_cb(self, event):
        if isinstance(event, KeyVerificationStart):
            self.info_highlight("{user} via {device} has started a key "
                                "verification process.\n"
                                "To accept use /olm verification "
                                "accept {user} {device}".format(
                                    user=event.sender,
                                    device=event.from_device
                                ))

        elif isinstance(event, KeyVerificationKey):
            sas = self.client.key_verifications.get(event.transaction_id, None)
            if not sas:
                return

            if sas.canceled:
                return

            device = sas.other_olm_device
            emoji = sas.get_emoji()

            emojis = [x[0] for x in emoji]
            descriptions = [x[1] for x in emoji]

            centered_width = 12

            def center_emoji(emoji, width):
                # Assume each emoji has width 2
                emoji_width = 2

                # These are emojis that need VARIATION-SELECTOR-16 (U+FE0F) so
                # that they are rendered with coloured glyphs. For these, we
                # need to add an extra space after them so that they are
                # rendered properly in weechat.
                variation_selector_emojis = [
                    '☁️',
                    '❤️',
                    '☂️',
                    '✏️',
                    '✂️',
                    '☎️',
                    '✈️'
                ]

                # Hack to make weechat behave properly when one of the above is
                # printed.
                if emoji in variation_selector_emojis:
                    emoji += " "

                # This is a trick to account for the fact that emojis are wider
                # than other monospace characters.
                placeholder = '.' * emoji_width

                return placeholder.center(width).replace(placeholder, emoji)

            emoji_str = u"".join(center_emoji(e, centered_width)
                                 for e in emojis)
            desc = u"".join(d.center(centered_width) for d in descriptions)
            short_string = u"\n".join([emoji_str, desc])

            self.info_highlight(u"Short authentication string for "
                                u"{user} via {device}:\n{string}\n"
                                u"Confirm that the strings match with "
                                u"/olm verification confirm {user} "
                                u"{device}".format(
                                    user=device.user_id,
                                    device=device.id,
                                    string=short_string
                                ))

        elif isinstance(event, KeyVerificationMac):
            try:
                sas = self.client.key_verifications[event.transaction_id]
            except KeyError:
                return

            device = sas.other_olm_device

            if sas.verified:
                self.info_highlight("Device {} of user {} successfully "
                                    "verified".format(
                                        device.id,
                                        device.user_id
                                    ))

        elif isinstance(event, KeyVerificationCancel):
            self.info_highlight("The interactive device verification with "
                                "user {} got canceled: {}.".format(
                                    event.sender,
                                    event.reason
                                ))

    def update_option(self, option, option_name):
        if option_name == "address":
            self._change_client()
        elif option_name == "port":
            self._change_client()
        elif option_name == "ssl_verify":
            value = W.config_boolean(option)
            if value:
                self.ssl_context.verify_mode = ssl.CERT_REQUIRED
                self.ssl_context.check_hostname = True
            else:
                self.ssl_context.check_hostname = False
                self.ssl_context.verify_mode = ssl.CERT_NONE
        elif option_name == "username":
            value = W.config_string(option)
            self.access_token = ""

            self._load_device_id()

            if self.client:
                self.client.user = value
                if self.device_id:
                    self.client.device_id = self.device_id
        else:
            pass

    def send_or_queue(self, request):
        # type: (bytes) -> None
        self.send(request)

    def try_send(self, message):
        # type: (MatrixServer, bytes) -> bool

        sock = self.socket

        if not sock:
            return False

        total_sent = 0
        message_length = len(message)

        while total_sent < message_length:
            try:
                sent = sock.send(message[total_sent:])

            except ssl.SSLWantWriteError:
                hook = W.hook_fd(sock.fileno(), 0, 1, 0, "send_cb", self.name)
                self.send_fd_hook = hook
                self.send_buffer = message[total_sent:]
                return True

            except socket.error as error:
                self._abort_send()

                errno = "error" + str(error.errno) + " " if error.errno else ""
                strerr = error.strerror if error.strerror else "Unknown reason"
                strerr = errno + strerr

                error_message = (
                    "{prefix}Error while writing to " "socket: {error}"
                ).format(prefix=W.prefix("network"), error=strerr)

                server_buffer_prnt(self, error_message)
                server_buffer_prnt(
                    self,
                    ("{prefix}matrix: disconnecting from server...").format(
                        prefix=W.prefix("network")
                    ),
                )

                self.disconnect()
                return False

            if sent == 0:
                self._abort_send()

                server_buffer_prnt(
                    self,
                    "{prefix}matrix: Error while writing to socket".format(
                        prefix=W.prefix("network")
                    ),
                )
                server_buffer_prnt(
                    self,
                    ("{prefix}matrix: disconnecting from server...").format(
                        prefix=W.prefix("network")
                    ),
                )
                self.disconnect()
                return False

            total_sent = total_sent + sent

        self._finalize_send()
        return True

    def _abort_send(self):
        self.send_buffer = b""

    def _finalize_send(self):
        # type: (MatrixServer) -> None
        self.send_buffer = b""

    def info_highlight(self, message):
        buf = ""
        if self.server_buffer:
            buf = self.server_buffer

        msg = "{}{}: {}".format(W.prefix("network"), SCRIPT_NAME, message)
        W.prnt_date_tags(buf, 0, "notify_highlight", msg)

    def info(self, message):
        buf = ""
        if self.server_buffer:
            buf = self.server_buffer

        msg = "{}{}: {}".format(W.prefix("network"), SCRIPT_NAME, message)
        W.prnt(buf, msg)

    def error(self, message):
        buf = ""
        if self.server_buffer:
            buf = self.server_buffer

        msg = "{}{}: {}".format(W.prefix("error"), SCRIPT_NAME, message)
        W.prnt(buf, msg)

    def send(self, data):
        # type: (bytes) -> bool
        self.try_send(data)

        return True

    def reconnect(self):
        message = ("{prefix}matrix: reconnecting to server...").format(
            prefix=W.prefix("network")
        )

        server_buffer_prnt(self, message)

        self.reconnect_time = None

        if not self.connect():
            self.schedule_reconnect()

    def schedule_reconnect(self):
        # type: (MatrixServer) -> None
        self.connecting = True
        self.reconnect_time = time.time()

        if self.reconnect_delay:
            self.reconnect_delay = (
                self.reconnect_delay
                * G.CONFIG.network.autoreconnect_delay_growing
            )
        else:
            self.reconnect_delay = self.config.reconnect_delay

        if G.CONFIG.network.autoreconnect_delay_max > 0:
            self.reconnect_delay = min(self.reconnect_delay,
                G.CONFIG.network.autoreconnect_delay_max)

        message = (
            "{prefix}matrix: reconnecting to server in {t} " "seconds"
        ).format(prefix=W.prefix("network"), t=self.reconnect_delay)

        server_buffer_prnt(self, message)

    def _close_socket(self):
        # type: () -> None
        if self.socket:
            try:
                self.socket.shutdown(socket.SHUT_RDWR)
            except socket.error:
                pass

            try:
                self.socket.close()
            except OSError:
                pass

    def disconnect(self, reconnect=True):
        # type: (bool) -> None
        if self.fd_hook:
            W.unhook(self.fd_hook)

        self._close_socket()

        self.fd_hook = None
        self.socket = None
        self.connected = False
        self.access_token = ""

        self.send_buffer = b""
        self.transport_type = None
        self.member_request_list = []

        if self.client:
            try:
                self.client.disconnect()
            except LocalProtocolError:
                pass

        self.lag = 0
        W.bar_item_update("lag")
        self.reconnect_time = None

        # Clear our request flags.
        self.keys_queried = False
        self.keys_claimed = defaultdict(bool)
        self.group_session_shared = defaultdict(bool)
        self.ignore_while_sharing = defaultdict(bool)
        self.to_device_sent = []

        if self.server_buffer:
            message = ("{prefix}matrix: disconnected from server").format(
                prefix=W.prefix("network")
            )
            server_buffer_prnt(self, message)

        if reconnect:
            self.schedule_reconnect()
        else:
            self.reconnect_delay = 0

    def connect(self):
        # type: (MatrixServer) -> int
        if not self.config.address or not self.config.port:
            message = "{prefix}Server address or port not set".format(
                prefix=W.prefix("error")
            )
            W.prnt("", message)
            return False

        if self.connected:
            return True

        if not self.server_buffer:
            create_server_buffer(self)

        if not self.timer_hook:
            self.timer_hook = W.hook_timer(
                1 * 1000, 0, 0, "matrix_timer_cb", self.name
            )

        ssl_message = " (SSL)" if self.ssl_context.check_hostname else ""

        message = (
            "{prefix}matrix: Connecting to " "{server}:{port}{ssl}..."
        ).format(
            prefix=W.prefix("network"),
            server=self.address,
            port=self.config.port,
            ssl=ssl_message,
        )

        W.prnt(self.server_buffer, message)

        W.hook_connect(
            self.config.proxy,
            self.address,
            self.config.port,
            1,
            0,
            "",
            "connect_cb",
            self.name,
        )

        return True

    def schedule_sync(self):
        self.sync_time = time.time()

    def sync(self, timeout=None, sync_filter=None):
        # type: (Optional[int], Optional[Dict[Any, Any]]) -> None
        if not self.client:
            return

        self.sync_time = None
        _, request = self.client.sync(timeout, sync_filter,
            full_state=self.first_sync)

        self.send_or_queue(request)

    def login_info(self):
        # type: () -> None
        if not self.client:
            return

        if self.client.logged_in:
            self.login()
            return

        _, request = self.client.login_info()
        self.send(request)

    """Start a local HTTP server to listen for SSO tokens."""
    def start_login_sso(self):
        # type: () -> None
        if self.sso_hook:
            # If there is a stale SSO process hanging around kill it. We could
            # let it stay around but the URL that needs to be opened by the
            # user is printed out in the callback.
            W.hook_set(self.sso_hook, "signal", "term")
            self.sso_hook = None

        process_args = {
            "buffer_flush": "1",
            "arg1": "--port",
            "arg2": str(self.config.sso_helper_listening_port)
        }

        self.sso_hook = W.hook_process_hashtable(
            "matrix_sso_helper",
            process_args,
            0,
            "sso_login_cb",
            self.name
        )

    def login(self, token=None):
        # type: (...) -> None
        assert self.client is not None
        if self.client.logged_in:
            msg = (
                "{prefix}{script_name}: Already logged in, " "syncing..."
            ).format(prefix=W.prefix("network"), script_name=SCRIPT_NAME)
            W.prnt(self.server_buffer, msg)
            timeout = 0 if self.transport_type == TransportType.HTTP else 30000
            limit = (G.CONFIG.network.max_initial_sync_events if self.first_sync else 500)
            sync_filter = {
                "room": {
                    "timeline": {"limit": limit},
                    "state": {"lazy_load_members": True}
                }
            }
            self.sync(timeout, sync_filter)
            return

        if (not self.config.username or not self.config.password) and not token:
            message = "{prefix}User or password not set".format(
                prefix=W.prefix("error")
            )
            W.prnt("", message)
            return self.disconnect()

        if token:
            _, request = self.client.login(
                device_name=self.config.device_name, token=token
            )
        else:
            _, request = self.client.login(
                password=self.config.password, device_name=self.config.device_name
            )
        self.send_or_queue(request)

        msg = "{prefix}matrix: Logging in...".format(
            prefix=W.prefix("network")
        )

        W.prnt(self.server_buffer, msg)

    def devices(self):
        _, request = self.client.devices()
        self.send_or_queue(request)

    def delete_device(self, device_id, auth=None):
        uuid, request = self.client.delete_devices([device_id], auth)
        self.device_deletion_queue[uuid] = device_id
        self.send_or_queue(request)
        return

    def rename_device(self, device_id, display_name):
        content = {
            "display_name": display_name
        }

        _, request = self.client.update_device(device_id, content)
        self.send_or_queue(request)

    def room_send_state(self, room_buffer, body, event_type):
        _, request = self.client.room_put_state(
            room_buffer.room.room_id, event_type, body
        )
        self.send_or_queue(request)

    def room_send_redaction(self, room_buffer, event_id, reason=None):
        _, request = self.client.room_redact(
            room_buffer.room.room_id, event_id, reason
        )
        self.send_or_queue(request)

    def room_kick(self, room_buffer, user_id, reason=None):
        _, request = self.client.room_kick(
            room_buffer.room.room_id, user_id, reason
        )
        self.send_or_queue(request)

    def room_invite(self, room_buffer, user_id):
        _, request = self.client.room_invite(room_buffer.room.room_id, user_id)
        self.send_or_queue(request)

    def room_join(self, room_id):
        _, request = self.client.join(room_id)
        self.send_or_queue(request)

    def room_leave(self, room_id):
        _, request = self.client.room_leave(room_id)
        self.send_or_queue(request)

    def room_get_messages(self, room_id):
        if not self.connected or not self.client.logged_in:
            return False

        room_buffer = self.find_room_from_id(room_id)

        # We're already fetching old messages
        if room_buffer.backlog_pending:
            return False

        if not room_buffer.prev_batch:
            return False

        uuid, request = self.client.room_messages(
            room_id,
            room_buffer.prev_batch,
            limit=10)

        room_buffer.backlog_pending = True
        self.backlog_queue[uuid] = room_id
        self.send_or_queue(request)

        return True

    def room_send_read_marker(self, room_id, event_id):
        """Send read markers for the provided room.

        Args:
            room_id(str): the room for which the read markers should
                be sent.
            event_id(str): the event id where to set the marker
        """
        if not self.connected or not self.client.logged_in:
            return

        _, request = self.client.room_read_markers(
            room_id,
            fully_read_event=event_id,
            read_event=event_id)
        self.send(request)

    def room_send_typing_notice(self, room_buffer):
        """Send a typing notice for the provided room.

        Args:
            room_buffer(RoomBuffer): the room for which the typing notice needs
                to be sent.
        """
        if not self.connected or not self.client.logged_in:
            return

        input = room_buffer.weechat_buffer.input

        typing_enabled = bool(int(W.string_eval_expression(
            G.CONFIG.network.typing_notice_conditions,
            {},
            {"typing_enabled": str(int(room_buffer.typing_enabled))},
            {"type": "condition"}
        )))

        if not typing_enabled:
            return

        # Don't send a typing notice if the user is typing in a weechat command
        if input.startswith("/") and not input.startswith("//"):
            return

        # Don't send a typing notice if we only typed a couple of letters.
        elif len(input) < 4 and not room_buffer.typing:
            return

        # If we were typing already and our input bar now has no letters or
        # only a couple of letters stop the typing notice.
        elif len(input) < 4:
            _, request = self.client.room_typing(
                room_buffer.room.room_id,
                typing_state=False)
            room_buffer.typing = False
            self.send(request)
            return

        # Don't send out a typing notice if we already sent one out and it
        # didn't expire yet.
        if not room_buffer.typing_notice_expired:
            return

        _, request = self.client.room_typing(
            room_buffer.room.room_id,
            typing_state=True,
            timeout=TYPING_NOTICE_TIMEOUT)

        room_buffer.typing = True
        self.send(request)

    def room_send_upload(
        self,
        upload
    ):
        """Send a room message containing the mxc URI of an upload."""
        try:
            room_buffer = self.find_room_from_id(upload.room_id)
        except (ValueError, KeyError):
            return True

        assert self.client

        if room_buffer.room.encrypted:
            assert upload.encrypt

        content = upload.content

        try:
            uuid = self.room_send_event(upload.room_id, content)
        except (EncryptionError, GroupEncryptionError):
            message = EncryptionQueueItem(upload.msgtype, upload)
            self.encryption_queue[upload.room_id].append(message)
            return False

        attributes = DEFAULT_ATTRIBUTES.copy()
        formatted = Formatted([FormattedString(
            upload.render,
            attributes
        )])

        own_message = OwnMessage(
            self.user_id, 0, "", uuid, upload.room_id, formatted
        )

        room_buffer.sent_messages_queue[uuid] = own_message
        self.print_unconfirmed_message(room_buffer, own_message)

        return True

    def share_group_session(
        self,
        room_id,
        ignore_missing_sessions=False,
        ignore_unverified_devices=False
    ):

        self.ignore_while_sharing[room_id] = ignore_unverified_devices

        _, request = self.client.share_group_session(
            room_id,
            ignore_missing_sessions=ignore_missing_sessions,
            ignore_unverified_devices=ignore_unverified_devices
        )
        self.send(request)
        self.group_session_shared[room_id] = True

    def room_send_event(
        self,
        room_id,    # type: str
        content,    # type: Dict[str, str]
        event_type="m.room.message",      # type: str
        ignore_unverified_devices=False,  # type: bool
    ):
        # type: (...) -> UUID
        assert self.client

        try:
            uuid, request = self.client.room_send(
                room_id, event_type, content
            )
            self.send(request)
            return uuid
        except GroupEncryptionError:
            try:
                if not self.group_session_shared[room_id]:
                    self.share_group_session(
                        room_id,
                        ignore_unverified_devices=ignore_unverified_devices
                    )
                raise

            except EncryptionError:
                if not self.keys_claimed[room_id]:
                    _, request = self.client.keys_claim(room_id)
                    self.keys_claimed[room_id] = True
                    self.send(request)
                raise

    def room_send_message(
        self,
        room_buffer,  # type: RoomBuffer
        formatted,    # type: Formatted
        msgtype="m.text",  # type: str
        ignore_unverified_devices=False,  # type: bool
        in_reply_to_event_id="",  # type: str
    ):
        # type: (...) -> bool
        room = room_buffer.room

        assert self.client

        content = {"msgtype": msgtype, "body": formatted.to_plain()}

        if formatted.is_formatted() or in_reply_to_event_id:
            content["format"] = "org.matrix.custom.html"
            content["formatted_body"] = formatted.to_html()
            if in_reply_to_event_id:
                content["m.relates_to"] = {
                    "m.in_reply_to": {"event_id": in_reply_to_event_id}
                }

        try:
            uuid = self.room_send_event(
                room.room_id,
                content,
                ignore_unverified_devices=ignore_unverified_devices
            )
        except (EncryptionError, GroupEncryptionError):
            message = EncryptionQueueItem(msgtype, formatted)
            self.encryption_queue[room.room_id].append(message)
            return False

        if msgtype == "m.emote":
            message_class = OwnAction  # type: Type
        else:
            message_class = OwnMessage

        own_message = message_class(
            self.user_id, 0, "", uuid, room.room_id, formatted
        )

        room_buffer.sent_messages_queue[uuid] = own_message
        self.print_unconfirmed_message(room_buffer, own_message)

        return True

    def print_unconfirmed_message(self, room_buffer, message):
        """Print an outgoing message before getting a receive confirmation.

        The message is printed out greyed out and only printed out if the
        client is configured to do so. The message needs to be later modified
        to contain proper coloring, this is done in the
        replace_printed_line_by_uuid() method of the RoomBuffer class.

        Args:
            room_buffer(RoomBuffer): the buffer of the room where the message
                needs to be printed out
            message(OwnMessages): the message that should be printed out
        """
        if G.CONFIG.network.print_unconfirmed_messages:
            room_buffer.printed_before_ack_queue.append(message.uuid)
            plain_message = message.formatted_message.to_weechat()
            plain_message = W.string_remove_color(plain_message, "")
            attributes = DEFAULT_ATTRIBUTES.copy()
            attributes["fgcolor"] = G.CONFIG.color.unconfirmed_message_fg
            attributes["bgcolor"] = G.CONFIG.color.unconfirmed_message_bg
            new_formatted = Formatted([FormattedString(
                plain_message,
                attributes
            )])

            new_message = copy.copy(message)
            new_message.formatted_message = new_formatted

            if isinstance(new_message, OwnAction):
                room_buffer.self_action(new_message)
            elif isinstance(new_message, OwnMessage):
                room_buffer.self_message(new_message)

    def keys_upload(self):
        _, request = self.client.keys_upload()
        self.send_or_queue(request)

    def keys_query(self):
        _, request = self.client.keys_query()
        self.keys_queried = True
        self.send_or_queue(request)

    def get_joined_members(self, room_id):
        if not self.connected or not self.client.logged_in:
            return

        if room_id in self.member_request_list:
            return

        self.member_request_list.append(room_id)
        _, request = self.client.joined_members(room_id)
        self.send(request)

    def _print_message_error(self, message):
        server_buffer_prnt(
            self,
            (
                "{prefix}Unhandled {status_code} error, please "
                "inform the developers about this."
            ).format(
                prefix=W.prefix("error"), status_code=message.response.status
            ),
        )

        server_buffer_prnt(self, pprint.pformat(message.__class__.__name__))
        server_buffer_prnt(self, pprint.pformat(message.request.payload))
        server_buffer_prnt(self, pprint.pformat(message.response.body))

    def handle_own_messages_error(self, response):
        room_buffer = self.room_buffers[response.room_id]

        if response.uuid not in room_buffer.printed_before_ack_queue:
            return

        message = room_buffer.sent_messages_queue.pop(response.uuid)
        room_buffer.mark_message_as_unsent(response.uuid, message)
        room_buffer.printed_before_ack_queue.remove(response.uuid)

    def handle_own_messages(self, response):
        def send_marker():
            if not room_buffer.read_markers_enabled:
                return

            self.room_send_read_marker(response.room_id, response.event_id)
            room_buffer.last_read_event = response.event_id

        room_buffer = self.room_buffers[response.room_id]

        message = room_buffer.sent_messages_queue.pop(response.uuid, None)

        # The message might have been returned in a sync response before we got
        # a room send response.
        if not message:
            return

        message.event_id = response.event_id
        # We already printed the message, just modify it to contain the proper
        # colors and formatting.
        if response.uuid in room_buffer.printed_before_ack_queue:
            room_buffer.replace_printed_line_by_uuid(response.uuid, message)
            room_buffer.printed_before_ack_queue.remove(response.uuid)
            send_marker()
            return

        if isinstance(message, OwnAction):
            room_buffer.self_action(message)
            send_marker()
            return
        if isinstance(message, OwnMessage):
            room_buffer.self_message(message)
            send_marker()
            return

        raise NotImplementedError(
            "Unsupported message of type {}".format(type(message))
        )

    def handle_backlog_response(self, response):
        room_id = self.backlog_queue.pop(response.uuid)
        room_buffer = self.find_room_from_id(room_id)
        room_buffer.first_view = False

        room_buffer.handle_backlog(response)

    def handle_devices_response(self, response):
        if not response.devices:
            m = "{}{}: No devices found for this account".format(
                    W.prefix("error"),
                    SCRIPT_NAME)
            W.prnt(self.server_buffer, m)

        header = (W.prefix("network") + SCRIPT_NAME + ": Devices for "
                  "server {}{}{}:\n"
                  "  Device ID         Device Name                       "
                  "Last Seen").format(
                      W.color("chat_server"),
                      self.name,
                      W.color("reset")
                  )
        W.prnt(self.server_buffer, header)

        lines = []
        for device in response.devices:
            last_seen_date = ("?" if not device.last_seen_date else
                              device.last_seen_date.strftime("%Y/%m/%d %H:%M"))
            last_seen = "{ip} @ {date}".format(
                ip=device.last_seen_ip or "?",
                date=last_seen_date
            )
            device_color = ("chat_self" if device.id == self.device_id else
                            W.info_get("nick_color_name", device.id))
            bold = W.color("bold") if device.id == self.device_id else ""
            line = "  {}{}{:<18}{}{:<34}{:<}".format(
                bold,
                W.color(device_color),
                device.id,
                W.color("resetcolor"),
                device.display_name or "",
                last_seen
                )
            lines.append(line)
        W.prnt(self.server_buffer, "\n".join(lines))

    """Handle a login info response and chose one of the available flows

    This currently supports only SSO and password logins. If both are available
    password takes precedence over SSO if a username and password is provided.

    """
    def _handle_login_info(self, response):
        if ("m.login.sso" in response.flows
                and (not self.config.username or not self.config.password)):
            self.start_login_sso()
        elif "m.login.password" in response.flows:
            self.login()
        else:
            self.error("No supported login flow found")
            self.disconnect()

    def _handle_login(self, response):
        self.access_token = response.access_token
        self.user_id = response.user_id
        self.client.access_token = response.access_token
        self.device_id = response.device_id
        self.save_device_id()

        message = "{prefix}matrix: Logged in as {user}".format(
            prefix=W.prefix("network"), user=self.user_id
        )

        W.prnt(self.server_buffer, message)

        if not self.client.olm_account_shared:
            self.keys_upload()

        sync_filter = {
            "room": {
                "timeline": {
                    "limit": G.CONFIG.network.max_initial_sync_events
                },
                "state": {"lazy_load_members": True}
            }
        }
        self.sync(timeout=0, sync_filter=sync_filter)

    def _handle_room_info(self, response):
        for room_id, info in response.rooms.invite.items():
            room = self.client.invited_rooms.get(room_id, None)

            if room:
                if room.inviter:
                    inviter_msg = " by {}{}".format(
                        W.color("chat_nick_other"), room.inviter
                    )
                else:
                    inviter_msg = ""

                self.info_highlight(
                    "You have been invited to {} {}({}{}{}){}"
                    "{}".format(
                        room.display_name,
                        W.color("chat_delimiters"),
                        W.color("chat_channel"),
                        room_id,
                        W.color("chat_delimiters"),
                        W.color("reset"),
                        inviter_msg,
                    )
                )
            else:
                self.info_highlight("You have been invited to {}.".format(
                    room_id
                ))

        for room_id, info in response.rooms.leave.items():
            if room_id not in self.buffers:
                continue

            room_buffer = self.find_room_from_id(room_id)
            room_buffer.handle_left_room(info)

        for room_id, info in response.rooms.join.items():
            if room_id not in self.buffers:
                self.create_room_buffer(room_id, info.timeline.prev_batch)

            room_buffer = self.find_room_from_id(room_id)
            room_buffer.handle_joined_room(info)

    def add_unhandled_users(self, rooms, n):
        # type: (List[RoomBuffer], int) -> bool
        total_users = 0

        while total_users <= n:
            try:
                room_buffer = rooms.pop()
            except IndexError:
                return False

            handled_users = 0

            users = room_buffer.unhandled_users

            for user_id in users:
                room_buffer.add_user(user_id, 0, True)
                handled_users += 1
                total_users += 1

                if total_users >= n:
                    room_buffer.unhandled_users = users[handled_users:]
                    rooms.append(room_buffer)
                    return True

            room_buffer.unhandled_users = []

        return False

    def _hook_lazy_user_adding(self):
        if not self.lazy_load_hook:
            hook = W.hook_timer(1 * 1000, 0, 0,
                                "matrix_load_users_cb", self.name)
            self.lazy_load_hook = hook

    def decrypt_printed_messages(self, key_event):
        """Decrypt already printed messages and send them to the buffer"""
        try:
            room_buffer = self.find_room_from_id(key_event.room_id)
        except KeyError:
            return

        decrypted_events = []

        for undecrypted_event in room_buffer.undecrypted_events:
            if undecrypted_event.session_id != key_event.session_id:
                continue

            event = self.client.decrypt_event(undecrypted_event)
            if event:
                decrypted_events.append((undecrypted_event, event))

        for event_pair in decrypted_events:
            undecrypted_event, event = event_pair
            room_buffer.undecrypted_events.remove(undecrypted_event)
            room_buffer.replace_undecrypted_line(event)

    def start_verification(self, device):
        _, request = self.client.start_key_verification(device)
        self.send(request)
        self.info("Starting an interactive device verification with "
                  "{} {}".format(device.user_id, device.id))

    def accept_sas(self, sas):
        _, request = self.client.accept_key_verification(sas.transaction_id)
        self.send(request)

    def cancel_sas(self, sas):
        _, request = self.client.cancel_key_verification(sas.transaction_id)
        self.send(request)

    def to_device(self, message):
        _, request = self.client.to_device(message)
        self.send(request)

    def confirm_sas(self, sas):
        _, request = self.client.confirm_short_auth_string(sas.transaction_id)
        self.send(request)

        device = sas.other_olm_device

        if sas.verified:
            self.info("Device {} of user {} successfully verified".format(
                device.id,
                device.user_id
            ))
        else:
            self.info("Waiting for {} to confirm...".format(device.user_id))

    def _handle_sync(self, response):
        # we got the same batch again, nothing to do
        self.first_sync = False

        if self.next_batch == response.next_batch:
            self.schedule_sync()
            return

        self._handle_room_info(response)

        for event in response.to_device_events:
            if isinstance(event, RoomKeyEvent):
                message = {
                    "sender": event.sender,
                    "sender_key": event.sender_key,
                    "room_id": event.room_id,
                    "session_id": event.session_id,
                    "algorithm": event.algorithm,
                    "server": self.name,
                }
                W.hook_hsignal_send("matrix_room_key_received", message)

                # TODO try to decrypt some cached undecrypted messages with the
                # new key
                # self.decrypt_printed_messages(event)

        if self.client.should_upload_keys:
            self.keys_upload()

        if self.client.should_query_keys and not self.keys_queried:
            self.keys_query()

        for room_buffer in self.room_buffers.values():
            # It's our initial sync, we need to fetch room members, so add
            # the room to the missing members queue.
            # 3 reasons we fetch room members here:
            #   * If the lazy load room users setting is off, otherwise we will
            #       fetch them when we switch to the buffer
            #   * If the room is encrypted, encryption needs the full member
            #       list for it to work.
            #   * If we are the only member, it is unlikely really an empty
            #       room and since we don't want a bunch of "Empty room?"
            #       buffers in our buffer list we fetch members here.
            if not self.next_batch:
                if (not G.CONFIG.network.lazy_load_room_users
                        or room_buffer.room.encrypted
                        or room_buffer.room.member_count <= 1):
                    self.rooms_with_missing_members.append(
                        room_buffer.room.room_id
                    )
            if room_buffer.unhandled_users:
                self._hook_lazy_user_adding()
                break

        self.next_batch = response.next_batch
        self.schedule_sync()
        W.bar_item_update("matrix_typing_notice")

        if self.rooms_with_missing_members:
            self.get_joined_members(self.rooms_with_missing_members.pop())

    def handle_delete_device_auth(self, response):
        device_id = self.device_deletion_queue.pop(response.uuid, None)

        if not device_id:
            return

        for flow in response.flows:
            if "m.login.password" in flow["stages"]:
                session = response.session
                auth = {
                    "type": "m.login.password",
                    "session": session,
                    "user": self.client.user_id,
                    "password": self.config.password
                }
                self.delete_device(device_id, auth)
                return

        self.error("No supported auth method for device deletion found.")

    def handle_error_response(self, response):
        self.error("Error: {}".format(str(response)))

        if isinstance(response, (SyncError, LoginError)):
            self.disconnect()
        elif isinstance(response, JoinedMembersError):
            self.rooms_with_missing_members.append(response.room_id)
            self.get_joined_members(self.rooms_with_missing_members.pop())
        elif isinstance(response, RoomSendError):
            self.handle_own_messages_error(response)
        elif isinstance(response, ShareGroupSessionError):
            self.group_session_shared[response.room_id] = False
            self.share_group_session(
                response.room_id,
                False,
                self.ignore_while_sharing[response.room_id]
            )

        elif isinstance(response, ToDeviceError):
            try:
                self.to_device_sent.remove(response.to_device_message)
            except ValueError:
                pass

    def handle_response(self, response):
        # type: (Response) -> None
        response_lag = response.elapsed

        current_lag = 0

        if self.client:
            current_lag = self.client.lag

        if response_lag >= current_lag:
            self.lag = response_lag * 1000
            self.lag_done = True
            W.bar_item_update("lag")

        if isinstance(response, ErrorResponse):
            self.handle_error_response(response)
            if isinstance(response, RoomMessagesError):
                room_buffer = self.room_buffers[response.room_id]
                room_buffer.backlog_pending = False

        elif isinstance(response, ToDeviceResponse):
            try:
                self.to_device_sent.remove(response.to_device_message)
            except ValueError:
                pass

        elif isinstance(response, LoginResponse):
            self._handle_login(response)

        elif isinstance(response, LoginInfoResponse):
            self._handle_login_info(response)

        elif isinstance(response, SyncResponse):
            self._handle_sync(response)

        elif isinstance(response, RoomSendResponse):
            self.handle_own_messages(response)

        elif isinstance(response, RoomMessagesResponse):
            self.handle_backlog_response(response)

        elif isinstance(response, DevicesResponse):
            self.handle_devices_response(response)

        elif isinstance(response, UpdateDeviceResponse):
            self.info("Device name successfully updated")

        elif isinstance(response, DeleteDevicesAuthResponse):
            self.handle_delete_device_auth(response)

        elif isinstance(response, DeleteDevicesResponse):
            self.info("Device successfully deleted")

        elif isinstance(response, KeysQueryResponse):
            self.keys_queried = False
            W.bar_item_update("buffer_modes")
            W.bar_item_update("matrix_modes")

            for user_id, device_dict in response.changed.items():
                for device in device_dict.values():
                    message = {
                        "user_id": user_id,
                        "device_id": device.id,
                        "ed25519": device.ed25519,
                        "curve25519": device.curve25519,
                        "deleted": str(device.deleted)
                    }
                    W.hook_hsignal_send("matrix_device_changed", message)

        elif isinstance(response, JoinedMembersResponse):
            self.member_request_list.remove(response.room_id)
            room_buffer = self.room_buffers[response.room_id]
            users = [user.user_id for user in response.members]

            # Don't add the users directly use the lazy load hook.
            room_buffer.unhandled_users += users
            self._hook_lazy_user_adding()
            room_buffer.members_fetched = True
            room_buffer.update_buffer_name()

            # Fetch the users for the next room.
            if self.rooms_with_missing_members:
                self.get_joined_members(self.rooms_with_missing_members.pop())
            # We are done adding all the users, do a full key query now since
            # the client knows all the encrypted room members.
            else:
                if self.client.should_query_keys and not self.keys_queried:
                    self.keys_query()

        elif isinstance(response, KeysClaimResponse):
            self.keys_claimed[response.room_id] = False
            try:
                self.share_group_session(
                    response.room_id,
                    True,
                    self.ignore_while_sharing[response.room_id]
                )
            except OlmTrustError as e:
                m = ("Untrusted devices found in room: {}".format(e))
                room_buffer = self.find_room_from_id(response.room_id)
                room_buffer.error(m)

                try:
                    item = self.encryption_queue[response.room_id][0]
                    if item.message_type not in ["m.file", "m.video",
                                                 "m.audio", "m.image"]:
                        room_buffer.last_message = item.message
                except IndexError:
                    pass

                self.encryption_queue[response.room_id].clear()
                return

        elif isinstance(response, ShareGroupSessionResponse):
            room_id = response.room_id
            self.group_session_shared[response.room_id] = False
            ignore_unverified = self.ignore_while_sharing[response.room_id]
            self.ignore_while_sharing[response.room_id] = False

            room_buffer = self.room_buffers[room_id]

            while self.encryption_queue[room_id]:
                item = self.encryption_queue[room_id].popleft()
                try:
                    if item.message_type in [
                        "m.file",
                        "m.video",
                        "m.audio",
                        "m.image"
                    ]:
                        ret = self.room_send_upload(item.message)
                    else:
                        assert isinstance(item.message, Formatted)
                        ret = self.room_send_message(
                            room_buffer,
                            item.message,
                            item.message_type,
                            ignore_unverified_devices=ignore_unverified
                        )

                    if not ret:
                        self.encryption_queue[room_id].pop()
                        self.encryption_queue[room_id].appendleft(item)
                        break

                except OlmTrustError:
                    self.encryption_queue[room_id].clear()

                    # If the item is a normal user message store it in the
                    # buffer to enable the send-anyways functionality.
                    if item.message_type not in ["m.file", "m.video",
                                                 "m.audio", "m.image"]:
                        room_buffer.last_message = item.message

                    break

    def create_room_buffer(self, room_id, prev_batch):
        room = self.client.rooms[room_id]
        buf = RoomBuffer(room, self.name, self.homeserver, prev_batch)

        # We sadly don't get a correct summary on full_state from synapse so we
        # can't trust it that the members are fully synced
        # if room.members_synced:
        #     buf.members_fetched = True

        self.room_buffers[room_id] = buf
        self.buffers[room_id] = buf.weechat_buffer._ptr

    def find_room_from_ptr(self, pointer):
        try:
            room_id = key_from_value(self.buffers, pointer)
            room_buffer = self.room_buffers[room_id]

            return room_buffer
        except (ValueError, KeyError):
            return None

    def find_room_from_id(self, room_id):
        room_buffer = self.room_buffers[room_id]
        return room_buffer

    def garbage_collect_users(self):
        """ Remove inactive users.
        This tries to keep the number of users added to the nicklist less than
            the configuration option matrix.network.max_nicklist_users. It
            removes users that have not been active for a day until there are
            less than max_nicklist_users or no users are left for removal.
            It never removes users that have a bigger power level than the
            default one.
        This function is run every hour by the server timer callback"""

        now = time.time()
        self.user_gc_time = now

        def day_passed(t1, t2):
            return (t2 - t1) > 86400

        for room_buffer in self.room_buffers.values():
            to_remove = max(
                (len(room_buffer.displayed_nicks) -
                    G.CONFIG.network.max_nicklist_users),
                0
            )

            if not to_remove:
                continue

            removed = 0
            removed_user_ids = []

            for user_id, nick in room_buffer.displayed_nicks.items():
                user = room_buffer.weechat_buffer.users[nick]

                if (not user.speaking_time or
                        day_passed(user.speaking_time, now)):
                    room_buffer.weechat_buffer.part(nick, 0, False)
                    removed_user_ids.append(user_id)
                    removed += 1

                if removed >= to_remove:
                    break

            for user_id in removed_user_ids:
                del room_buffer.displayed_nicks[user_id]

    def buffer_merge(self):
        if not self.server_buffer:
            return

        buf = self.server_buffer

        if G.CONFIG.look.server_buffer == ServerBufferType.MERGE_CORE:
            num = W.buffer_get_integer(W.buffer_search_main(), "number")
            W.buffer_unmerge(buf, num + 1)
            W.buffer_merge(buf, W.buffer_search_main())
        elif G.CONFIG.look.server_buffer == ServerBufferType.MERGE:
            if SERVERS:
                first = None
                for server in SERVERS.values():
                    if server.server_buffer:
                        first = server.server_buffer
                        break
                if first:
                    num = W.buffer_get_integer(
                        W.buffer_search_main(), "number"
                    )
                    W.buffer_unmerge(buf, num + 1)
                    if buf is not first:
                        W.buffer_merge(buf, first)
        else:
            num = W.buffer_get_integer(W.buffer_search_main(), "number")
            W.buffer_unmerge(buf, num + 1)


@utf8_decode
def matrix_config_server_read_cb(
    data, config_file, section, option_name, value
):

    return_code = W.WEECHAT_CONFIG_OPTION_SET_ERROR

    if option_name:
        server_name, option = option_name.rsplit(".", 1)
        server = None

        if server_name in SERVERS:
            server = SERVERS[server_name]
        else:
            server = MatrixServer(server_name, config_file)
            SERVERS[server.name] = server

        # Ignore invalid options
        if option in server.config._option_ptrs:
            return_code = W.config_option_set(
                server.config._option_ptrs[option], value, 1
            )

    # TODO print out error message in case of erroneous return_code

    return return_code


@utf8_decode
def matrix_config_server_write_cb(data, config_file, section_name):
    if not W.config_write_line(config_file, section_name, ""):
        return W.WEECHAT_CONFIG_WRITE_ERROR

    for server in SERVERS.values():
        for option in server.config._option_ptrs.values():
            if not W.config_write_option(config_file, option):
                return W.WEECHAT_CONFIG_WRITE_ERROR

    return W.WEECHAT_CONFIG_WRITE_OK


@utf8_decode
def matrix_config_server_change_cb(server_name, option):
    # type: (str, str) -> int
    server = SERVERS[server_name]
    option_name = None

    # The function config_option_get_string() is used to get differing
    # properties from a config option, sadly it's only available in the plugin
    # API of weechat.
    option_name = key_from_value(server.config._option_ptrs, option)
    server.update_option(option, option_name)

    return 1


@utf8_decode
def matrix_load_users_cb(server_name, remaining_calls):
    server = SERVERS[server_name]
    start = time.time()

    rooms = [x for x in server.room_buffers.values() if x.unhandled_users]

    while server.add_unhandled_users(rooms, 100):
        current = time.time()

        if current - start >= 0.1:
            return W.WEECHAT_RC_OK

    # We are done adding users, we can unhook now.
    W.unhook(server.lazy_load_hook)
    server.lazy_load_hook = None

    return W.WEECHAT_RC_OK


@utf8_decode
def matrix_timer_cb(server_name, remaining_calls):
    server = SERVERS[server_name]

    current_time = time.time()

    if (
        (not server.connected)
        and server.reconnect_time
        and current_time >= (server.reconnect_time + server.reconnect_delay)
    ):
        server.reconnect()
        return W.WEECHAT_RC_OK

    if not server.connected or not server.client.logged_in:
        return W.WEECHAT_RC_OK

    # check lag, disconnect if it's too big
    server.lag = server.client.lag * 1000
    server.lag_done = False
    W.bar_item_update("lag")

    if server.lag > G.CONFIG.network.lag_reconnect * 1000:
        server.disconnect()
        return W.WEECHAT_RC_OK

    for i, message in enumerate(server.client.outgoing_to_device_messages):
        if i >= 5:
            break

        if message in server.to_device_sent:
            continue

        server.to_device(message)
        server.to_device_sent.append(message)

    if server.sync_time and current_time > server.sync_time:
        timeout = 0 if server.transport_type == TransportType.HTTP else 30000
        sync_filter = {
            "room": {
                "timeline": {"limit": 500},
                "state": {"lazy_load_members": True}
            }
        }
        server.sync(timeout, sync_filter)

    if current_time > (server.user_gc_time + 3600):
        server.garbage_collect_users()

    return W.WEECHAT_RC_OK


def create_default_server(config_file):
    server = MatrixServer("matrix_org", config_file._ptr)
    SERVERS[server.name] = server

    option = W.config_get(SCRIPT_NAME + ".server." + server.name + ".address")
    W.config_option_set(option, "matrix.org", 1)

    return True


@utf8_decode
def send_cb(server_name, file_descriptor):
    # type: (str, int) -> int

    server = SERVERS[server_name]

    if server.send_fd_hook:
        W.unhook(server.send_fd_hook)
        server.send_fd_hook = None

    if server.send_buffer:
        server.try_send(server.send_buffer)

    return W.WEECHAT_RC_OK
