""" Respond to commands """

import telethon

import pgbotlib.api
import pgbotlib.dbstuff
import pgbotlib.response


class Commander:
    T_START = frozenset(['start_cmd'])
    T_STOP = frozenset(['stop_cmd'])

    def __init__(self, config: dict,
                 client: telethon.TelegramClient,
                 admins: list,
                 db_conn: pgbotlib.dbstuff.DBConn,
                 responder: pgbotlib.response.Responder) -> None:
        self.config = config
        self.client = client
        self.admins = admins
        self.db_conn = db_conn
        self.responder = responder
        self.available_tokens = [
                str(token) for token, _ in self.responder.tokens]

    def __add_entry(self, caller: int, command: str) -> bool:
        if caller not in self.admins:
            print('fuck off!')
            return None
        input_tokens, phrase = command.strip().split(' ', 1)
        input_tokenset = frozenset(input_tokens.split(','))
        for token in input_tokenset:
            if token not in self.available_tokens:
                return False
        query = 'INSERT INTO responses (tokens, response) values (%s,%s)'
        values = (','.join(sorted(input_tokenset)), phrase.strip())
        return self.db_conn.update(query, values)

    async def action(self,
                     event: telethon.events.common.EventBuilder) -> None:
        command = event.message.text
        sender = await event.get_sender()
        response = None
        match command:
            case command if command.startswith('/add '):
                if self.__add_entry(sender.id, command[5:]):
                    response = 'success'
                else:
                    response = 'failure'
            case '/list':
                response = ', '.join(self.available_tokens)
            case '/start':
                self.responder.enable()
                response = self.responder.get_response(self.T_START)
            case '/stop':
                self.responder.disable()
                response = self.responder.get_response(self.T_STOP)
        if response:
            await self.client.send_message(event.message.peer_id, response)
        return None