import asyncio
import json
import os
import uuid
from datetime import datetime

from aiogram import Bot, Dispatcher, F, types
from aiogram.client.session.aiohttp import AiohttpSession
from aiogram.enums import ParseMode
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message


# =========================
# Settings
# =========================
TOKEN = "توکن_ربات_خودت"
ADMIN_ID = 123456789
SUPPORT_ID = "@YourID"


CARD_NUMBER = "6104 3386 9673 8463"
CARD_HOLDER = "رفیعی"
PRICE_PER_GB = 4400

CUSTOMERS_FILE = "customers.json"
ORDERS_FILE = "orders.json"

PLAN_PRICES = {
    "special_1": {"title": "پلن ویژه تک کاربره", "price": 400000},
    "special_2": {"title": "پلن ویژه دو کاربره", "price": 800000},
    "special_3": {"title": "پلن ویژه سه کاربره", "price": 1000000},
}

session = AiohttpSession()
bot = Bot(token=TOKEN, session=session, parse_mode=ParseMode.MARKDOWN)
dp = Dispatcher()


# =========================
# States
# =========================
class BotStates(StatesGroup):
    waiting_for_volume = State()
    waiting_for_renewal_text = State()
    waiting_for_receipt_order_code = State()
    waiting_for_receipt_photo = State()
    waiting_for_inquiry_code = State()
    waiting_for_broadcast = State()
    waiting_for_admin_delivery = State()


# =========================
# Storage helpers
# =========================
def load_json(path, default):
    if not os.path.exists(path):
        return default
    try:
        with open(path, "r", encoding="utf-8") as file:
            return json.load(file)
    except Exception as e:
        print(f"[load_json] خطا در خواندن {path}: {e}")
        return default


def save_json(path, data):
    with open(path, "w", encoding="utf-8") as file:
        json.dump(data, file, ensure_ascii=False, indent=2)


def load_customers():
    return load_json(CUSTOMERS_FILE, [])


def save_customers(customers):
    save_json(CUSTOMERS_FILE, customers)


def load_orders():
    return load_json(ORDERS_FILE, [])


def save_orders(orders):
    save_orders(ORDERS_FILE, orders)


def now_text():
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def upsert_customer(user, last_order_type=None):
    customers = load_customers()
    for item in customers:
        if item["user_id"] == user.id:
            item["full_name"] = user.full_name
            item["username"] = user.username
            item["last_seen"] = now_text()
            if last_order_type:
                item["last_order_type"] = last_order_type
            save_customers(customers)
            return

    customers.append(
        {
            "user_id": user.id,
            "full_name": user.full_name,
            "username": user.username,
            "last_seen": now_text(),
            "last_order_type": last_order_type or "بدون سفارش",
        }
    )
    save_customers(customers)


def generate_order_code():
    return "ORD-" + uuid.uuid4().hex[:8].upper()


def create_order(user, order_type, amount, extra_info=""):
    orders = load_orders()
    order_code = generate_order_code()

    orders.append(
        {
            "order_code": order_code,
            "user_id": user.id,
            "full_name": user.full_name,
            "username": user.username,
            "order_type": order_type,
            "amount": amount,
            "extra_info": extra_info,
            "status": "در انتظار پرداخت",
            "created_at": now_text(),
            "receipt_received": False,
        }
    )
    save_orders(orders)
    upsert_customer(user, order_type)
    return order_code


def update_order_receipt(order_code):
    orders = load_orders()
    for order in orders:
        if order["order_code"].strip().upper() == order_code.strip().upper():
            order["receipt_received"] = True
            order["status"] = "رسید ارسال شده"
            order["updated_at"] = now_text()
            save_orders(orders)
            return order
    return None


def update_order_status(order_code, status, admin_response=None):
    orders = load_orders()
    for order in orders:
        if order["order_code"].strip().upper() == order_code.strip().upper():
            order["status"] = status
            order["updated_at"] = now_text()
            if admin_response is not None:
                order["admin_response"] = admin_response
            save_orders(orders)
            return order
    return None


def find_order(order_code):
    orders = load_orders()
    for order in orders:
        if order["order_code"].strip().upper() == order_code.strip().upper():
            return order
    return None


def get_customer_count():
    return len(load_customers())


def get_orders_count():
    return len(load_orders())


# =========================
# Keyboards
# =========================
def main_menu():
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text="📥 سفارش حجمی", callback_data="custom_vol")],
            [InlineKeyboardButton(text="♾ پلن‌های ویژه", callback_data="special_plans")],
            [InlineKeyboardButton(text="🔄 تمدید سرویس", callback_data="renewal")],
            [InlineKeyboardButton(text="🧾 ارسال رسید پرداخت", callback_data="send_receipt")],
            [InlineKeyboardButton(text="🔎 استعلام سفارش", callback_data="inquiry")],
            [InlineKeyboardButton(text="📚 آموزش فعال‌سازی", callback_data="guide")],
            [InlineKeyboardButton(text="📜 قوانین خرید", callback_data="rules")],
            [InlineKeyboardButton(text="☎️ پشتیبانی", callback_data="support")],
        ]
    )


def back_menu():
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text="🏠 بازگشت به منوی اصلی", callback_data="back_main")]
        ]
    )


def special_plans_menu():
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text="👤 پلن ویژه تک کاربره", callback_data="plan_special_1")],
            [InlineKeyboardButton(text="👥 پلن ویژه دو کاربره", callback_data="plan_special_2")],
            [InlineKeyboardButton(text="👨‍👩‍👧 پلن ویژه سه کاربره", callback_data="plan_special_3")],
            [InlineKeyboardButton(text="🏠 بازگشت به منوی اصلی", callback_data="back_main")],
        ]
    )


def admin_menu():
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text="👥 تعداد مشتری‌ها", callback_data="admin_count")],
            [InlineKeyboardButton(text="📦 تعداد سفارش‌ها", callback_data="admin_orders_count")],
            [InlineKeyboardButton(text="📄 لیست مشتری‌ها", callback_data="admin_list")],
            [InlineKeyboardButton(text="📬 پیام همگانی", callback_data="admin_broadcast")],
            [InlineKeyboardButton(text="🏠 بازگشت به منوی اصلی", callback_data="back_main")],
        ]
    )


def admin_receipt_actions(order_code, user_id):
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [
                InlineKeyboardButton(
                    text="✅ تایید و ارسال لینک",
                    callback_data=f"approve|{order_code}|{user_id}",
                )
            ],
            [
                InlineKeyboardButton(
                    text="❌ رد سفارش",
                    callback_data=f"reject|{order_code}|{user_id}",
                )
            ],
        ]
    )


# =========================
# Utility text
# =========================
def payment_text(title, price_text, order_code):
    return (
        f"✅ *{title}*\n\n"
        f"🧾 کد سفارش: `{order_code}`\n"
        f"💵 مبلغ: *{price_text}*\n\n"
        "💳 اطلاعات پرداخت:\n"
        f"`{CARD_NUMBER}`\n"
        f"👤 به نام: *{CARD_HOLDER}*\n\n"
        "بعد از پرداخت، از بخش *🧾 ارسال رسید پرداخت* تصویر رسیدت رو بفرست 🌟\n"
        "مرسی از اعتمادت 🌹"
    )


async def set_order_context(state: FSMContext, order_code, order_type):
    await state.update_data(order_code=order_code, order_type=order_type)


# =========================
# Start
# =========================
@dp.message(Command("start"))
async def start_handler(message: Message, state: FSMContext):
    await state.clear()
    upsert_customer(message.from_user)

    text = (
        "سلام دوست خوبم 🌟\n\n"
        "به ربات فروش سرویس دیجیتال خوش اومدی ✨\n"
        "اینجا می‌تونی خیلی راحت سفارش ثبت کنی، رسید بفرستی و وضعیت سفارشت رو پیگیری کنی 🚀\n\n"
        "از منوی زیر انتخاب کن 👇"
    )
    await message.answer(text, reply_markup=main_menu())


# =========================
# Back main
# =========================
@dp.callback_query(F.data == "back_main")
async def back_main_handler(callback: types.CallbackQuery, state: FSMContext):
    await state.clear()
    await callback.message.edit_text(
        "🏠 برگشتی به منوی اصلی\n\nهر چیزی لازم داشتی از اینجا انتخاب کن 😄",
        reply_markup=main_menu(),
    )
    await callback.answer()


# =========================
# Custom volume
# =========================
@dp.callback_query(F.data == "custom_vol")
async def custom_volume_handler(callback: types.CallbackQuery, state: FSMContext):
    await state.clear()
    await callback.message.edit_text(
        f"📥 *سفارش حجمی*\n\n"
        f"💰 قیمت هر گیگابایت: *{PRICE_PER_GB:,} تومان*\n\n"
        "لطفاً تعداد گیگ موردنظرت رو فقط به صورت عدد بفرست.\n"
        "مثال: `10`",
        reply_markup=back_menu(),
    )
    await state.set_state(BotStates.waiting_for_volume)
    await callback.answer()


@dp.message(BotStates.waiting_for_volume)
async def get_volume_handler(message: Message, state: FSMContext):
    if not message.text or not message.text.isdigit():
        await message.answer("⚠️ لطفاً فقط عدد بفرست، مثلاً `5`")
        return

    gb = int(message.text)
    if gb <= 0:
        await message.answer("❌ تعداد گیگ باید بیشتر از صفر باشه.")
        return

    total = gb * PRICE_PER_GB
    order_type = f"سفارش حجمی - {gb} گیگ"
    order_code = create_order(message.from_user, order_type, total, f"{gb} گیگ")

    await message.answer(
        payment_text(order_type, f"{total:,} تومان", order_code),
        reply_markup=main_menu(),
    )
    await state.clear()


# =========================
# Special plans
# =========================
@dp.callback_query(F.data == "special_plans")
async def special_plans_handler(callback: types.CallbackQuery):
    await callback.message.edit_text(
        "♾ *پلن‌های ویژه*\n\nیکی از پلن‌ها رو انتخاب کن تا اطلاعات پرداختش رو ببینی 👇",
        reply_markup=special_plans_menu(),
    )
    await callback.answer()


@dp.callback_query(F.data.startswith("plan_special_"))
async def special_plan_detail(callback: types.CallbackQuery, state: FSMContext):
    key = callback.data.replace("plan_", "")
    plan = PLAN_PRICES.get(key)
    if not plan:
        await callback.answer("پلن پیدا نشد.", show_alert=True)
        return

    order_code = create_order(callback.from_user, plan["title"], plan["price"], "")

    await callback.message.edit_text(
        payment_text(plan["title"], f"{plan['price']:,} تومان", order_code),
        reply_markup=back_menu(),
    )
    await callback.answer()


# =========================
# Renewal
# =========================
@dp.callback_query(F.data == "renewal")
async def renewal_handler(callback: types.CallbackQuery, state: FSMContext):
    await state.clear()
    await callback.message.edit_text(
        "🔄 *تمدید سرویس*\n\n"
        "لطفاً توضیح تمدیدت رو بفرست.\n"
        "مثلاً:\n"
        "`تمدید پلن یک‌ماهه`",
        reply_markup=back_menu(),
    )
    await state.set_state(BotStates.waiting_for_renewal_text)
    await callback.answer()


@dp.message(BotStates.waiting_for_renewal_text)
async def renewal_text_handler(message: Message, state: FSMContext):
    renewal_info = message.text.strip() if message.text else "بدون توضیح"
    order_type = f"تمدید سرویس - {renewal_info}"
    order_code = create_order(message.from_user, order_type, "نامشخص", renewal_info)

    text = (
        f"✅ *{order_type}*\n\n"
        f"🧾 کد سفارش: `{order_code}`\n\n"
        "💳 اطلاعات پرداخت:\n"
        f"`{CARD_NUMBER}`\n"
        f"👤 به نام: *{CARD_HOLDER}*\n\n"
        "بعد از پرداخت، رسیدت رو بفرست تا تمدیدت پیگیری بشه 🌟"
    )
    await message.answer(text, reply_markup=main_menu())
    await state.clear()


# =========================
# Receipt (جریان دو مرحله‌ای)
# =========================
@dp.callback_query(F.data == "send_receipt")
async def send_receipt_handler(callback: types.CallbackQuery, state: FSMContext):
    await state.clear()
    await callback.message.edit_text(
        "🧾 *ارسال رسید پرداخت*\n\n"
        "برای پیگیری دقیق، اول *کد سفارش* خودت رو بفرست.\n"
        "مثال: `ORD-1A2B3C4D`\n\n"
        "اگر کد سفارش رو نداری، با پشتیبانی در ارتباط باش.",
        reply_markup=back_menu(),
    )
    await state.set_state(BotStates.waiting_for_receipt_order_code)
    await callback.answer()


@dp.message(BotStates.waiting_for_receipt_order_code)
async def receipt_order_code_handler(message: Message, state: FSMContext):
    code = message.text.strip() if message.text else ""
    order = find_order(code)

    if not order:
        await message.answer(
            "❌ سفارشی با این کد پیدا نشد.\n"
            "لطفاً کد را دقیق بررسی کن یا با پشتیبانی در ارتباط باش.",
            reply_markup=back_menu(),
        )
        return

    # فقط اجازه ارسال رسید برای سفارش‌هایی که هنوز تکمیل نشدن
    if order["status"] in ("تکمیل شده", "رد شده"):
        await message.answer(
            f"⚠️ این سفارش قبلاً *{order['status']}* شده.\n"
            "نیازی به ارسال رسید جدید نیست.",
            reply_markup=main_menu(),
        )
        await state.clear()
        return

    await state.update_data(order_code=order["order_code"], order_type=order["order_type"])

    await message.answer(
        f"✅ سفارش پیدا شد!\n"
        f"🧾 کد سفارش: `{order['order_code']}`\n"
        f"📦 نوع: *{order['order_type']}*\n\n"
        "حالا *عکس رسید پرداخت* رو ارسال کن 📸",
        reply_markup=back_menu(),
    )
    await state.set_state(BotStates.waiting_for_receipt_photo)


@dp.message(BotStates.waiting_for_receipt_photo, F.photo)
async def receipt_photo_handler(message: Message, state: FSMContext):
    data = await state.get_data()
    order_code = data.get("order_code", "نامشخص")
    order_type = data.get("order_type", "نامشخص")
    user = message.from_user

    order = update_order_receipt(order_code) if order_code != "نامشخص" else None
    upsert_customer(user, order_type)

    caption = (
        "🧾 *رسید پرداخت جدید*\n\n"
        f"👤 نام: {user.full_name}\n"
        f"🆔 آیدی عددی: `{user.id}`\n"
        f"🔗 یوزرنیم: @{user.username if user.username else 'ندارد'}\n"
        f"📦 نوع سفارش: *{order_type}*\n"
        f"🧾 کد سفارش: `{order_code}`\n\n"
        "لطفاً بررسی شود."
    )

    await bot.send_photo(
        chat_id=ADMIN_ID,
        photo=message.photo[-1].file_id,
        caption=caption,
        reply_markup=admin_receipt_actions(order_code, user.id),
    )

    status_text = "رسید ارسال شد" if order else "رسید ثبت شد"
    await message.answer(
        f"✅ {status_text}\n\n"
        f"🧾 کد سفارش شما: `{order_code}`\n"
        "رسیدت برای بررسی فرستاده شد و به‌زودی پیگیری میشه 🤝🌹",
        reply_markup=main_menu(),
    )
    await state.clear()


@dp.message(BotStates.waiting_for_receipt_photo)
async def receipt_invalid_handler(message: Message):
    await message.answer("⚠️ لطفاً فقط *عکس رسید پرداخت* رو ارسال کن 📸")


# =========================
# Inquiry
# =========================
@dp.callback_query(F.data == "inquiry")
async def inquiry_handler(callback: types.CallbackQuery, state: FSMContext):
    await callback.message.edit_text(
        "🔎 *استعلام سفارش*\n\n"
        "لطفاً کد سفارش خودت رو بفرست.\n"
        "مثال: `ORD-1A2B3C4D`",
        reply_markup=back_menu(),
    )
    await state.set_state(BotStates.waiting_for_inquiry_code)
    await callback.answer()


@dp.message(BotStates.waiting_for_inquiry_code)
async def inquiry_code_handler(message: Message, state: FSMContext):
    code = message.text.strip() if message.text else ""
    order = find_order(code)

    if not order:
        await message.answer(
            "❌ سفارشی با این کد پیدا نشد.\n"
            "لطفاً کد را دقیق بررسی کن یا با پشتیبانی در ارتباط باش.",
            reply_markup=main_menu(),
        )
        await state.clear()
        return

    text = (
        "📦 *وضعیت سفارش*\n\n"
        f"🧾 کد سفارش: `{order['order_code']}`\n"
        f"📌 نوع سفارش: *{order['order_type']}*\n"
        f"💵 مبلغ: *{order['amount']}*\n"
        f"📍 وضعیت: *{order['status']}*\n"
        f"🕒 زمان ثبت: `{order['created_at']}`\n\n"
        "اگر سوالی داشتی از بخش پشتیبانی پیام بده 🌟"
    )
    await message.answer(text, reply_markup=main_menu())
    await state.clear()


# =========================
# Guide / Rules / Support
# =========================
@dp.callback_query(F.data == "guide")
async def guide_handler(callback: types.CallbackQuery):
    await callback.message.edit_text(
        "📚 *آموزش فعال‌سازی*\n\n"
        "1️⃣ برنامه موردنیاز را نصب کن\n"
        "2️⃣ اطلاعات سرویس را وارد کن\n"
        "3️⃣ تنظیمات لازم را انجام بده\n"
        "4️⃣ سرویس را فعال کن ✅\n\n"
        "اگر خواستی بعداً متن اختصاصی‌تر هم برات می‌چینم 😉",
        reply_markup=back_menu(),
    )
    await callback.answer()


@dp.callback_query(F.data == "rules")
async def rules_handler(callback: types.CallbackQuery):
    await callback.message.edit_text(
        "📜 *قوانین خرید*\n\n"
        "1️⃣ قبل از پرداخت، پلن را با دقت انتخاب کن.\n"
        "2️⃣ بعد از پرداخت، رسید معتبر بفرست.\n"
        "3️⃣ پاسخگویی طبق ساعات اعلام‌شده انجام می‌شود.\n"
        "4️⃣ برای هر پیگیری، کد سفارش را نگه دار.\n\n"
        "ممنون که با حوصله همراهی می‌کنی 🌹",
        reply_markup=back_menu(),
    )
    await callback.answer()


@dp.callback_query(F.data == "support")
async def support_handler(callback: types.CallbackQuery):
    await callback.message.edit_text(
        "☎️ *پشتیبانی*\n\n"
        f"🆔 آیدی پشتیبانی: {SUPPORT_ID}\n\n"
        "🕘 ساعات پاسخگویی:\n"
        "*9 صبح تا 11 شب*\n\n"
        "اگر کمی دیر جواب دادی، نگران نباش؛ حتماً پیگیری میشه 🌟",
        reply_markup=back_menu(),
    )
    await callback.answer()


# =========================
# Admin: تایید و تحویل سفارش
# =========================
@dp.callback_query(F.data.startswith("approve|"))
async def approve_order_handler(callback: types.CallbackQuery, state: FSMContext):
    if callback.from_user.id != ADMIN_ID:
        await callback.answer("دسترسی ندارید.", show_alert=True)
        return

    _, order_code, user_id = callback.data.split("|")
    user_id = int(user_id)

    await state.set_state(BotStates.waiting_for_admin_delivery)
    await state.update_data(target_user_id=user_id, order_code=order_code)

    await callback.message.answer(
        f"✅ سفارش `{order_code}` انتخاب شد.\n\n"
        "حالا پیام نهایی رو بفرست (متن، لینک، کانفیگ، عکس، ویدیو، فایل - هر چیزی) 📨\n"
        "همون پیام مستقیم برای کاربر ارسال میشه."
    )
    await callback.answer("منتظر دریافت پیام تحویل...")


@dp.message(BotStates.waiting_for_admin_delivery)
async def admin_delivery_handler(message: Message, state: FSMContext):
    if message.from_user.id != ADMIN_ID:
        await message.answer("⛔️ فقط ادمین می‌تواند این بخش را استفاده کند.")
        return

    data = await state.get_data()
    user_id = data.get("target_user_id")
    order_code = data.get("order_code")

    if not user_id or not order_code:
        await message.answer("❌ اطلاعات سفارش پیدا نشد.")
        await state.clear()
        return

    # گرفتن متن پاسخ برای ذخیره در دیتابیس
    delivery_text = message.text or message.caption or "محتوای پیام (عکس/ویدیو/فایل)"

    try:
        # کپی کردن هر نوع پیام (متن، عکس، ویدیو، فایل، صدا و ...) به کاربر
        await message.copy_to(
            chat_id=user_id,
            caption=(
                "🎉 *سفارش شما تایید شد*\n\n"
                f"🧾 کد سفارش: `{order_code}`\n\n"
                + (message.caption or "" if message.caption else "")
            ) if (message.photo or message.video or message.document) else None,
        )

        # اگه فقط متن بود، جداگانه پیام هدر بفرست
        if message.text:
            await bot.send_message(
                user_id,
                "🎉 *سفارش شما تایید شد*\n\n"
                f"🧾 کد سفارش: `{order_code}`\n\n"
                f"{message.text}\n\n"
                "ممنون از خریدت 🌹",
            )

        update_order_status(order_code, "تکمیل شده", delivery_text)

        await message.answer(
            f"✅ پیام تحویل برای کاربر ارسال شد.\n"
            f"🧾 کد سفارش: `{order_code}`\n"
            f"📍 وضعیت: *تکمیل شده*"
        )
    except Exception as e:
        await message.answer(f"❌ ارسال به کاربر ناموفق بود:\n`{e}`")

    await state.clear()


# =========================
# Admin: رد سفارش
# =========================
@dp.callback_query(F.data.startswith("reject|"))
async def reject_order_handler(callback: types.CallbackQuery, state: FSMContext):
    if callback.from_user.id != ADMIN_ID:
        await callback.answer("دسترسی ندارید.", show_alert=True)
        return

    _, order_code, user_id = callback.data.split("|")
    user_id = int(user_id)

    # اگه ادمین توی state تحویل بود، پاکش کن
    await state.clear()

    update_order_status(order_code, "رد شده")

    try:
        await bot.send_message(
            user_id,
            "❌ *سفارش شما رد شد*\n\n"
            f"🧾 کد سفارش: `{order_code}`\n"
            "اگر فکر می‌کنی اشتباهی شده، با پشتیبانی در ارتباط باش.",
        )
    except Exception:
        pass

    await callback.message.answer(f"❌ سفارش `{order_code}` رد شد و به کاربر اطلاع داده شد.")
    await callback.answer("سفارش رد شد.")


# =========================
# Admin panel
# =========================
@dp.message(Command("admin"))
async def admin_panel_handler(message: Message, state: FSMContext):
    if message.from_user.id != ADMIN_ID:
        await message.answer("⛔️ شما به این بخش دسترسی نداری.")
        return

    await state.clear()
    await message.answer(
        "🛠 *پنل ادمین*\n\nاز گزینه‌های زیر استفاده کن 👇",
        reply_markup=admin_menu(),
    )


@dp.callback_query(F.data == "admin_count")
async def admin_count_handler(callback: types.CallbackQuery):
    if callback.from_user.id != ADMIN_ID:
        await callback.answer("دسترسی ندارید.", show_alert=True)
        return

    await callback.message.edit_text(
        f"👥 *تعداد مشتری‌ها:* {get_customer_count()}",
        reply_markup=admin_menu(),
    )
    await callback.answer()


@dp.callback_query(F.data == "admin_orders_count")
async def admin_orders_count_handler(callback: types.CallbackQuery):
    if callback.from_user.id != ADMIN_ID:
        await callback.answer("دسترسی ندارید.", show_alert=True)
        return

    await callback.message.edit_text(
        f"📦 *تعداد سفارش‌ها:* {get_orders_count()}",
        reply_markup=admin_menu(),
    )
    await callback.answer()


@dp.callback_query(F.data == "admin_list")
async def admin_list_handler(callback: types.CallbackQuery):
    if callback.from_user.id != ADMIN_ID:
        await callback.answer("دسترسی ندارید.", show_alert=True)
        return

    customers = load_customers()
    if not customers:
        await callback.message.edit_text("📄 هنوز مشتری ثبت نشده.", reply_markup=admin_menu())
        await callback.answer()
        return

    lines = ["📄 *لیست مشتری‌ها*\n"]
    for item in customers[:20]:
        username = f"@{item['username']}" if item.get("username") else "ندارد"
        lines.append(
            f"👤 {item.get('full_name', 'بدون نام')}\n"
            f"🆔 `{item.get('user_id')}`\n"
            f"🔗 {username}\n"
            f"📦 {item.get('last_order_type', 'نامشخص')}\n"
            f"🕒 {item.get('last_seen', '-')}\n"
        )

    await callback.message.edit_text("\n".join(lines), reply_markup=admin_menu())
    await callback.answer()


@dp.callback_query(F.data == "admin_broadcast")
async def admin_broadcast_handler(callback: types.CallbackQuery, state: FSMContext):
    if callback.from_user.id != ADMIN_ID:
        await callback.answer("دسترسی ندارید.", show_alert=True)
        return

    await callback.message.edit_text(
        "📬 *ارسال پیام همگانی*\n\n"
        "لطفاً متن پیام را بفرست تا برای همه مشتری‌ها ارسال شود.",
        reply_markup=admin_menu(),
    )
    await state.set_state(BotStates.waiting_for_broadcast)
    await callback.answer()


@dp.message(BotStates.waiting_for_broadcast)
async def broadcast_message_handler(message: Message, state: FSMContext):
    if message.from_user.id != ADMIN_ID:
        await message.answer("⛔️ دسترسی ندارید.")
        return

    customers = load_customers()
    sent = 0
    failed = 0

    for customer in customers:
        try:
            await bot.send_message(customer["user_id"], f"📢 *پیام جدید*\n\n{message.text}")
            sent += 1
            await asyncio.sleep(0.05)  # جلوگیری از flood
        except Exception:
            failed += 1
            continue

    await message.answer(
        f"✅ پیام همگانی ارسال شد.\n"
        f"📨 موفق: {sent} نفر\n"
        f"❌ ناموفق: {failed} نفر",
        reply_markup=admin_menu(),
    )
    await state.clear()


# =========================
# Main
# =========================
async def main():
    print("Bot is running...")
    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())