import asyncio
import logging

from aiogram import Router, Bot, F
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext
from aiogram.types import Message, CallbackQuery

import config
import database as db
import keyboards as kb
from states import AdminStates

router = Router(name="admin")
# Ushbu router faqat ADMIN_IDS ro'yxatidagi foydalanuvchilar uchun ishlaydi
router.message.filter(F.from_user.id.in_(config.ADMIN_IDS))
router.callback_query.filter(F.from_user.id.in_(config.ADMIN_IDS))


def _stats_text() -> str:
    s = db.stats()
    return (
        "📊 *Statistika*\n\n"
        f"👥 Jami foydalanuvchilar: {s['total_users']}\n"
        f"⭐ Umrbod premium: {s['premium_lifetime']}\n"
        f"⏳ Muddatli premium (faol): {s['premium_active']}\n"
        f"✉️ Jami xabarlar: {s['total_messages']}\n"
        f"📅 Bugungi xabarlar: {s['today_messages']}\n"
        f"💰 Umumiy tushum: {s['revenue_stars']} ⭐"
    )


@router.message(Command("admin"))
async def cmd_admin(message: Message):
    await message.answer(
        "🛠 *Admin panel*",
        reply_markup=kb.admin_menu_kb(db.is_maintenance()),
    )


@router.callback_query(F.data == "adm:menu")
async def cb_menu(callback: CallbackQuery, state: FSMContext):
    await state.clear()
    await callback.message.edit_text(
        "🛠 *Admin panel*", reply_markup=kb.admin_menu_kb(db.is_maintenance())
    )
    await callback.answer()


# ------------------------------------------------------- foydalanuvchiga ---
@router.callback_query(F.data == "adm:dm")
async def cb_dm_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_user_id_for_dm)
    await callback.message.answer("Foydalanuvchi ID sini yuboring:")
    await callback.answer()


@router.message(AdminStates.waiting_user_id_for_dm)
async def dm_get_user_id(message: Message, state: FSMContext):
    if not message.text or not message.text.strip().isdigit():
        await message.answer("Iltimos, faqat raqamlardan iborat ID yuboring.")
        return
    await state.update_data(target_id=int(message.text.strip()))
    await state.set_state(AdminStates.waiting_message_for_dm)
    await message.answer("Endi yuboriladigan xabarni (matn/rasm/video) yuboring:")


@router.message(AdminStates.waiting_message_for_dm)
async def dm_send(message: Message, state: FSMContext):
    data = await state.get_data()
    target_id = data.get("target_id")
    try:
        await message.copy_to(chat_id=target_id)
        await message.answer("✅ Xabar yuborildi.")
    except Exception:
        logging.exception("Admin DM xatosi")
        await message.answer("❌ Xabarni yuborib bo'lmadi (foydalanuvchi botni bloklagan bo'lishi mumkin).")
    await state.clear()


# ------------------------------------------------------------ umumiy xabar -
@router.callback_query(F.data == "adm:broadcast")
async def cb_broadcast_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_broadcast_text)
    await callback.message.answer(
        "Barcha foydalanuvchilarga yuboriladigan xabarni yuboring "
        "(matn/rasm/video bo'lishi mumkin):"
    )
    await callback.answer()


@router.message(AdminStates.waiting_broadcast_text)
async def broadcast_send(message: Message, state: FSMContext, bot: Bot):
    await state.clear()
    user_ids = db.get_all_user_ids()
    status = await message.answer(f"⏳ Yuborilmoqda... (0/{len(user_ids)})")

    success, failed = 0, 0
    for i, uid in enumerate(user_ids, start=1):
        try:
            await message.copy_to(chat_id=uid)
            success += 1
        except Exception:
            failed += 1
        await asyncio.sleep(config.BROADCAST_DELAY)
        if i % 50 == 0:
            try:
                await status.edit_text(f"⏳ Yuborilmoqda... ({i}/{len(user_ids)})")
            except Exception:
                pass

    await status.edit_text(
        f"✅ Yakunlandi.\nYuborildi: {success}\nXato/bloklangan: {failed}"
    )


# ------------------------------------------------------------ kanal --------
@router.callback_query(F.data == "adm:channel")
async def cb_channel_start(callback: CallbackQuery, state: FSMContext):
    if not config.CHANNEL_ID:
        await callback.answer(
            "CHANNEL_ID sozlanmagan. .env faylida CHANNEL_ID ni belgilang.",
            show_alert=True,
        )
        return
    await state.set_state(AdminStates.waiting_channel_text)
    await callback.message.answer(f"Kanalga ({config.CHANNEL_ID}) yuboriladigan xabarni yuboring:")
    await callback.answer()


@router.message(AdminStates.waiting_channel_text)
async def channel_send(message: Message, state: FSMContext):
    await state.clear()
    try:
        await message.copy_to(chat_id=config.CHANNEL_ID)
        await message.answer("✅ Kanalga yuborildi.")
    except Exception:
        logging.exception("Kanalga yuborishda xato")
        await message.answer("❌ Kanalga yuborib bo'lmadi. Bot kanalda admin ekanini tekshiring.")


# -------------------------------------------------------- ta'mirlash rejimi-
@router.callback_query(F.data == "adm:maintenance")
async def cb_toggle_maintenance(callback: CallbackQuery):
    new_state = not db.is_maintenance()
    db.set_maintenance(new_state)
    await callback.message.edit_text(
        "🛠 *Admin panel*", reply_markup=kb.admin_menu_kb(new_state)
    )
    await callback.answer(
        "Ta'mirlash rejimi YOQILDI." if new_state else "Ta'mirlash rejimi O'CHIRILDI."
    )


# --------------------------------------------------------------- statistika-
@router.callback_query(F.data == "adm:stats")
async def cb_stats(callback: CallbackQuery):
    await callback.message.edit_text(_stats_text(), reply_markup=kb.back_to_admin_kb())
    await callback.answer()


# ----------------------------------------------------- premium berish/olish
@router.callback_query(F.data == "adm:grant")
async def cb_grant_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_grant_user_id)
    await callback.message.answer("Premium beriladigan foydalanuvchi ID sini yuboring:")
    await callback.answer()


@router.message(AdminStates.waiting_grant_user_id)
async def grant_get_user_id(message: Message, state: FSMContext):
    if not message.text or not message.text.strip().isdigit():
        await message.answer("Iltimos, faqat raqamlardan iborat ID yuboring.")
        return
    target_id = int(message.text.strip())
    await state.clear()
    await message.answer("Rejani tanlang:", reply_markup=kb.grant_plan_kb(target_id))


@router.callback_query(F.data.startswith("admgrant:"))
async def cb_grant_apply(callback: CallbackQuery, bot: Bot):
    _, plan_key, target_id = callback.data.split(":", 2)
    target_id = int(target_id)
    db.grant_premium(target_id, plan_key)
    plan = config.PREMIUM_PLANS[plan_key]
    await callback.message.edit_text(
        f"✅ {target_id} foydalanuvchisiga *{plan['title']}* Premium berildi."
    )
    try:
        await bot.send_message(
            target_id,
            f"🎉 Sizga admin tomonidan *{plan['title']}* Premium obuna berildi!",
        )
    except Exception:
        pass
    await callback.answer()


@router.callback_query(F.data == "adm:revoke")
async def cb_revoke_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_revoke_user_id)
    await callback.message.answer("Premium olib qo'yiladigan foydalanuvchi ID sini yuboring:")
    await callback.answer()


@router.message(AdminStates.waiting_revoke_user_id)
async def revoke_apply(message: Message, state: FSMContext, bot: Bot):
    if not message.text or not message.text.strip().isdigit():
        await message.answer("Iltimos, faqat raqamlardan iborat ID yuboring.")
        return
    target_id = int(message.text.strip())
    await state.clear()
    db.revoke_premium(target_id)
    await message.answer(f"✅ {target_id} foydalanuvchisining Premium'i bekor qilindi.")
    try:
        await bot.send_message(target_id, "Sizning Premium obunangiz administrator tomonidan bekor qilindi.")
    except Exception:
        pass