""" PagerMaid module for different ways to avoid users. """

from pagermaid import log
from pagermaid.enums.command import CommandHandler
from pagermaid.single_utils import sqlite
from pagermaid.utils import lang
from pagermaid.enums import Client, Message
from pagermaid.listener import listener


@listener(
    is_plugin=False,
    outgoing=True,
    command="ghost",
    description=lang("ghost_des"),
    parameters="<true|false|status>",
)
async def ghost(message: Message):
    """Toggles ghosting of a user."""
    if len(message.parameter) != 1:
        await message.edit(f"{lang('error_prefix')}{lang('arg_error')}")
        return
    await message.edit(f"{lang('error_prefix')}{lang('arg_error')}")


ghost: "CommandHandler"


@ghost.sub_command(
    is_plugin=False,
    outgoing=True,
    command="true",
)
async def ghost_true(client: Client, message: Message):
    myself = await client.get_me()
    self_user_id = myself.id
    if message.chat.id == self_user_id:
        return await message.edit(lang("ghost_e_mark"))
    sqlite[f"ghosted.chat_id.{str(message.chat.id)}"] = True
    await message.safe_delete()
    await log(
        f"{lang('ghost_set_f')} ChatID {str(message.chat.id)} {lang('ghost_set_l')}"
    )


@ghost.sub_command(
    is_plugin=False,
    outgoing=True,
    command="false",
)
async def ghost_false(client: Client, message: Message):
    myself = await client.get_me()
    self_user_id = myself.id
    if message.chat.id == self_user_id:
        await message.edit(lang("ghost_e_mark"))
        return
    try:
        del sqlite[f"ghosted.chat_id.{str(message.chat.id)}"]
    except KeyError:
        return await message.edit(lang("ghost_e_noexist"))
    await message.safe_delete()
    await log(
        f"{lang('ghost_set_f')} ChatID {str(message.chat.id)} {lang('ghost_cancel')}"
    )


@ghost.sub_command(
    is_plugin=False,
    outgoing=True,
    command="status",
)
async def ghost_status(message: Message):
    if sqlite.get(f"ghosted.chat_id.{str(message.chat.id)}", None):
        await message.edit(lang("ghost_e_exist"))
    else:
        await message.edit(lang("ghost_e_noexist"))


@listener(
    is_plugin=False,
    outgoing=True,
    command="deny",
    need_admin=True,
    description=lang("deny_des"),
    parameters="<true|false|status>",
)
async def deny(message: Message):
    """Toggles denying of a user."""
    if len(message.parameter) != 1:
        await message.edit(f"{lang('error_prefix')}{lang('arg_error')}")
        return
    await message.edit(f"{lang('error_prefix')}{lang('arg_error')}")


deny: "CommandHandler"


@deny.sub_command(
    is_plugin=False,
    outgoing=True,
    need_admin=True,
    command="true",
)
async def deny_true(client: Client, message: Message):
    myself = await client.get_me()
    self_user_id = myself.id
    if message.chat.id == self_user_id:
        return await message.edit(lang("ghost_e_mark"))
    sqlite[f"denied.chat_id.{str(message.chat.id)}"] = True
    await message.safe_delete()
    await log(f"ChatID {str(message.chat.id)} {lang('deny_set')}")


@deny.sub_command(
    is_plugin=False,
    outgoing=True,
    need_admin=True,
    command="false",
)
async def deny_false(client: Client, message: Message):
    myself = await client.get_me()
    self_user_id = myself.id
    if message.chat.id == self_user_id:
        await message.edit(lang("ghost_e_mark"))
        return
    try:
        del sqlite[f"denied.chat_id.{str(message.chat.id)}"]
    except KeyError:
        return await message.edit(lang("deny_e_noexist"))
    await message.safe_delete()
    await log(f"ChatID {str(message.chat.id)} {lang('deny_cancel')}")


@deny.sub_command(
    is_plugin=False,
    outgoing=True,
    need_admin=True,
    command="status",
)
async def deny_status(message: Message):
    if sqlite.get(f"denied.chat_id.{str(message.chat.id)}", None):
        await message.edit(lang("deny_e_exist"))
    else:
        await message.edit(lang("deny_e_noexist"))


@listener(is_plugin=False, incoming=True, outgoing=False, ignore_edited=True)
async def set_read_acknowledgement(client: Client, message: Message):
    """Event handler to infinitely read ghosted messages."""
    if sqlite.get(f"ghosted.chat_id.{str(message.chat.id)}", None):
        await client.read_chat_history(message.chat.id)


@listener(is_plugin=False, incoming=True, outgoing=False, ignore_edited=True)
async def message_removal(message: Message):
    """Event handler to infinitely delete denied messages."""
    if sqlite.get(f"denied.chat_id.{str(message.chat.id)}", None):
        await message.safe_delete()