import asyncio

from nio import MatrixRoom, Event

from matrix_bot.bot import MatrixBot
from matrix_bot.client import MatrixClient
from matrix_bot.eventparser import MessageEventParser, ignore_when_not_concerned, EventNotConcerned

from config import env_config
from callbacks import properly_fail
from markov import parle


async def non_lus(room_id):
    room = tchap_bot.matrix_client.rooms[room_id]
    if room.unread_notifications:
        response = await tchap_bot.matrix_client.room_messages(room_id=room_id, limit=room.unread_notifications, direction="back", start="")
        for message in response.chunk:
            await repond(room, message, tchap_bot.matrix_client)


# le décorateur @properly_fail va permettre à la commande de laisser un message d'erreur si la commande plante et
# d'envoyer le message que le bot n'est plus en train d'écrire
# la fonction va être appelée dans tous les cas, le décorateur @ignore_when_not_concerned
# permet de laisser event_parser gérer le cas où la commande n'est pas concernée
@properly_fail("Oups, j'ai buggué 😿")
@ignore_when_not_concerned
async def repond(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
    # on initialise un event_parser pour décider à quel message cette commande va répondre
    event_parser = MessageEventParser(room=room, event=message, matrix_client=matrix_client)
    # il ne va pas répondre à ses propres messages
    event_parser.do_not_accept_own_message()


    if not hasattr(message, "body") or not hasattr(message, "formatted_body"):
        # message non textuel
        raise EventNotConcerned

    # ne répond qu'en message direct ou dans un salon s'il est interpellé avec @identifiant.du.bot dans le corps du message
    if len(room.users) > 2 and not (message.formatted_body and matrix_client.user_id in message.formatted_body):
        raise EventNotConcerned

    # il envoie l'information qu'il est en train d'écrire
    await matrix_client.room_typing(room.room_id)
    reponse = parle()
    await asyncio.sleep(len(reponse) / 50)
    # il envoie le message
    await matrix_client.room_typing(room.room_id, typing_state=False)
    await matrix_client.send_html_message(room.room_id, reponse)


@properly_fail("Oups, j'ai buggué 😿")
@ignore_when_not_concerned
async def dune(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
    event_parser = MessageEventParser(room=room, event=message, matrix_client=matrix_client)
    event_parser.do_not_accept_own_message()

    if ("Adrien" in message.body or "adrien" in message.body):
        await matrix_client.room_typing(room.room_id)
        await matrix_client.send_html_message(room.room_id, "<em>Lisan al-Gaib !</em>", "m.notice")


tchap_bot = MatrixBot(
    env_config.matrix_home_server,
    env_config.matrix_bot_username,
    env_config.matrix_bot_password,
    proxy=env_config.https_proxy,
    use_functions=True,
    ssl=True
)

tchap_bot.callbacks.register_on_startup(non_lus)
tchap_bot.callbacks.register_on_message_event(dune)
tchap_bot.callbacks.register_on_message_event(repond)
tchap_bot.run()