import json
import asyncio
import aiosqlite
from aiogram import Router, F, Bot
from aiogram.types import CallbackQuery, Message
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from aiogram.utils.keyboard import InlineKeyboardBuilder

from config import ADMIN_IDS, DB_PATH
from keyboards.inline import get_admin_panel_keyboard

router = Router()

class AdminStates(StatesGroup):
    # ساخت و ویرایش دسته‌بندی
    waiting_for_cat_name = State()
    waiting_for_cat_pos = State()
    waiting_for_cat_style = State()
    waiting_for_edit_cat_name = State()

    # ساخت و ویرایش محصول عادی
    waiting_for_prod_cat = State()
    waiting_for_prod_name = State()
    waiting_for_prod_desc = State()
    waiting_for_prod_price = State()
    waiting_for_prod_media = State()
    waiting_for_prod_type = State()
    waiting_for_prod_data = State()
    waiting_for_edit_prod_name = State()

    # ساخت و مدیریت موجودی محصول وی‌پی‌ان (VPN)
    waiting_for_vpn_prod_cat = State()
    waiting_for_vpn_prod_name = State()
    waiting_for_vpn_prod_desc = State()
    waiting_for_vpn_prod_price = State()
    waiting_for_vpn_prod_media = State()
    waiting_for_vpn_links_input = State()

    # مدیریت ادمین‌ها و گروه رسیدها
    waiting_for_add_admin_user = State()
    waiting_for_receipt_group_id = State()

    # کدهای تخفیف
    waiting_for_discount_code = State()
    waiting_for_discount_type = State()
    waiting_for_discount_value = State()
    waiting_for_discount_scope = State()
    waiting_for_discount_target = State()

    # ارسال همگانی
    waiting_for_broadcast_msg = State()

    # تنظیمات و کانال‌ها
    waiting_for_ref_percent = State()
    waiting_for_ton_wallet = State()
    waiting_for_trx_wallet = State()
    waiting_for_log_channel = State()
    waiting_for_log_footer = State()
    waiting_for_sponsor_ch_id = State()
    waiting_for_sponsor_title = State()
    waiting_for_sponsor_link = State()

    # ویرایش دکمه‌های اصلی
    waiting_for_button_text = State()

    # شارژ و کارت
    waiting_for_manual_charge_user = State()
    waiting_for_manual_charge_amount = State()
    waiting_for_ticket_reply = State()
    waiting_for_card_num = State()
    waiting_for_card_owner = State()
    waiting_for_approve_amount = State()

    # مدیریت سفارشات
    waiting_for_order_status_text = State()
    waiting_for_order_complete_content = State()

async def is_admin(user_id: int) -> bool:
    if user_id in ADMIN_IDS:
        return True
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id FROM admins WHERE user_id = ?", (user_id,)) as cursor:
            row = await cursor.fetchone()
            return row is not None

def get_cancel_btn():
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ لغو و بازگشت", callback_data="admin_panel", style="danger")
    return builder.as_markup()

# ==================== ۱. پنل ادمین ====================
@router.callback_query(F.data == "admin_panel")
async def admin_panel(callback: CallbackQuery, state: FSMContext):
    if not await is_admin(callback.from_user.id):
        return
    await state.clear()
    await callback.message.edit_text("🛠️ **پنل مدیریت فروشگاه**", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

# ==================== ۲. مدیریت ادمین‌های ربات ====================
@router.callback_query(F.data == "admin_manage_admins")
async def manage_admins_menu(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id, username FROM admins") as cursor:
            db_admins = await cursor.fetchall()

    builder = InlineKeyboardBuilder()
    builder.button(text="➕ افزودن ادمین جدید", callback_data="add_new_admin_user", style="success")

    text = "👮‍♂️ **مدیریت ادمین‌های ربات**\n\n📌 **ادمین‌های اصلی (تعریف‌شده در کانفیگ):**\n"
    for a_id in ADMIN_IDS:
        text += f"▫️ `{a_id}`\n"

    text += "\n📌 **ادمین‌های دیتابیس (افزوده شده از پنل):**\n"
    if db_admins:
        for a_id, a_name in db_admins:
            text += f"▫️ @{a_name or 'بدون یوزرنیم'} (`{a_id}`)\n"
            builder.button(text=f"🗑️ حذف ادمین: {a_name or a_id}", callback_data=f"del_admin_{a_id}")
    else:
        text += "▫️ هنوز ادمین جدیدی اضافه نشده است.\n"

    builder.button(text="🔙 بازگشت به پنل مدیریت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text(text, reply_markup=builder.as_markup(), parse_mode="Markdown")

@router.callback_query(F.data == "add_new_admin_user")
async def add_admin_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_add_admin_user)
    await callback.message.edit_text("👤 لطفاً **آیدی عددی** یا **یوزرنیم** کاربر جدیدی که می‌خواهید ادمین شود را وارد کنید (مثال: `12345678` یا `@username`):", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_add_admin_user)
async def add_admin_save(message: Message, state: FSMContext):
    input_val = message.text.strip().replace("@", "")

    async with aiosqlite.connect(DB_PATH) as db:
        if input_val.isdigit():
            target_id = int(input_val)
            async with db.execute("SELECT username FROM users WHERE user_id = ?", (target_id,)) as cursor:
                row = await cursor.fetchone()
                target_username = row[0] if row else ""
        else:
            async with db.execute("SELECT user_id, username FROM users WHERE LOWER(username) = LOWER(?)", (input_val,)) as cursor:
                row = await cursor.fetchone()
                if row:
                    target_id, target_username = row[0], row[1]
                else:
                    target_id, target_username = None, None

        if not target_id:
            await message.answer("❌ کاربر در دیتابیس یافت نشد! کاربر مورد نظر باید حداقل یک‌بار ربات را /start کرده باشد.", reply_markup=get_cancel_btn())
            return

        await db.execute("INSERT OR IGNORE INTO admins (user_id, username) VALUES (?, ?)", (target_id, target_username))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ کاربر `{target_id}` با موفقیت به عنوان **ادمین جدید** ربات اضافه گردید.", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

@router.callback_query(F.data.startswith("del_admin_"))
async def delete_admin_handler(callback: CallbackQuery):
    del_id = int(callback.data.split("_")[2])
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM admins WHERE user_id = ?", (del_id,))
        await db.commit()

    await callback.answer("✅ دسترسی ادمین کاربر لغو شد.", show_alert=True)
    await manage_admins_menu(callback)

# ==================== ۳. تنظیم گروه اختصاصی بررسی رسیدها ====================
@router.callback_query(F.data == "admin_set_receipt_group")
async def receipt_group_menu(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT value FROM settings WHERE key='receipt_group'") as cursor:
            row = await cursor.fetchone()
            current_group = row[0] if row else "تنظیم نشده"

    builder = InlineKeyboardBuilder()
    builder.button(text="👥 تنظیم / تغییر آیدی گروه رسیدها", callback_data="set_receipt_grp_start")
    if current_group:
        builder.button(text="🗑️ حذف گروه رسیدها", callback_data="clear_receipt_grp")
    builder.button(text="🔙 بازگشت به پنل مدیریت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    text = (
        f"👥 **تنظیم گروه اختصاصی بررسی رسیدها**\n\n"
        f"▫️ آیدی عددی گروه فعلی: `{current_group or 'تنظیم نشده'}`\n\n"
        f"💡 *در صورت تنظیم آیدی گروه، رسیدهای کارت‌به‌کارت واریزی کاربران مستقیماً به داخل این گروه ارسال می‌شود تا ادمین‌ها بتوانند همانجا آنها را تایید یا رد کنند.*"
    )
    await callback.message.edit_text(text, reply_markup=builder.as_markup(), parse_mode="Markdown")

@router.callback_query(F.data == "set_receipt_grp_start")
async def set_receipt_grp_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_receipt_group_id)
    text = (
        f"👥 **راهنمای ثبت آیدی عددی گروه رسیدها:**\n\n"
        f"۱. ربات را وارد گروه ادمین‌های خود کنید و آن را ادمین بفرمایید.\n"
        f"۲. آیدی عددی گروه را که معمولاً با `-100` شروع می‌شود وارد کنید (مثال: `-100123456789`):\n\n"
        f"📌 *نکته: می‌توانید با فوروارد پیام از گروه به ربات‌های نمایش آیدی، آیدی عددی دقیق گروه خود را پیدا کنید.*"
    )
    await callback.message.edit_text(text, reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_receipt_group_id)
async def set_receipt_grp_save(message: Message, state: FSMContext):
    grp_id = message.text.strip()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('receipt_group', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (grp_id,))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ آیدی گروه بررسی رسیدها با موفقیت به `{grp_id}` تغییر یافت.", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

@router.callback_query(F.data == "clear_receipt_grp")
async def clear_receipt_grp_handler(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('receipt_group', '') ON CONFLICT(key) DO UPDATE SET value = excluded.value")
        await db.commit()

    await callback.answer("✅ گروه رسیدها حذف شد.", show_alert=True)
    await receipt_group_menu(callback)

# ==================== ۴. مدیریت روش‌های پرداخت ====================
@router.callback_query(F.data == "admin_payment_settings")
async def admin_payment_settings(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT key, value FROM settings") as cursor:
            rows = await cursor.fetchall()
            settings = {row[0]: row[1] for row in rows}

    card_status = "🟢 فعال" if settings.get("enable_card") == "1" else "🔴 غیرفعال"
    stars_status = "🟢 فعال" if settings.get("enable_stars") == "1" else "🔴 غیرفعال"
    ton_status = "🟢 فعال" if settings.get("enable_ton") == "1" else "🔴 غیرفعال"
    trx_status = "🟢 فعال" if settings.get("enable_trx") == "1" else "🔴 غیرفعال"

    card_num = settings.get("bank_card", "ثبت نشده")
    card_owner = settings.get("card_owner", "ثبت نشده")
    ton_wallet = settings.get("ton_wallet") or "ثبت نشده"
    trx_wallet = settings.get("trx_wallet") or "ثبت نشده"

    text = (
        f"⚙️ **مدیریت درگاه‌ها و روش‌های پرداخت**\n\n"
        f"💳 **۱. کارت به کارت:** {card_status}\n"
        f"▫️ شماره کارت: `{card_num}` | صاحب حساب: {card_owner}\n\n"
        f"🌟 **۲. استارز تلگرام:** {stars_status}\n"
        f"▫️ محاسبه اتوماتیک قیمت روز استارز به تومان\n\n"
        f"💎 **۳. کریپتو - شبکه TON:** {ton_status}\n"
        f"▫️ ولت TON: `{ton_wallet}`\n\n"
        f"🔴 **۴. کریپتو - شبکه TRON (ترون):** {trx_status}\n"
        f"▫️ ولت TRON: `{trx_wallet}`\n\n"
        f"جهت فعال/غیرفعال‌سازی یا ویرایش اطلاعات روی دکمه‌های زیر کلیک کنید:"
    )

    builder = InlineKeyboardBuilder()
    builder.button(text=f"💳 کارت به کارت ({card_status})", callback_data="toggle_pay_card")
    builder.button(text=f"🌟 استارز تلگرام ({stars_status})", callback_data="toggle_pay_stars")
    builder.button(text=f"💎 رمزارز TON ({ton_status})", callback_data="toggle_pay_ton")
    builder.button(text=f"🔴 رمزارز TRON ({trx_status})", callback_data="toggle_pay_trx")
    
    builder.button(text="💳 تنظیم شماره کارت و صاحب حساب", callback_data="admin_set_card")
    builder.button(text="💎 تنظیم آدرس ولت TON (Tonkeeper)", callback_data="admin_set_ton_wallet")
    builder.button(text="🔴 تنظیم آدرس ولت TRON (TRX)", callback_data="admin_set_trx_wallet")
    
    builder.button(text="🔙 بازگشت به پنل مدیریت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text(text, reply_markup=builder.as_markup(), parse_mode="Markdown")

@router.callback_query(F.data.startswith("toggle_pay_"))
async def toggle_payment_method(callback: CallbackQuery):
    method = callback.data.replace("toggle_pay_", "")
    key_name = f"enable_{method}"

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT value FROM settings WHERE key = ?", (key_name,)) as cursor:
            row = await cursor.fetchone()
            current_val = row[0] if row else "1"

        new_val = "0" if current_val == "1" else "1"
        await db.execute("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (key_name, new_val))
        await db.commit()

    await callback.answer("✅ وضعیت روش پرداخت تغییر یافت.", show_alert=False)
    await admin_payment_settings(callback)

@router.callback_query(F.data == "admin_set_ton_wallet")
async def set_ton_wallet_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_ton_wallet)
    text = (
        f"💎 **راهنمای فعال‌سازی پرداخت خودکار با ولت TON (Tonkeeper / Telegram Wallet)**\n\n"
        f"آدرس ولت شبکه TON خود را وارد کنید (آدرسی که با EQ یا UQ شروع می‌شود):"
    )
    await callback.message.edit_text(text, reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_ton_wallet)
async def set_ton_wallet_save(message: Message, state: FSMContext):
    wallet_addr = message.text.strip()
    if len(wallet_addr) < 20:
        await message.answer("❌ آدرس ولت وارد شده معتبر نیست. لطفاً آدرس صحیح TON را وارد کنید:", reply_markup=get_cancel_btn())
        return

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('ton_wallet', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (wallet_addr,))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ **آدرس ولت TON با موفقیت ذخیره شد:**\n\n`{wallet_addr}`", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

@router.callback_query(F.data == "admin_set_trx_wallet")
async def set_trx_wallet_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_trx_wallet)
    text = (
        f"🔴 **راهنمای فعال‌سازی پرداخت خودکار با شبکه ترون (TRX)**\n\n"
        f"آدرس ولت شبکه TRON خود را وارد کنید (آدرسی که با حرف T شروع می‌شود):"
    )
    await callback.message.edit_text(text, reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_trx_wallet)
async def set_trx_wallet_save(message: Message, state: FSMContext):
    wallet_addr = message.text.strip()
    if not wallet_addr.startswith("T") or len(wallet_addr) < 25:
        await message.answer("❌ آدرس ولت ترون معتبر نیست! (باید با حرف T شروع شود):", reply_markup=get_cancel_btn())
        return

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('trx_wallet', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (wallet_addr,))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ **آدرس ولت ترون با موفقیت ذخیره شد:**\n\n`{wallet_addr}`", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

# ==================== ۵. تنظیم درصد پورسانت زیرمجموعه‌گیری ====================
@router.callback_query(F.data == "admin_set_ref_percent")
async def set_ref_percent_start(callback: CallbackQuery, state: FSMContext):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT value FROM settings WHERE key='referral_percent'") as cursor:
            row = await cursor.fetchone()
            current_percent = row[0] if row else "30"

    await state.set_state(AdminStates.waiting_for_ref_percent)
    await callback.message.edit_text(
        f"🎯 **تنظیم درصد پورسانت زیرمجموعه‌گیری**\n\n"
        f"درصد فعلی: **{current_percent}%**\n\n"
        f"لطفاً عدد درصد جدید (مثلاً 10 یا 20 یا 30) را به صورت عدد انگلیسی وارد کنید:",
        reply_markup=get_cancel_btn(),
        parse_mode="Markdown"
    )

@router.message(AdminStates.waiting_for_ref_percent)
async def save_ref_percent(message: Message, state: FSMContext):
    if not message.text.isdigit():
        await message.answer("لطفاً فقط یک عدد معتبر وارد کنید (مثلاً 20):", reply_markup=get_cancel_btn())
        return

    percent = int(message.text)
    if percent < 0 or percent > 100:
        await message.answer("درصد باید بین 0 تا 100 باشد:", reply_markup=get_cancel_btn())
        return

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "INSERT INTO settings (key, value) VALUES ('referral_percent', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
            (str(percent),)
        )
        await db.commit()

    await state.clear()
    await message.answer(f"✅ درصد پورسانت زیرمجموعه‌گیری با موفقیت به **{percent}%** تغییر یافت.", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

# ==================== ۶. مدیریت دکمه‌های اصلی ====================
@router.callback_query(F.data == "admin_edit_buttons")
async def edit_buttons_start(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    builder = InlineKeyboardBuilder()
    builder.button(text="💳 دکمه شارژ حساب", callback_data="manage_btn_btn_charge")
    builder.button(text="📦 دکمه سفارشات من", callback_data="manage_btn_btn_orders")
    builder.button(text="🌐 دکمه وی‌پی‌ان‌های من", callback_data="manage_btn_btn_vpns")
    builder.button(text="💰 دکمه کسب درآمد", callback_data="manage_btn_btn_referral")
    builder.button(text="🎫 دکمه پشتیبانی", callback_data="manage_btn_btn_support")
    builder.button(text="👤 دکمه حساب کاربری", callback_data="manage_btn_btn_profile")
    builder.button(text="⚙️ دکمه پنل ادمین", callback_data="manage_btn_btn_admin")
    builder.button(text="❌ لغو و بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("🎨 **ویرایش دکمه‌های اصلی ربات**\nدکمه مورد نظر را جهت تغییر متن یا رنگ انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("manage_btn_"))
async def manage_btn_options(callback: CallbackQuery, state: FSMContext):
    btn_key = callback.data.replace("manage_btn_", "")
    await state.update_data(selected_btn_key=btn_key)

    builder = InlineKeyboardBuilder()
    builder.button(text="✏️ تغییر متن و ایموجی", callback_data=f"ch_btn_txt_{btn_key}")
    builder.button(text="🎨 تغییر رنگ / استایل", callback_data=f"ch_btn_style_{btn_key}")
    builder.button(text="🔙 بازگشت", callback_data="admin_edit_buttons", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("گزینه مورد نظر را برای ویرایش دکمه انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("ch_btn_txt_"))
async def edit_btn_text_start(callback: CallbackQuery, state: FSMContext):
    btn_key = callback.data.replace("ch_btn_txt_", "")
    await state.update_data(selected_btn_key=btn_key)
    await state.set_state(AdminStates.waiting_for_button_text)
    await callback.message.edit_text("✏️ متن جدید دکمه را بفرستید (می‌توانید از ایموجی‌های دلخواه استفاده کنید):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_button_text)
async def save_btn_text(message: Message, state: FSMContext):
    data = await state.get_data()
    btn_key = data.get("selected_btn_key")
    new_text = message.text

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "INSERT INTO bot_buttons (key, text) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET text = excluded.text",
            (btn_key, new_text)
        )
        await db.commit()

    await state.clear()
    await message.answer("✅ متن دکمه بروزرسانی شد.", reply_markup=get_admin_panel_keyboard())

@router.callback_query(F.data.startswith("ch_btn_style_"))
async def edit_btn_style_select(callback: CallbackQuery, state: FSMContext):
    btn_key = callback.data.replace("ch_btn_style_", "")
    await state.update_data(selected_btn_key=btn_key)

    builder = InlineKeyboardBuilder()
    builder.button(text="🟢 سبز (success)", callback_data="set_btn_style_success")
    builder.button(text="🔴 قرمز (danger)", callback_data="set_btn_style_danger")
    builder.button(text="🔵 آبی (primary)", callback_data="set_btn_style_primary")
    builder.button(text="⚪ معمولی (بدون استایل)", callback_data="set_btn_style_none")
    builder.button(text="❌ لغو", callback_data="admin_edit_buttons", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("رنگ/استایل جدید دکمه را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("set_btn_style_"))
async def save_btn_style(callback: CallbackQuery, state: FSMContext):
    style_code = callback.data.replace("set_btn_style_", "")
    saved_style = style_code if style_code in ["success", "danger", "primary"] else None
    
    data = await state.get_data()
    btn_key = data.get("selected_btn_key")

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "INSERT INTO bot_buttons (key, text, style) VALUES (?, 'دکمه', ?) ON CONFLICT(key) DO UPDATE SET style = excluded.style",
            (btn_key, saved_style)
        )
        await db.commit()

    await state.clear()
    await callback.message.edit_text("✅ استایل دکمه با موفقیت بروزرسانی شد.", reply_markup=get_admin_panel_keyboard())

# ==================== ۷. مدیریت دسته‌بندی‌ها ====================
@router.callback_query(F.data == "admin_manage_cats")
async def manage_cats(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, name, position FROM categories ORDER BY position ASC") as cursor:
            cats = await cursor.fetchall()

    builder = InlineKeyboardBuilder()
    for c_id, c_name, c_pos in cats:
        builder.button(text=f"{c_name} (ترتیب: {c_pos})", callback_data=f"edit_cat_{c_id}")
    builder.button(text="➕ ساخت دسته‌بندی جدید", callback_data="add_new_cat", style="success")
    builder.button(text="❌ بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("📂 **مدیریت دسته‌بندی‌ها**\nجهت ویرایش روی دسته‌بندی کلیک کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("edit_cat_"))
async def edit_cat_menu(callback: CallbackQuery):
    c_id = int(callback.data.split("_")[2])
    builder = InlineKeyboardBuilder()
    builder.button(text="✏️ تغییر نام", callback_data=f"ch_cat_name_{c_id}")
    builder.button(text="🎨 تغییر رنگ / استایل", callback_data=f"ch_cat_style_{c_id}")
    builder.button(text="🗑️ حذف دسته‌بندی", callback_data=f"del_cat_{c_id}", style="danger")
    builder.button(text="🔙 بازگشت", callback_data="admin_manage_cats")
    builder.adjust(1)
    await callback.message.edit_text("انتخاب کنید چه تغییری اعمال شود:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("ch_cat_style_"))
async def ch_cat_style_start(callback: CallbackQuery, state: FSMContext):
    c_id = int(callback.data.split("_")[3])
    await state.update_data(target_cat_id=c_id)

    builder = InlineKeyboardBuilder()
    builder.button(text="🟢 سبز (success)", callback_data="setcatstyle_success")
    builder.button(text="🔴 قرمز (danger)", callback_data="setcatstyle_danger")
    builder.button(text="🔵 آبی (primary)", callback_data="setcatstyle_primary")
    builder.button(text="⚪ معمولی (بدون استایل)", callback_data="setcatstyle_none")
    builder.button(text="❌ لغو", callback_data="admin_manage_cats", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("استایل/رنگ جدید دسته‌بندی را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("setcatstyle_"))
async def save_cat_style(callback: CallbackQuery, state: FSMContext):
    style_code = callback.data.split("_")[1]
    saved_style = style_code if style_code in ["success", "danger", "primary"] else None
    
    data = await state.get_data()
    c_id = data.get("target_cat_id")

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("UPDATE categories SET style = ? WHERE id = ?", (saved_style, c_id))
        await db.commit()

    await state.clear()
    await callback.message.edit_text("✅ استایل دسته‌بندی بروزرسانی شد.", reply_markup=get_admin_panel_keyboard())

@router.callback_query(F.data.startswith("del_cat_"))
async def delete_cat(callback: CallbackQuery):
    c_id = int(callback.data.split("_")[2])
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM categories WHERE id = ?", (c_id,))
        await db.execute("DELETE FROM products WHERE category_id = ?", (c_id,))
        await db.commit()
    await callback.answer("✅ دسته‌بندی حذف شد.", show_alert=True)
    await manage_cats(callback)

@router.callback_query(F.data.startswith("ch_cat_name_"))
async def ch_cat_name_start(callback: CallbackQuery, state: FSMContext):
    c_id = int(callback.data.split("_")[3])
    await state.update_data(target_cat_id=c_id)
    await state.set_state(AdminStates.waiting_for_edit_cat_name)
    await callback.message.edit_text("نام جدید دسته‌بندی را وارد کنید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_edit_cat_name)
async def ch_cat_name_save(message: Message, state: FSMContext):
    data = await state.get_data()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("UPDATE categories SET name = ? WHERE id = ?", (message.text, data["target_cat_id"]))
        await db.commit()
    await state.clear()
    await message.answer("✅ نام دسته‌بندی ویرایش شد.", reply_markup=get_admin_panel_keyboard())

@router.callback_query(F.data == "add_new_cat")
async def add_cat_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_cat_name)
    await callback.message.edit_text("نام دسته‌بندی جدید را وارد کنید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_cat_name)
async def add_cat_name(message: Message, state: FSMContext):
    await state.update_data(cat_name=message.text)
    await state.set_state(AdminStates.waiting_for_cat_pos)
    await message.answer("موقعیت نمایش را وارد کنید (عدد 1 یا 2...):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_cat_pos)
async def add_cat_pos(message: Message, state: FSMContext):
    pos = int(message.text) if message.text.isdigit() else 0
    await state.update_data(cat_pos=pos)

    builder = InlineKeyboardBuilder()
    builder.button(text="🟢 سبز (success)", callback_data="style_success")
    builder.button(text="🔴 قرمز (danger)", callback_data="style_danger")
    builder.button(text="🔵 آبی (primary)", callback_data="style_primary")
    builder.button(text="⚪ معمولی (بدون استایل)", callback_data="style_none")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await state.set_state(AdminStates.waiting_for_cat_style)
    await message.answer("استایل دکمه را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_cat_style, F.data.startswith("style_"))
async def add_cat_style(callback: CallbackQuery, state: FSMContext):
    style_code = callback.data.split("_")[1]
    saved_style = style_code if style_code in ["success", "danger", "primary"] else None
    
    data = await state.get_data()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO categories (name, position, style) VALUES (?, ?, ?)", (data["cat_name"], data["cat_pos"], saved_style))
        await db.commit()
    await state.clear()
    await callback.message.edit_text("✅ دسته‌بندی جدید ذخیره شد.", reply_markup=get_admin_panel_keyboard())

# ==================== ۸. مدیریت و ویرایش محصولات ====================
@router.callback_query(F.data == "admin_manage_prods")
async def manage_prods_menu(callback: CallbackQuery):
    builder = InlineKeyboardBuilder()
    builder.button(text="➕ افزودن محصول عادی", callback_data="admin_add_prod", style="success")
    builder.button(text="🌐 افزودن محصول وی‌پی‌ان (VPN)", callback_data="admin_add_vpn_prod", style="success")
    builder.button(text="🔑 مدیریت موجودی و لینک‌های VPN", callback_data="admin_manage_vpn_stock", style="primary")
    builder.button(text="✏️ ویرایش/حذف محصولات موجود", callback_data="admin_list_cats_for_prod_edit")
    builder.button(text="❌ بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)
    await callback.message.edit_text("📦 **مدیریت محصولات فروشگاه**", reply_markup=builder.as_markup())

@router.callback_query(F.data == "admin_list_cats_for_prod_edit")
async def list_cats_for_prod_edit(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, name FROM categories ORDER BY position ASC") as cursor:
            cats = await cursor.fetchall()

    if not cats:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت", callback_data="admin_manage_prods", style="danger")
        await callback.message.edit_text("⚠️ هیچ دسته‌بندی یافت نشد.", reply_markup=builder.as_markup())
        return

    builder = InlineKeyboardBuilder()
    for c_id, c_name in cats:
        builder.button(text=f"📂 {c_name}", callback_data=f"sel_cat_edit_p_{c_id}")

    builder.button(text="🔙 بازگشت", callback_data="admin_manage_prods", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("📂 لطفاً دسته‌بندی مورد نظر برای ویرایش محصولاتش را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("sel_cat_edit_p_"))
async def list_prods_of_cat_for_edit(callback: CallbackQuery):
    c_id = int(callback.data.split("_")[4])

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, name, price, delivery_type FROM products WHERE category_id = ?", (c_id,)) as cursor:
            prods = await cursor.fetchall()

    builder = InlineKeyboardBuilder()
    if not prods:
        builder.button(text="🔙 بازگشت به دسته‌بندی‌ها", callback_data="admin_list_cats_for_prod_edit", style="danger")
        await callback.message.edit_text("⚠️ هیچ محصولی در این دسته‌بندی وجود ندارد.", reply_markup=builder.as_markup())
        return

    for p_id, p_name, p_price, p_type in prods:
        tag = "🌐 VPN" if p_type == "vpn" else "📦 عادی"
        builder.button(text=f"[{tag}] {p_name} | {p_price:,} تومان", callback_data=f"edit_p_{p_id}")

    builder.button(text="🔙 بازگشت به دسته‌بندی‌ها", callback_data="admin_list_cats_for_prod_edit", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("محصول مورد نظر برای ویرایش را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("edit_p_"))
async def edit_prod_options(callback: CallbackQuery):
    p_id = int(callback.data.split("_")[2])
    builder = InlineKeyboardBuilder()
    builder.button(text="✏️ تغییر نام", callback_data=f"ch_p_name_{p_id}")
    builder.button(text="🗑️ حذف محصول", callback_data=f"del_p_{p_id}", style="danger")
    builder.button(text="🔙 بازگشت به دسته‌بندی‌ها", callback_data="admin_list_cats_for_prod_edit")
    builder.adjust(1)
    await callback.message.edit_text("انتخاب کنید چه تغییری در محصول اعمال شود:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("del_p_"))
async def delete_product(callback: CallbackQuery):
    p_id = int(callback.data.split("_")[2])
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM products WHERE id = ?", (p_id,))
        await db.execute("DELETE FROM vpn_stock WHERE product_id = ?", (p_id,))
        await db.commit()
    await callback.answer("✅ محصول حذف شد.", show_alert=True)
    await list_cats_for_prod_edit(callback)

@router.callback_query(F.data.startswith("ch_p_name_"))
async def ch_p_name_start(callback: CallbackQuery, state: FSMContext):
    p_id = int(callback.data.split("_")[3])
    await state.update_data(target_prod_id=p_id)
    await state.set_state(AdminStates.waiting_for_edit_prod_name)
    await callback.message.edit_text("نام جدید محصول را وارد کنید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_edit_prod_name)
async def ch_p_name_save(message: Message, state: FSMContext):
    data = await state.get_data()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("UPDATE products SET name = ? WHERE id = ?", (message.text, data["target_prod_id"]))
        await db.commit()
    await state.clear()
    await message.answer("✅ نام محصول ویرایش شد.", reply_markup=get_admin_panel_keyboard())

# --- افزودن محصول عادی ---
@router.callback_query(F.data == "admin_add_prod")
async def add_prod_start(callback: CallbackQuery, state: FSMContext):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, name FROM categories") as cursor:
            cats = await cursor.fetchall()

    if not cats:
        await callback.answer("❌ ابتدا دسته‌بندی بسازید.", show_alert=True)
        return

    builder = InlineKeyboardBuilder()
    for c_id, c_name in cats:
        builder.button(text=c_name, callback_data=f"sel_cat_{c_id}")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await state.set_state(AdminStates.waiting_for_prod_cat)
    await callback.message.edit_text("دسته‌بندی محصول عادی را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_prod_cat, F.data.startswith("sel_cat_"))
async def add_prod_cat_selected(callback: CallbackQuery, state: FSMContext):
    c_id = int(callback.data.split("_")[2])
    await state.update_data(prod_cat_id=c_id)
    await state.set_state(AdminStates.waiting_for_prod_name)
    await callback.message.edit_text("نام محصول را وارد کنید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_prod_name)
async def add_prod_name(message: Message, state: FSMContext):
    await state.update_data(prod_name=message.text)
    await state.set_state(AdminStates.waiting_for_prod_desc)
    await message.answer("📝 **توضیحات محصول** را وارد کنید (جهت نمایش به مشتری قبل از خرید):", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_prod_desc)
async def add_prod_desc(message: Message, state: FSMContext):
    await state.update_data(prod_desc=message.text)
    await state.set_state(AdminStates.waiting_for_prod_price)
    await message.answer("💰 **قیمت محصول** را به تومان (فقط عدد) وارد کنید:", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_prod_price)
async def add_prod_price(message: Message, state: FSMContext):
    if not message.text.isdigit():
        await message.answer("لطفاً قیمت را فقط به صورت عدد وارد کنید:", reply_markup=get_cancel_btn())
        return
    await state.update_data(prod_price=int(message.text))
    await state.set_state(AdminStates.waiting_for_prod_media)

    builder = InlineKeyboardBuilder()
    builder.button(text="⏭️ رد کردن (بدون رسانه)", callback_data="skip_prod_media")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await message.answer(
        "🖼️ **تصویر / ویدیو / گیف محصول (اختیاری)**\n\n"
        "می‌توانید یک تصویر، ویدیو یا گیف برای این محصول ارسال کنید.\n"
        "اگر محصول رسانه ندارد، روی دکمه **⏭️ رد کردن (بدون رسانه)** بزنید.",
        reply_markup=builder.as_markup(),
        parse_mode="Markdown"
    )

@router.callback_query(AdminStates.waiting_for_prod_media, F.data == "skip_prod_media")
async def skip_prod_media_handler(callback: CallbackQuery, state: FSMContext):
    await state.update_data(prod_media_type=None, prod_media_file_id=None)
    await ask_prod_delivery_type(callback.message, state)

@router.message(AdminStates.waiting_for_prod_media)
async def save_prod_media_handler(message: Message, state: FSMContext):
    if message.photo:
        m_type = "photo"
        m_id = message.photo[-1].file_id
    elif message.video:
        m_type = "video"
        m_id = message.video.file_id
    elif message.animation:
        m_type = "animation"
        m_id = message.animation.file_id
    else:
        await message.answer("لطفاً یک تصویر، ویدیو یا گیف ارسال کنید یا روی دکمه '⏭️ رد کردن' بزنید:")
        return

    await state.update_data(prod_media_type=m_type, prod_media_file_id=m_id)
    await ask_prod_delivery_type(message, state)

async def ask_prod_delivery_type(target: Message, state: FSMContext):
    builder = InlineKeyboardBuilder()
    builder.button(text="⚡ تحویل خودکار (اکانت/کد/فایل آماده)", callback_data="type_auto", style="success")
    builder.button(text="🛠️ تحویل دستی (نیازمند آماده‌سازی ادمین)", callback_data="type_manual", style="primary")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await state.set_state(AdminStates.waiting_for_prod_type)
    await target.answer("نوع تحویل محصول را تعیین کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_prod_type, F.data.startswith("type_"))
async def add_prod_type_selected(callback: CallbackQuery, state: FSMContext):
    del_type = callback.data.split("_")[1]
    await state.update_data(prod_type=del_type)

    if del_type == "auto":
        await state.update_data(prod_content_list=[])
        await state.set_state(AdminStates.waiting_for_prod_data)

        builder = InlineKeyboardBuilder()
        builder.button(text="✅ ثبت نهایی محتوای محصول", callback_data="finish_prod_data", style="success")
        builder.button(text="❌ لغو و بازگشت", callback_data="admin_panel", style="danger")
        builder.adjust(1)

        await callback.message.edit_text(
            "🔑 **محتوا/اطلاعات تحویلی خودکار** را ارسال کنید.\n\n"
            "📌 می‌توانید یک یا چند متن، عکس، فیلم، کد یا فایل مختلف ارسال نمایید.\n"
            "پس از ارسال تمامی پیام‌ها، روی دکمه **✅ ثبت نهایی محتوای محصول** کلیک کنید.",
            reply_markup=builder.as_markup(),
            parse_mode="Markdown"
        )
    else:
        data = await state.get_data()
        async with aiosqlite.connect(DB_PATH) as db:
            await db.execute(
                "INSERT INTO products (category_id, name, description, price, delivery_type, media_type, media_file_id) VALUES (?, ?, ?, ?, 'manual', ?, ?)",
                (data["prod_cat_id"], data["prod_name"], data["prod_desc"], data["prod_price"], data.get("prod_media_type"), data.get("prod_media_file_id"))
            )
            await db.commit()
        await state.clear()
        await callback.message.edit_text("✅ محصول با حالت **تحویل دستی** ذخیره شد.", reply_markup=get_admin_panel_keyboard())

@router.message(AdminStates.waiting_for_prod_data)
async def add_prod_data_collect(message: Message, state: FSMContext):
    data = await state.get_data()
    content_list = data.get("prod_content_list", [])

    if message.photo:
        item = {"type": "photo", "file_id": message.photo[-1].file_id, "caption": message.caption or ""}
    elif message.document:
        item = {"type": "document", "file_id": message.document.file_id, "caption": message.caption or ""}
    elif message.video:
        item = {"type": "video", "file_id": message.video.file_id, "caption": message.caption or ""}
    elif message.text:
        item = {"type": "text", "text": message.text}
    else:
        item = {"type": "text", "text": message.caption or "محتوا"}

    content_list.append(item)
    await state.update_data(prod_content_list=content_list)

    builder = InlineKeyboardBuilder()
    builder.button(text="✅ ثبت نهایی محتوای محصول", callback_data="finish_prod_data", style="success")
    builder.button(text="❌ لغو و بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await message.answer(
        f"📥 **محتوای شماره {len(content_list)} دریافت شد.**\n\n"
        f"می‌توانید پیام، عکس یا فایل دیگری ارسال کنید یا جهت اتمام روی **✅ ثبت نهایی محتوای محصول** کلیک کنید.",
        reply_markup=builder.as_markup(),
        parse_mode="Markdown"
    )

@router.callback_query(AdminStates.waiting_for_prod_data, F.data == "finish_prod_data")
async def finish_prod_data_handler(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    content_list = data.get("prod_content_list", [])

    if not content_list:
        await callback.answer("❌ حداقل باید یک پیام یا فایل برای محصول ارسال کنید!", show_alert=True)
        return

    full_stock_data = json.dumps(content_list, ensure_ascii=False)

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "INSERT INTO products (category_id, name, description, price, delivery_type, stock_data, media_type, media_file_id) VALUES (?, ?, ?, ?, 'auto', ?, ?, ?)",
            (data["prod_cat_id"], data["prod_name"], data["prod_desc"], data["prod_price"], full_stock_data, data.get("prod_media_type"), data.get("prod_media_file_id"))
        )
        await db.commit()

    await state.clear()
    await callback.message.edit_text(
        f"✅ محصول با موفقیت و **{len(content_list)} بخش محتوای تحویلی خودکار** ذخیره شد.",
        reply_markup=get_admin_panel_keyboard()
    )

# --- افزودن اختصاصی محصول وی‌پی‌ان (VPN) ---
@router.callback_query(F.data == "admin_add_vpn_prod")
async def add_vpn_prod_start(callback: CallbackQuery, state: FSMContext):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, name FROM categories") as cursor:
            cats = await cursor.fetchall()

    if not cats:
        await callback.answer("❌ ابتدا باید حداقل یک دسته‌بندی ایجاد کنید.", show_alert=True)
        return

    builder = InlineKeyboardBuilder()
    for c_id, c_name in cats:
        builder.button(text=c_name, callback_data=f"sel_vpn_cat_{c_id}")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await state.set_state(AdminStates.waiting_for_vpn_prod_cat)
    await callback.message.edit_text("📂 دسته‌بندی محصول وی‌پی‌ان (VPN) را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_vpn_prod_cat, F.data.startswith("sel_vpn_cat_"))
async def add_vpn_prod_cat_selected(callback: CallbackQuery, state: FSMContext):
    c_id = int(callback.data.split("_")[3])
    await state.update_data(vpn_prod_cat_id=c_id)
    await state.set_state(AdminStates.waiting_for_vpn_prod_name)
    await callback.message.edit_text("🌐 نام محصول وی‌پی‌ان را وارد کنید (مثال: `وی پی ان ۱۰ گیگ هلند`):", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_vpn_prod_name)
async def add_vpn_prod_name(message: Message, state: FSMContext):
    await state.update_data(vpn_prod_name=message.text.strip())
    await state.set_state(AdminStates.waiting_for_vpn_prod_desc)
    await message.answer("📝 **توضیحات وی‌پی‌ان** را وارد کنید (مثال: `تک کاربره / مهلت ۱ ماهه / سرعت بالا`):", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_vpn_prod_desc)
async def add_vpn_prod_desc(message: Message, state: FSMContext):
    await state.update_data(vpn_prod_desc=message.text.strip())
    await state.set_state(AdminStates.waiting_for_vpn_prod_price)
    await message.answer("💰 **قیمت محصول وی‌پی‌ان** را به تومان (فقط عدد) وارد کنید:", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_vpn_prod_price)
async def add_vpn_prod_price(message: Message, state: FSMContext):
    if not message.text.isdigit():
        await message.answer("لطفاً قیمت را فقط به صورت عدد معتبر وارد کنید:", reply_markup=get_cancel_btn())
        return

    price = int(message.text)
    await state.update_data(vpn_prod_price=price)
    await state.set_state(AdminStates.waiting_for_vpn_prod_media)

    builder = InlineKeyboardBuilder()
    builder.button(text="⏭️ رد کردن (بدون رسانه)", callback_data="skip_vpn_prod_media")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await message.answer(
        "🖼️ **تصویر / ویدیو / گیف محصول وی‌پی‌ان (اختیاری)**\n\n"
        "می‌توانید یک تصویر، ویدیو یا گیف ارسال کنید.\n"
        "در غیر این صورت روی **⏭️ رد کردن (بدون رسانه)** کلیک کنید.",
        reply_markup=builder.as_markup(),
        parse_mode="Markdown"
    )

@router.callback_query(AdminStates.waiting_for_vpn_prod_media, F.data == "skip_vpn_prod_media")
async def skip_vpn_prod_media_handler(callback: CallbackQuery, state: FSMContext):
    await save_vpn_product_db(callback.message, state, m_type=None, m_id=None)

@router.message(AdminStates.waiting_for_vpn_prod_media)
async def save_vpn_prod_media_handler(message: Message, state: FSMContext):
    if message.photo:
        m_type = "photo"
        m_id = message.photo[-1].file_id
    elif message.video:
        m_type = "video"
        m_id = message.video.file_id
    elif message.animation:
        m_type = "animation"
        m_id = message.animation.file_id
    else:
        await message.answer("لطفاً یک تصویر، ویدیو یا گیف ارسال کنید یا روی دکمه '⏭️ رد کردن' بزنید:")
        return

    await save_vpn_product_db(message, state, m_type=m_type, m_id=m_id)

async def save_vpn_product_db(target_msg: Message, state: FSMContext, m_type: str | None, m_id: str | None):
    data = await state.get_data()
    async with aiosqlite.connect(DB_PATH) as db:
        cursor = await db.execute(
            "INSERT INTO products (category_id, name, description, price, delivery_type, media_type, media_file_id) VALUES (?, ?, ?, ?, 'vpn', ?, ?)",
            (data["vpn_prod_cat_id"], data["vpn_prod_name"], data["vpn_prod_desc"], data["vpn_prod_price"], m_type, m_id)
        )
        prod_id = cursor.lastrowid
        await db.commit()

    await state.clear()

    builder = InlineKeyboardBuilder()
    builder.button(text="🔑 افزودن لینک‌های کانکشن هم‌اکنون", callback_data=f"add_vpn_stock_{prod_id}", style="success")
    builder.button(text="🏠 بازگشت به پنل مدیریت", callback_data="admin_panel")
    builder.adjust(1)

    await target_msg.answer(
        f"✅ **محصول وی‌پی‌ان ({data['vpn_prod_name']}) با موفقیت ایجاد شد!**\n\n"
        f"اکنون می‌توانید موجودی و لینک‌های کانکشن V2Ray/VLESS/VMess آن را ثبت نمایید.",
        reply_markup=builder.as_markup(),
        parse_mode="Markdown"
    )

# --- مدیریت موجودی و لینک‌های اختصاصی VPN ---
@router.callback_query(F.data == "admin_manage_vpn_stock")
async def manage_vpn_stock_menu(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("""
            SELECT p.id, p.name, 
            (SELECT COUNT(*) FROM vpn_stock WHERE product_id = p.id AND status = 'available') as stock_count
            FROM products p
            WHERE p.delivery_type = 'vpn'
        """) as cursor:
            vpn_prods = await cursor.fetchall()

    if not vpn_prods:
        builder = InlineKeyboardBuilder()
        builder.button(text="➕ ساخت محصول وی‌پی‌ان جدید", callback_data="admin_add_vpn_prod", style="success")
        builder.button(text="🔙 بازگشت", callback_data="admin_manage_prods", style="danger")
        builder.adjust(1)

        await callback.message.edit_text("⚠️ هنوز هیچ محصول وی‌پی‌انی ساخته نشده است.", reply_markup=builder.as_markup())
        return

    builder = InlineKeyboardBuilder()
    for p_id, p_name, s_count in vpn_prods:
        builder.button(text=f"🌐 {p_name} | موجودی: {s_count} عدد", callback_data=f"add_vpn_stock_{p_id}")

    builder.button(text="🔙 بازگشت", callback_data="admin_manage_prods", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("🔑 **مدیریت موجودی لینک‌های VPN**\nجهت افزودن لینک کانکشن روی محصول کلیک کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("add_vpn_stock_"))
async def add_vpn_stock_start(callback: CallbackQuery, state: FSMContext):
    prod_id = int(callback.data.split("_")[3])

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT name FROM products WHERE id = ?", (prod_id,)) as cursor:
            prod_row = await cursor.fetchone()

    if not prod_row:
        await callback.answer("محصول یافت نشد.", show_alert=True)
        return

    await state.update_data(target_vpn_prod_id=prod_id, collected_vpn_links=[])
    await state.set_state(AdminStates.waiting_for_vpn_links_input)

    builder = InlineKeyboardBuilder()
    builder.button(text="✅ ثبت و ذخیره لینک‌ها", callback_data="finish_vpn_stock_data", style="success")
    builder.button(text="❌ لغو و بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text(
        f"🌐 **افزودن موجودی لینک برای:** `{prod_row[0]}`\n\n"
        f"📌 لطفاً لینک‌های کانکشن (v2ray / vless / vmess / trojan) را بفرستید.\n"
        f"💡 می‌توانید چند لینک را یکجا بفرستید (هر لینک در یک خط) یا لینک‌ها را پیام به پیام ارسال کنید.\n\n"
        f"پس از ارسال تمام لینک‌ها، روی دکمه **✅ ثبت و ذخیره لینک‌ها** کلیک کنید.",
        reply_markup=builder.as_markup(),
        parse_mode="Markdown"
    )

@router.message(AdminStates.waiting_for_vpn_links_input)
async def add_vpn_stock_collect(message: Message, state: FSMContext):
    if not message.text:
        await message.answer("لطفاً لینک‌های کانکشن متنی ارسال کنید:")
        return

    data = await state.get_data()
    collected_links = data.get("collected_vpn_links", [])

    new_links = [line.strip() for line in message.text.split("\n") if line.strip()]
    collected_links.extend(new_links)

    await state.update_data(collected_vpn_links=collected_links)

    builder = InlineKeyboardBuilder()
    builder.button(text="✅ ثبت و ذخیره لینک‌ها", callback_data="finish_vpn_stock_data", style="success")
    builder.button(text="❌ لغو و بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await message.answer(
        f"📥 **تعداد {len(new_links)} لینک جدید دریافت شد!**\n"
        f"📊 مجموع لینک‌های آماده ذخیره در این مرحله: **{len(collected_links)} عدد**\n\n"
        f"می‌توانید لینک‌های بیشتری بفرستید یا روی **✅ ثبت و ذخیره لینک‌ها** بزنید.",
        reply_markup=builder.as_markup(),
        parse_mode="Markdown"
    )

@router.callback_query(AdminStates.waiting_for_vpn_links_input, F.data == "finish_vpn_stock_data")
async def finish_vpn_stock_data_handler(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("target_vpn_prod_id")
    collected_links = data.get("collected_vpn_links", [])

    if not collected_links:
        await callback.answer("❌ هیچ لینکی ارسال نشده است!", show_alert=True)
        return

    async with aiosqlite.connect(DB_PATH) as db:
        for link in collected_links:
            await db.execute(
                "INSERT INTO vpn_stock (product_id, link, status) VALUES (?, ?, 'available')",
                (prod_id, link)
            )
        await db.commit()

    await state.clear()
    await callback.message.edit_text(
        f"🎉 **تعداد {len(collected_links)} عدد لینک کانکشن VPN با موفقیت به موجودی این محصول اضافه شد!**",
        reply_markup=get_admin_panel_keyboard(),
        parse_mode="Markdown"
    )

# ==================== ۹. مدیریت کدهای تخفیف اختصاصی ====================
@router.callback_query(F.data == "admin_manage_discounts")
async def manage_discounts_menu(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, code, discount_type, value, scope FROM discount_codes") as cursor:
            codes = await cursor.fetchall()

    builder = InlineKeyboardBuilder()
    builder.button(text="➕ ساخت کد تخفیف جدید", callback_data="add_discount_code", style="success")

    for d_id, d_code, d_type, d_val, d_scope in codes:
        val_str = f"{d_val}%" if d_type == "percent" else f"{d_val:,} تومان"
        builder.button(text=f"🏷️ {d_code} ({val_str})", callback_data=f"del_discount_{d_id}")

    builder.button(text="🔙 بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("🏷️ **مدیریت کدهای تخفیف**\n(برای حذف کد تخفیف، روی آن کلیک کنید):", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("del_discount_"))
async def delete_discount_code(callback: CallbackQuery):
    d_id = int(callback.data.split("_")[2])
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM discount_codes WHERE id = ?", (d_id,))
        await db.commit()
    await callback.answer("✅ کد تخفیف حذف شد.", show_alert=True)
    await manage_discounts_menu(callback)

@router.callback_query(F.data == "add_discount_code")
async def add_discount_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_discount_code)
    await callback.message.edit_text("✏️ عبارت کد تخفیف را وارد کنید (مثال: `OFF50` یا `NOROOZ`):", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_discount_code)
async def add_discount_code_save(message: Message, state: FSMContext):
    await state.update_data(discount_code=message.text.strip().upper())
    await state.set_state(AdminStates.waiting_for_discount_type)

    builder = InlineKeyboardBuilder()
    builder.button(text="درصدی (%)", callback_data="dtype_percent")
    builder.button(text="مبلغ ثابت (تومان)", callback_data="dtype_fixed")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(2, 1)

    await message.answer("نوع تخفیف را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_discount_type, F.data.startswith("dtype_"))
async def add_discount_type_save(callback: CallbackQuery, state: FSMContext):
    d_type = callback.data.split("_")[1]
    await state.update_data(discount_type=d_type)
    await state.set_state(AdminStates.waiting_for_discount_value)

    unit = "درصد (مثال: 20)" if d_type == "percent" else "تومان (مثال: 10000)"
    await callback.message.edit_text(f"مقدار تخفیف را به {unit} وارد کنید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_discount_value)
async def add_discount_value_save(message: Message, state: FSMContext):
    if not message.text.isdigit():
        await message.answer("لطفاً فقط عدد وارد کنید:", reply_markup=get_cancel_btn())
        return

    await state.update_data(discount_value=int(message.text))
    await state.set_state(AdminStates.waiting_for_discount_scope)

    builder = InlineKeyboardBuilder()
    builder.button(text="🌐 برای همه محصولات", callback_data="dscope_all")
    builder.button(text="📂 برای یک دسته‌بندی خاص", callback_data="dscope_category")
    builder.button(text="📦 برای یک محصول خاص", callback_data="dscope_product")
    builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await message.answer("محدوده اعمال این کد تخفیف را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_discount_scope, F.data.startswith("dscope_"))
async def add_discount_scope_save(callback: CallbackQuery, state: FSMContext):
    scope = callback.data.split("_")[1]
    await state.update_data(discount_scope=scope)

    if scope == "all":
        data = await state.get_data()
        async with aiosqlite.connect(DB_PATH) as db:
            await db.execute(
                "INSERT INTO discount_codes (code, discount_type, value, scope) VALUES (?, ?, ?, 'all')",
                (data["discount_code"], data["discount_type"], data["discount_value"])
            )
            await db.commit()
        await state.clear()
        await callback.message.edit_text(f"✅ کد تخفیف `{data['discount_code']}` برای **همه محصولات** ثبت شد.", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

    elif scope == "category":
        async with aiosqlite.connect(DB_PATH) as db:
            async with db.execute("SELECT id, name FROM categories") as cursor:
                cats = await cursor.fetchall()

        builder = InlineKeyboardBuilder()
        for c_id, c_name in cats:
            builder.button(text=c_name, callback_data=f"sel_d_cat_{c_id}")
        builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
        builder.adjust(1)

        await state.set_state(AdminStates.waiting_for_discount_target)
        await callback.message.edit_text("دسته‌بندی مورد نظر را انتخاب کنید:", reply_markup=builder.as_markup())

    elif scope == "product":
        async with aiosqlite.connect(DB_PATH) as db:
            async with db.execute("SELECT id, name FROM products") as cursor:
                prods = await cursor.fetchall()

        builder = InlineKeyboardBuilder()
        for p_id, p_name in prods:
            builder.button(text=p_name, callback_data=f"sel_d_prod_{p_id}")
        builder.button(text="❌ لغو", callback_data="admin_panel", style="danger")
        builder.adjust(1)

        await state.set_state(AdminStates.waiting_for_discount_target)
        await callback.message.edit_text("محصول مورد نظر را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(AdminStates.waiting_for_discount_target, F.data.startswith("sel_d_"))
async def add_discount_target_save(callback: CallbackQuery, state: FSMContext):
    target_id = int(callback.data.split("_")[3])
    data = await state.get_data()

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "INSERT INTO discount_codes (code, discount_type, value, scope, target_id) VALUES (?, ?, ?, ?, ?)",
            (data["discount_code"], data["discount_type"], data["discount_value"], data["discount_scope"], target_id)
        )
        await db.commit()

    await state.clear()
    await callback.message.edit_text(f"✅ کد تخفیف `{data['discount_code']}` با موفقیت ایجاد شد.", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

# ==================== ۱۰. ارسال پیام همگانی و هدفمند ====================
@router.callback_query(F.data == "admin_broadcast")
async def broadcast_menu(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, name FROM categories") as cursor:
            cats = await cursor.fetchall()

    builder = InlineKeyboardBuilder()
    builder.button(text="📢 ارسال به تمامی کاربران", callback_data="bcast_target_all")
    builder.button(text="🌐 ارسال فقط به خریداران وی‌پی‌ان", callback_data="bcast_target_vpn")

    for c_id, c_name in cats:
        builder.button(text=f"📂 خریداران دسته‌بندی {c_name}", callback_data=f"bcast_target_cat_{c_id}")

    builder.button(text="🔙 بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("📢 **ارسال پیام همگانی**\nلطفاً جامعه هدف کاربران را انتخاب کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("bcast_target_"))
async def broadcast_target_selected(callback: CallbackQuery, state: FSMContext):
    target_str = callback.data.replace("bcast_target_", "")
    await state.update_data(broadcast_target=target_str)
    await state.set_state(AdminStates.waiting_for_broadcast_msg)

    await callback.message.edit_text(
        "📝 پیام همگانی خود را ارسال کنید (متن، عکس یا فیلم به همراه توضیحات پذیرفته می‌شود):",
        reply_markup=get_cancel_btn()
    )

@router.message(AdminStates.waiting_for_broadcast_msg)
async def process_broadcast_send(message: Message, state: FSMContext, bot: Bot):
    data = await state.get_data()
    target_str = data.get("broadcast_target")

    async with aiosqlite.connect(DB_PATH) as db:
        if target_str == "all":
            async with db.execute("SELECT user_id FROM users") as cursor:
                users = [row[0] for row in await cursor.fetchall()]
        elif target_str == "vpn":
            async with db.execute("SELECT DISTINCT used_by FROM vpn_stock WHERE used_by IS NOT NULL") as cursor:
                users = [row[0] for row in await cursor.fetchall()]
        elif target_str.startswith("cat_"):
            cat_id = int(target_str.replace("cat_", ""))
            async with db.execute("""
                SELECT DISTINCT orders.user_id FROM orders 
                JOIN products ON orders.product_id = products.id 
                WHERE products.category_id = ?
            """, (cat_id,)) as cursor:
                users = [row[0] for row in await cursor.fetchall()]
        else:
            users = []

    await state.clear()
    status_msg = await message.answer(f"⏳ ارسال پیام همگانی به {len(users)} کاربر آغاز شد...")

    sent_count = 0
    failed_count = 0

    for u_id in users:
        try:
            await message.copy_to(chat_id=u_id)
            sent_count += 1
            await asyncio.sleep(0.05)
        except Exception:
            failed_count += 1

    await status_msg.edit_text(
        f"✅ **ارسال پیام همگانی به پایان رسید!**\n\n"
        f"🟢 موفق: {sent_count} نفر\n"
        f"🔴 ناموفق (بلاک/حذف): {failed_count} نفر",
        reply_markup=get_admin_panel_keyboard(),
        parse_mode="Markdown"
    )

# ==================== ۱۱. آمار کل و تفکیکی ====================
@router.callback_query(F.data == "admin_stats")
async def admin_stats_handler(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT COUNT(*) FROM users") as cursor:
            total_users = (await cursor.fetchone())[0]

        async with db.execute("SELECT COUNT(*), SUM(price) FROM orders WHERE status = 'تکمیل شده'") as cursor:
            row = await cursor.fetchone()
            total_orders = row[0] or 0
            total_revenue = row[1] or 0

        async with db.execute("""
            SELECT categories.name, COUNT(orders.id), SUM(orders.price)
            FROM orders
            JOIN products ON orders.product_id = products.id
            JOIN categories ON products.category_id = categories.id
            WHERE orders.status = 'تکمیل شده'
            GROUP BY categories.id
        """) as cursor:
            cat_stats = await cursor.fetchall()

    text = (
        f"📊 **آمار و گزارشات کلی فروشگاه**\n"
        f"━━━━━━━━━━━━━━\n\n"
        f"👥 **تعداد کل کاربران:** {total_users:,} نفر\n"
        f"🛒 **تعداد کل خریدهای موفق:** {total_orders:,} عدد\n"
        f"💰 **مجموع درآمد کل فروشگاه:** {total_revenue:,} تومان\n\n"
        f"📂 **تفکیک فروش بر اساس دسته‌بندی‌ها:**\n"
    )

    if cat_stats:
        for c_name, c_count, c_sum in cat_stats:
            text += f"▫️ **{c_name}:** {c_count} خرید | {c_sum:,} تومان\n"
    else:
        text += "▫️ هنوز خریدی انجام نشده است.\n"

    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به پنل مدیریت", callback_data="admin_panel", style="danger")
    await callback.message.edit_text(text, reply_markup=builder.as_markup(), parse_mode="Markdown")

# ==================== ۱۲. مدیریت کانال گزارشات و اسپانسرها ====================
@router.callback_query(F.data == "admin_set_log_channel")
async def log_channel_settings_menu(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT value FROM settings WHERE key='log_channel'") as cursor:
            ch = (await cursor.fetchone())[0]
        async with db.execute("SELECT value FROM settings WHERE key='log_footer_text'") as cursor:
            ft = (await cursor.fetchone())[0]

    builder = InlineKeyboardBuilder()
    builder.button(text="📢 تنظیم شناسه کانال گزارشات", callback_data="ch_log_ch")
    builder.button(text="✏️ ویرایش متن توضیحات/تشکر کانال", callback_data="ch_log_ft")
    builder.button(text="🔙 بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    text = (
        f"📣 **تنظیمات کانال گزارش تراکنش‌ها**\n\n"
        f"▫️ شناسه کانال فعلی: `{ch or 'تنظیم نشده'}`\n"
        f"▫️ متن پاورقی فعلی:\n`{ft}`"
    )
    await callback.message.edit_text(text, reply_markup=builder.as_markup(), parse_mode="Markdown")

@router.callback_query(F.data == "ch_log_ch")
async def set_log_ch_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_log_channel)
    await callback.message.edit_text("آیدی عددی کانال یا یوزرنیم کانال را وارد کنید (مثال: `@my_logs` یا `-10012345678`):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_log_channel)
async def set_log_ch_save(message: Message, state: FSMContext):
    ch_val = message.text.strip()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('log_channel', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (ch_val,))
        await db.commit()
    await state.clear()
    await message.answer("✅ کانال گزارش تراکنش‌ها ذخیره شد. (مطمئن شوید ربات در کانال ادمین است)", reply_markup=get_admin_panel_keyboard())

@router.callback_query(F.data == "ch_log_ft")
async def set_log_ft_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_log_footer)
    await callback.message.edit_text("متن تشکر پایین فاکتور گزارش را ارسال کنید (مثال: `ممنون از اعتماد شما ❤️`):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_log_footer)
async def set_log_ft_save(message: Message, state: FSMContext):
    ft_val = message.text.strip()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('log_footer_text', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (ft_val,))
        await db.commit()
    await state.clear()
    await message.answer("✅ متن تشکر گزارشات بروزرسانی شد.", reply_markup=get_admin_panel_keyboard())

# --- مدیریت کانال‌های اسپانسری (قفل عضویت اجباری) ---
@router.callback_query(F.data == "admin_manage_sponsors")
async def manage_sponsors_menu(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT id, title, channel_id FROM sponsor_channels") as cursor:
            sponsors = await cursor.fetchall()

    builder = InlineKeyboardBuilder()
    builder.button(text="➕ افزودن کانال اسپانسری جدید", callback_data="add_sponsor_ch", style="success")

    for s_id, s_title, s_ch in sponsors:
        builder.button(text=f"❌ حذف: {s_title}", callback_data=f"del_sponsor_{s_id}")

    builder.button(text="🔙 بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("📢 **مدیریت کانال‌های اسپانسری (قفل عضویت)**", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("del_sponsor_"))
async def delete_sponsor_channel(callback: CallbackQuery):
    s_id = int(callback.data.split("_")[2])
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM sponsor_channels WHERE id = ?", (s_id,))
        await db.commit()
    await callback.answer("✅ کانال اسپانسری حذف شد.", show_alert=True)
    await manage_sponsors_menu(callback)

@router.callback_query(F.data == "add_sponsor_ch")
async def add_sponsor_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_sponsor_ch_id)
    await callback.message.edit_text("آیدی عددی کانال (با -100) یا یوزرنیم کانال را وارد کنید (مثال: `@mychannel` یا `-10012345678`):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_sponsor_ch_id)
async def add_sponsor_ch_id(message: Message, state: FSMContext):
    await state.update_data(sp_ch_id=message.text.strip())
    await state.set_state(AdminStates.waiting_for_sponsor_title)
    await message.answer("عنوان/نام کانال را وارد کنید (مثال: `کانال رسمی ما`):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_sponsor_title)
async def add_sponsor_title(message: Message, state: FSMContext):
    await state.update_data(sp_title=message.text.strip())
    await state.set_state(AdminStates.waiting_for_sponsor_link)
    await message.answer("لینک جوین/دعوت کانال را وارد کنید (مثال: `https://t.me/mychannel`):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_sponsor_link)
async def add_sponsor_link(message: Message, state: FSMContext):
    data = await state.get_data()
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "INSERT INTO sponsor_channels (channel_id, title, invite_link) VALUES (?, ?, ?)",
            (data["sp_ch_id"], data["sp_title"], message.text.strip())
        )
        await db.commit()

    await state.clear()
    await message.answer("✅ کانال اسپانسری با موفقیت اضافه شد.", reply_markup=get_admin_panel_keyboard())

# ==================== ۱۳. بررسی رسیدهای کارت به کارت در انتظار ====================
@router.callback_query(F.data == "admin_check_receipts")
async def admin_check_receipts_handler(callback: CallbackQuery):
    if not await is_admin(callback.from_user.id):
        return

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("""
            SELECT receipts.id, receipts.user_id, users.username, receipts.photo_id, receipts.caption, receipts.created_at
            FROM receipts
            JOIN users ON receipts.user_id = users.user_id
            WHERE receipts.status = 'pending'
            ORDER BY receipts.id DESC
        """) as cursor:
            pending_receipts = await cursor.fetchall()

    if not pending_receipts:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت به پنل مدیریت", callback_data="admin_panel", style="danger")
        await callback.message.edit_text("📋 هیچ رسید تایید نشده‌ای در سیستم وجود ندارد.", reply_markup=builder.as_markup())
        return

    await callback.message.edit_text(f"📋 **تعداد {len(pending_receipts)} رسید در انتظار بررسی پیدا شد:**\nدر حال ارسال...", parse_mode="Markdown")

    for rec_id, u_id, u_name, photo_id, caption, created_at in pending_receipts:
        builder = InlineKeyboardBuilder()
        builder.button(text="✅ تایید و شارژ", callback_data=f"approve_rec_{rec_id}", style="success")
        builder.button(text="❌ رد رسید", callback_data=f"reject_rec_{rec_id}", style="danger")
        builder.adjust(2)

        text = (
            f"💳 **رسید شماره #{rec_id}**\n\n"
            f"👤 کاربر: @{u_name or 'بدون یوزرنیم'}\n"
            f"🆔 آیدی عددی: `{u_id}`\n"
            f"📝 توضیحات: {caption or 'بدون توضیح'}\n"
            f"📅 تاریخ: `{created_at}`"
        )

        try:
            if photo_id:
                await callback.message.answer_photo(photo_id, caption=text, reply_markup=builder.as_markup(), parse_mode="Markdown")
            else:
                await callback.message.answer(text, reply_markup=builder.as_markup(), parse_mode="Markdown")
        except Exception:
            pass

# ==================== ۱۴. مدیریت سفارشات ====================
@router.callback_query(F.data == "admin_manage_orders")
async def manage_orders_list(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("""
            SELECT orders.id, users.username, orders.user_id, products.name, orders.status
            FROM orders
            JOIN users ON orders.user_id = users.user_id
            JOIN products ON orders.product_id = products.id
            ORDER BY orders.id DESC LIMIT 20
        """) as cursor:
            orders = await cursor.fetchall()

    if not orders:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت", callback_data="admin_panel", style="danger")
        await callback.message.edit_text("📋 هیچ سفارشی ثبت نشده است.", reply_markup=builder.as_markup())
        return

    builder = InlineKeyboardBuilder()
    for o_id, u_name, u_id, p_name, status in orders:
        builder.button(text=f"#{o_id} | @{u_name or u_id} | {p_name} ({status})", callback_data=f"manage_ord_{o_id}")
    builder.button(text="❌ بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("📋 **لیست سفارشات اخیر:**\nجهت بررسی و تغییر وضعیت روی سفارش کلیک کنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("manage_ord_"))
async def manage_single_order(callback: CallbackQuery, state: FSMContext):
    o_id = int(callback.data.split("_")[2])
    await state.update_data(target_order_id=o_id)

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("""
            SELECT orders.id, orders.user_id, users.username, products.name, orders.price, orders.status
            FROM orders
            JOIN users ON orders.user_id = users.user_id
            JOIN products ON orders.product_id = products.id
            WHERE orders.id = ?
        """, (o_id,)) as cursor:
            ord_data = await cursor.fetchone()

    if not ord_data:
        return

    _, u_id, u_name, p_name, price, status = ord_data

    text = (
        f"📦 **مدیریت سفارش #{o_id}**\n\n"
        f"👤 کاربر: @{u_name or 'ندارد'}\n"
        f"🆔 آیدی عددی: `{u_id}`\n"
        f"🛒 محصول: {p_name}\n"
        f"💰 قیمت: {price:,} تومان\n"
        f"📌 وضعیت فعلی: `{status}`"
    )

    builder = InlineKeyboardBuilder()
    builder.button(text="✏️ تغییر متن وضعیت (مثلاً: در حال خرید اکانت)", callback_data=f"ch_ord_stat_{o_id}")
    builder.button(text="✅ تکمیل سفارش و ارسال فایل/کد به کاربر", callback_data=f"compl_ord_{o_id}", style="success")
    builder.button(text="🔙 بازگشت", callback_data="admin_manage_orders", style="danger")
    builder.adjust(1)

    await callback.message.edit_text(text, reply_markup=builder.as_markup(), parse_mode="Markdown")

@router.callback_query(F.data.startswith("ch_ord_stat_"))
async def ch_order_status_start(callback: CallbackQuery, state: FSMContext):
    o_id = int(callback.data.split("_")[3])
    await state.update_data(target_order_id=o_id)
    await state.set_state(AdminStates.waiting_for_order_status_text)
    await callback.message.edit_text("✏️ متن جدید وضعیت سفارش را وارد کنید (مثلاً: اکانت خریداری شد، در حال ساخت لینک کانفیگ):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_order_status_text)
async def ch_order_status_save(message: Message, state: FSMContext, bot: Bot):
    new_status = message.text
    data = await state.get_data()
    o_id = data["target_order_id"]

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id FROM orders WHERE id = ?", (o_id,)) as cursor:
            u_id = (await cursor.fetchone())[0]
        await db.execute("UPDATE orders SET status = ? WHERE id = ?", (new_status, o_id))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ وضعیت سفارش #{o_id} به `{new_status}` تغییر یافت.", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

    try:
        await bot.send_message(u_id, f"📌 **تغییر وضعیت سفارش #{o_id}**\n\nوضعیت جدید: `{new_status}`", parse_mode="Markdown")
    except Exception:
        pass

@router.callback_query(F.data.startswith("compl_ord_"))
async def complete_order_start(callback: CallbackQuery, state: FSMContext):
    o_id = int(callback.data.split("_")[2])
    await state.update_data(target_order_id=o_id)
    await state.set_state(AdminStates.waiting_for_order_complete_content)
    await callback.message.edit_text("🔑 اطلاعات تحویلی به کاربر (کد/لینک/اکانت) را ارسال کنید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_order_complete_content)
async def complete_order_save(message: Message, state: FSMContext, bot: Bot):
    content = message.text
    data = await state.get_data()
    o_id = data["target_order_id"]

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id, product_id FROM orders WHERE id = ?", (o_id,)) as cursor:
            row = await cursor.fetchone()
            u_id, p_id = row[0], row[1]

        async with db.execute("SELECT name FROM products WHERE id = ?", (p_id,)) as cursor:
            p_name = (await cursor.fetchone())[0]

        await db.execute("UPDATE orders SET status = 'تکمیل شده', delivered_content = ? WHERE id = ?", (content, o_id))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ سفارش #{o_id} تکمیل شد و محتوا به کاربر تحویل گردید.", reply_markup=get_admin_panel_keyboard())

    try:
        await bot.send_message(u_id, f"🎉 **سفارش #{o_id} ({p_name}) تکمیل شد!**\n\n🔑 **اطلاعات تحویلی:**\n`{content}`", parse_mode="Markdown")
    except Exception:
        pass

# ==================== ۱۵. مدیریت تیکت‌ها ====================
@router.callback_query(F.data == "admin_manage_tickets")
async def list_open_tickets(callback: CallbackQuery):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("""
            SELECT tickets.id, tickets.user_id, users.username, tickets.subject
            FROM tickets
            JOIN users ON tickets.user_id = users.user_id
            WHERE tickets.status = 'open'
        """) as cursor:
            tickets = await cursor.fetchall()

    if not tickets:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت", callback_data="admin_panel", style="danger")
        await callback.message.edit_text("📋 هیچ تیکت باز جدیدی وجود ندارد.", reply_markup=builder.as_markup())
        return

    builder = InlineKeyboardBuilder()
    for t_id, u_id, u_name, subj in tickets:
        builder.button(text=f"🎫 #{t_id} | @{u_name or u_id} - {subj[:20]}", callback_data=f"reply_tk_{t_id}")
    builder.button(text="❌ بازگشت", callback_data="admin_panel", style="danger")
    builder.adjust(1)

    await callback.message.edit_text("📋 **لیست تیکت‌های پشتیبانی:**", reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("reply_tk_"))
async def reply_ticket_start(callback: CallbackQuery, state: FSMContext):
    t_id = int(callback.data.split("_")[2])
    await state.update_data(reply_ticket_id=t_id)
    await state.set_state(AdminStates.waiting_for_ticket_reply)
    await callback.message.reply(f"✍️ پاسخ خود را برای تیکت #{t_id} بنویسید:", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_ticket_reply)
async def reply_ticket_send(message: Message, state: FSMContext, bot: Bot):
    data = await state.get_data()
    t_id = data["reply_ticket_id"]
    reply_text = message.text

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id FROM tickets WHERE id = ?", (t_id,)) as cursor:
            user_id = (await cursor.fetchone())[0]
        await db.execute("INSERT INTO ticket_messages (ticket_id, sender, message_text) VALUES (?, 'admin', ?)", (t_id, reply_text))
        await db.execute("UPDATE tickets SET status = 'closed' WHERE id = ?", (t_id,))
        await db.commit()

    await state.clear()
    await message.answer("✅ پاسخ برای کاربر ارسال شد و تیکت بسته شد.", reply_markup=get_admin_panel_keyboard())
    try:
        await bot.send_message(user_id, f"📩 **پاسخ پشتیبانی به تیکت #{t_id}:**\n\n{reply_text}", parse_mode="Markdown")
    except Exception:
        pass

# ==================== ۱۶. تنظیمات کارت بانکی و شارژ دستی ====================
@router.callback_query(F.data == "admin_set_card")
async def set_card_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_card_num)
    await callback.message.edit_text("💳 **مرحله ۱ از ۲:** شماره کارت ۱۶ رقمی را وارد کنید:", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_card_num)
async def set_card_num_save(message: Message, state: FSMContext):
    await state.update_data(card_num=message.text.strip())
    await state.set_state(AdminStates.waiting_for_card_owner)
    await message.answer("👤 **مرحله ۲ از ۲:** نام و نام خانوادگی صاحب حساب را وارد کنید:", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_card_owner)
async def set_card_owner_save(message: Message, state: FSMContext):
    data = await state.get_data()
    card_num = data["card_num"]
    card_owner = message.text.strip()

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("INSERT INTO settings (key, value) VALUES ('bank_card', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (card_num,))
        await db.execute("INSERT INTO settings (key, value) VALUES ('card_owner', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (card_owner,))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ **اطلاعات کارت ذخیره شد:**\n\n💳 شماره کارت: `{card_num}`\n👤 صاحب حساب: {card_owner}", reply_markup=get_admin_panel_keyboard(), parse_mode="Markdown")

@router.callback_query(F.data == "admin_manual_charge")
async def manual_charge_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminStates.waiting_for_manual_charge_user)
    await callback.message.edit_text("👤 آیدی عددی یا یوزرنیم کاربر را وارد کنید (مثال: `@username` یا `12345678`):", reply_markup=get_cancel_btn())

@router.message(AdminStates.waiting_for_manual_charge_user)
async def manual_charge_user(message: Message, state: FSMContext):
    input_val = message.text.strip().replace("@", "")

    async with aiosqlite.connect(DB_PATH) as db:
        if input_val.isdigit():
            async with db.execute("SELECT user_id, username FROM users WHERE user_id = ?", (int(input_val),)) as cursor:
                user_row = await cursor.fetchone()
        else:
            async with db.execute("SELECT user_id, username FROM users WHERE LOWER(username) = LOWER(?)", (input_val,)) as cursor:
                user_row = await cursor.fetchone()

    if not user_row:
        await message.answer("❌ کاربر در دیتابیس ربات یافت نشد! کاربر باید حداقل یک‌بار ربات را /start کرده باشد.", reply_markup=get_cancel_btn())
        return

    await state.update_data(target_user=user_row[0], target_username=user_row[1])
    await state.set_state(AdminStates.waiting_for_manual_charge_amount)
    await message.answer(f"💰 کاربر **@{user_row[1] or user_row[0]}** یافت شد.\nمبلغ شارژ (به تومان) را وارد کنید:", reply_markup=get_cancel_btn(), parse_mode="Markdown")

@router.message(AdminStates.waiting_for_manual_charge_amount)
async def manual_charge_amount(message: Message, state: FSMContext, bot: Bot):
    if not message.text.isdigit():
        await message.answer("لطفاً فقط عدد وارد کنید:", reply_markup=get_cancel_btn())
        return
    amount = int(message.text)
    data = await state.get_data()
    u_id = data["target_user"]

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("UPDATE users SET balance = balance + ? WHERE user_id = ?", (amount, u_id))
        await db.commit()

    await state.clear()
    await message.answer(f"✅ حساب کاربر `{u_id}` به مبلغ {amount:,} تومان شارژ شد.", reply_markup=get_admin_panel_keyboard())
    try:
        await bot.send_message(u_id, f"🎁 حساب شما به مبلغ **{amount:,} تومان** شارژ شد!", parse_mode="Markdown")
    except Exception:
        pass

# ==================== ۱۷. تایید و رد رسیدهای شارژ ====================
@router.callback_query(F.data.startswith("approve_rec_"))
async def approve_rec_start(callback: CallbackQuery, state: FSMContext):
    if not await is_admin(callback.from_user.id):
        await callback.answer("❌ شما ادمین نیستید!", show_alert=True)
        return

    rec_id = int(callback.data.split("_")[2])
    prompt_msg = await callback.message.reply("💰 مبلغ شارژ به تومان را وارد کنید:", reply_markup=get_cancel_btn())

    await state.update_data(
        rec_id=rec_id,
        prompt_msg_id=prompt_msg.message_id,
        receipt_msg_id=callback.message.message_id,
        chat_id=callback.message.chat.id
    )
    await state.set_state(AdminStates.waiting_for_approve_amount)

@router.message(AdminStates.waiting_for_approve_amount)
async def approve_rec_finish(message: Message, state: FSMContext, bot: Bot):
    if not message.text.isdigit():
        await message.answer("لطفاً فقط عدد وارد کنید:", reply_markup=get_cancel_btn())
        return

    amount = int(message.text)
    data = await state.get_data()
    rec_id = data.get("rec_id")
    prompt_msg_id = data.get("prompt_msg_id")
    receipt_msg_id = data.get("receipt_msg_id")
    chat_id = data.get("chat_id", message.chat.id)
    admin_user = message.from_user

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id FROM receipts WHERE id = ?", (rec_id,)) as cursor:
            row = await cursor.fetchone()
            user_id = row[0] if row else None

        if user_id:
            await db.execute("UPDATE users SET balance = balance + ? WHERE user_id = ?", (amount, user_id))
            await db.execute("UPDATE receipts SET status = 'approved' WHERE id = ?", (rec_id,))
            await db.commit()

    await state.clear()

    text_update = f"\n\n✅ **تایید شده توسط ادمین @{admin_user.username or admin_user.first_name}**\n💰 **مبلغ شارژ:** {amount:,} تومان"

    # بروزرسانی کارت رسید اصلی و حذف دکمه‌های تایید/رد
    if receipt_msg_id:
        try:
            if message.reply_to_message and message.reply_to_message.message_id == prompt_msg_id and message.reply_to_message.reply_to_message:
                orig = message.reply_to_message.reply_to_message
                if orig.caption:
                    await bot.edit_message_caption(chat_id=chat_id, message_id=receipt_msg_id, caption=orig.caption + text_update, reply_markup=None, parse_mode="Markdown")
                else:
                    await bot.edit_message_text(chat_id=chat_id, message_id=receipt_msg_id, text=(orig.text or "💳 رسید واریزی") + text_update, reply_markup=None, parse_mode="Markdown")
            else:
                try:
                    await bot.edit_message_caption(chat_id=chat_id, message_id=receipt_msg_id, caption=f"💳 **رسید شماره #{rec_id}**" + text_update, reply_markup=None, parse_mode="Markdown")
                except Exception:
                    await bot.edit_message_text(chat_id=chat_id, message_id=receipt_msg_id, text=f"💳 **رسید شماره #{rec_id}**" + text_update, reply_markup=None, parse_mode="Markdown")
        except Exception:
            pass

    # پاکسازی پیام‌های اضافی در گروه
    if message.chat.type in ["group", "supergroup"]:
        try:
            await message.delete()
        except Exception:
            pass
        if prompt_msg_id:
            try:
                await bot.delete_message(chat_id=chat_id, message_id=prompt_msg_id)
            except Exception:
                pass
    else:
        if prompt_msg_id:
            try:
                await bot.delete_message(chat_id=chat_id, message_id=prompt_msg_id)
            except Exception:
                pass
        await message.answer(f"✅ رسید #{rec_id} تایید شد و کاربر `{user_id}` به مبلغ {amount:,} تومان شارژ گردید.", reply_markup=get_admin_panel_keyboard())

    if user_id:
        try:
            await bot.send_message(user_id, f"🎉 رسید شارژ شما تایید شد و حساب شما به مبلغ **{amount:,} تومان** شارژ گردید!", parse_mode="Markdown")
        except Exception:
            pass

@router.callback_query(F.data.startswith("reject_rec_"))
async def reject_rec(callback: CallbackQuery, bot: Bot):
    if not await is_admin(callback.from_user.id):
        await callback.answer("❌ شما ادمین نیستید!", show_alert=True)
        return

    rec_id = int(callback.data.split("_")[2])
    admin_user = callback.from_user

    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute("SELECT user_id FROM receipts WHERE id = ?", (rec_id,)) as cursor:
            row = await cursor.fetchone()
            user_id = row[0] if row else None
        await db.execute("UPDATE receipts SET status = 'rejected' WHERE id = ?", (rec_id,))
        await db.commit()

    text_update = f"\n\n❌ **رد شده توسط ادمین @{admin_user.username or admin_user.first_name}**"
    try:
        if callback.message.caption:
            await callback.message.edit_caption(caption=callback.message.caption + text_update, reply_markup=None)
        else:
            await callback.message.edit_text(text=callback.message.text + text_update, reply_markup=None)
    except Exception:
        pass

    try:
        if user_id:
            await bot.send_message(user_id, "❌ رسید شارژ حساب شما مورد تایید قرار نگرفت.")
    except Exception:
        pass