"""Основные команды бота."""

from __future__ import annotations

import logging

from aiogram import Router
from aiogram.enums import ChatMemberStatus
from aiogram.filters import Command
from aiogram.types import Message

from bot.services import access, stats, subscriptions
from bot.services import users as users_service
from common.config import get_settings
from common.texts import economy, info, system
from common.texts.render import format_tops, format_user_list, render

logger = logging.getLogger(__name__)
router = Router(name="commands")


@router.message(Command("ник", ignore_case=True))
async def set_nick_handler(message: Message) -> None:
    if not await access.check_user(message):
        return

    parts = (message.text or "").split()
    if len(parts) < 2:
        await message.reply(system.MSG_NICK_ERROR)
        return

    nick = parts[1]
    try:
        await users_service.set_nick(message.from_user.id, nick)
        await message.answer(render(system.MSG_NICK_SET, {"username": message.from_user.username, "nick": nick}))
        await message.delete()
    except Exception:
        logger.exception("Не удалось установить ник")
        await message.reply(system.MSG_NICK_ERROR)


@router.message(Command("список", ignore_case=True))
async def list_nicks_handler(message: Message) -> None:
    if not await access.check_user(message):
        return

    settings = get_settings()
    if message.chat.type == "private":
        allowed = True
    else:
        member = await message.bot.get_chat_member(settings.chat_id, message.from_user.id)
        allowed = member.status in {ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.CREATOR}

    if not allowed:
        await message.answer(system.MSG_LIST_PRIVATE_ONLY)
        return

    await users_service.register_from_message(message)
    nicks = await users_service.list_nicks()
    context = {
        "users_list": format_user_list([{"username": n.username, "nick": n.nick} for n in nicks]),
        "users_list_count": len(nicks),
    }
    await message.answer(render(economy.MSG_NICK_LIST, context))


@router.message(Command("кто", ignore_case=True))
async def get_nick_handler(message: Message) -> None:
    if not await access.check_user(message):
        return
    if message.reply_to_message is None or message.reply_to_message.from_user is None:
        await message.reply(system.MSG_REPLY_REQUIRED)
        return

    user_info = await users_service.get_user_info(message.reply_to_message.from_user.id)
    if user_info is None or not user_info.nick:
        await message.reply(system.MSG_NICK_EMPTY)
        return
    await message.reply(user_info.nick)


@router.message(Command("помощь", ignore_case=True))
async def help_handler(message: Message) -> None:
    if not await access.check_user(message):
        return
    await message.answer(info.MSG_HELP)


@router.message(Command("инфо", ignore_case=True))
async def info_handler(message: Message) -> None:
    if not await access.check_user(message):
        return

    user_info = await users_service.get_user_info(message.from_user.id)
    if user_info is None:
        await message.reply(system.MSG_NICK_ERROR)
        return

    context = {
        "username": user_info.username,
        "nick": user_info.nick_text,
        "title": user_info.title_text,
        "lvl": user_info.lvl,
        "exp": user_info.exp,
        "exp_max": user_info.exp_max,
        "money": user_info.money,
        "dt": user_info.dt,
        "msg_count": user_info.msg_count,
        "eggs": user_info.eggs,
    }
    await message.answer(render(info.MSG_INFO, context))


@router.message(Command("рейтинг", ignore_case=True))
async def top_handler(message: Message) -> None:
    if not await access.check_user(message):
        return
    tops = await stats.top_users()
    context = {"tops": format_tops([{"nick": t.nick, "count": t.count} for t in tops])}
    await message.answer(render(economy.MSG_TOP, context))


@router.message(Command("отписка", ignore_case=True))
async def unsubscribe_handler(message: Message) -> None:
    if not await access.check_user(message):
        return
    await subscriptions.unsubscribe(message.from_user.id)
    await message.reply(system.MSG_UNSUBSCRIBED)


@router.message(Command("подписка", ignore_case=True))
async def subscribe_handler(message: Message) -> None:
    if not await access.check_user(message):
        return
    await subscriptions.subscribe(message.from_user.id)
    await message.reply(system.MSG_SUBSCRIBED)