import telebot
from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton, ForceReply
import sqlite3
import json
import threading
import time
from datetime import datetime, timedelta
import random
import string
import os
import shutil
from collections import defaultdict

# ========== تنظیمات ==========
TOKEN = "8913862233:AAHDoKGgR0f7Ff3b2Y8FGpExorIl__pH4Do"
ADMIN_ID = 6037513696
CHANNEL_USERNAME = "shetaban_Net"  # بدون @
REQUIRED_CHANNEL = "@shetaban_Net"  # با @ برای بررسی

bot = telebot.TeleBot(TOKEN)

CARD_NUMBER = "6219861419054308"
CARD_OWNER = "عرفان زمانلو"
BANK_NAME = "بلو بانک"

# محدودیت درخواست
RATE_LIMIT = defaultdict(list)

# قیمت‌ها
PRICES = {
    "2geek": {"price": 220000, "gb": 1, "days": 30, "icon": "⭐️", "emoji": "🥉"},
    "3geek": {"price": 330000, "gb": 3, "days": 30, "icon": "⭐️⭐️", "emoji": "🥈"},
    "5geek": {"price": 550000, "gb": 5, "days": 30, "icon": "💎", "emoji": "🥇"},
    "10geek": {"price": 1100000, "gb": 10, "days": 30, "icon": "👑", "emoji": "💎"}
}

PLAN_NAMES = {
    "2geek": "کانفیگ 2 گیگ",
    "3geek": "کانفیگ 3 گیگ",
    "5geek": "کانفیگ 5 گیگ",
    "10geek": "کانفیگ 10 گیگ"
}

WELCOME_TEXT = """✨ به فروشگاه حرفه‌ای کانفیگ خوش آمدید ✨

سلام {first_name} عزیز! 👋

⚡ سرویس‌های با کیفیت بالا
🛡 پشتیبانی ۲۴ ساعته
🚀 سرعت فوق العاده

━━━━━━━━━━━━━━━━━━━
💰 پکیج‌های ویژه:
⭐️ 2 گیگ - 220,000 تومان
⭐️⭐️ 3 گیگ - 330,000 تومان
💎 5 گیگ - 550,000 تومان
👑 10 گیگ - 1,100,000 تومان
━━━━━━━━━━━━━━━━━━━

📌 برای شروع، روی دکمه 🛍️ خرید سرویس بزنید

📢 کانال اطلاع‌رسانی: @{channel}
"""

JOIN_REQUIRED_TEXT = """🔒 دسترسی به ربات نیازمند عضویت در کانال ماست!

━━━━━━━━━━━━━━━━━━━
📢 لطفاً ابتدا در کانال زیر عضو شوید:

👉 {channel}

بعد از عضویت، روی دکمه 🔄 بررسی عضویت کلیک کنید.
━━━━━━━━━━━━━━━━━━━
"""

# ========== دیتابیس ==========
def init_db():
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    
    c.execute('''CREATE TABLE IF NOT EXISTS users (
        user_id TEXT PRIMARY KEY,
        username TEXT,
        first_name TEXT,
        join_date TEXT,
        total_spent INTEGER DEFAULT 0,
        total_orders INTEGER DEFAULT 0,
        is_blocked INTEGER DEFAULT 0,
        last_active TEXT
    )''')
    
    c.execute('''CREATE TABLE IF NOT EXISTS orders (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        order_number TEXT UNIQUE,
        user_id TEXT,
        plan TEXT,
        price INTEGER,
        status TEXT,
        receipt_photo TEXT,
        receipt_time TEXT,
        config_link TEXT,
        expiry_date TEXT,
        created_at TEXT,
        confirmed_at TEXT,
        confirmed_by TEXT
    )''')
    
    c.execute('''CREATE TABLE IF NOT EXISTS settings (
        key TEXT PRIMARY KEY,
        value TEXT
    )''')
    
    c.execute('''CREATE TABLE IF NOT EXISTS logs (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        user_id TEXT,
        action TEXT,
        details TEXT,
        created_at TEXT
    )''')
    
    c.execute('''CREATE TABLE IF NOT EXISTS support_tickets (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        user_id TEXT,
        message TEXT,
        admin_reply TEXT,
        status TEXT,
        created_at TEXT,
        replied_at TEXT
    )''')
    
    c.execute("CREATE INDEX IF NOT EXISTS idx_orders_user_id ON orders(user_id)")
    c.execute("CREATE INDEX IF NOT EXISTS idx_orders_status ON orders(status)")
    
    c.execute("INSERT OR IGNORE INTO settings (key, value) VALUES ('maintenance', '0')")
    c.execute("INSERT OR IGNORE INTO settings (key, value) VALUES ('daily_report', '1')")
    
    conn.commit()
    conn.close()

init_db()

# ========== کش دیتابیس ==========
cache_stats = {"data": None, "time": 0}

def get_stats():
    now = time.time()
    if cache_stats["data"] and (now - cache_stats["time"]) < 300:
        return cache_stats["data"]
    
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    
    today = datetime.now().date().isoformat()
    week_ago = (datetime.now() - timedelta(days=7)).date().isoformat()
    month_ago = (datetime.now() - timedelta(days=30)).date().isoformat()
    yesterday = (datetime.now() - timedelta(days=1)).date().isoformat()
    
    c.execute("SELECT COALESCE(SUM(price), 0) FROM orders WHERE status = 'confirmed' AND DATE(confirmed_at) = ?", (today,))
    today_sales = c.fetchone()[0]

    c.execute("SELECT COUNT(*) FROM orders WHERE status = 'confirmed' AND DATE(confirmed_at) = ?", (today,))
    today_orders = c.fetchone()[0]
    
    c.execute("SELECT COALESCE(SUM(price), 0) FROM orders WHERE status = 'confirmed' AND DATE(confirmed_at) = ?", (yesterday,))
    yesterday_sales = c.fetchone()[0]
    
    c.execute("SELECT COALESCE(SUM(price), 0) FROM orders WHERE status = 'confirmed' AND DATE(confirmed_at) >= ?", (week_ago,))
    week_sales = c.fetchone()[0]
    
    c.execute("SELECT COALESCE(SUM(price), 0) FROM orders WHERE status = 'confirmed' AND DATE(confirmed_at) >= ?", (month_ago,))
    month_sales = c.fetchone()[0]
    
    c.execute("SELECT COUNT(*) FROM users WHERE is_blocked = 0")
    total_users = c.fetchone()[0]
    
    c.execute("SELECT COUNT(*) FROM orders WHERE status = 'waiting_confirm'")
    pending_orders = c.fetchone()[0]
    
    c.execute("SELECT COALESCE(SUM(price), 0) FROM orders WHERE status = 'confirmed'")
    total_sales = c.fetchone()[0]
    c.execute("SELECT COUNT(*) FROM orders WHERE status = 'confirmed'")
    total_orders = c.fetchone()[0]
    
    conn.close()
    
    sales_growth = 0
    if yesterday_sales > 0:
        sales_growth = ((today_sales - yesterday_sales) / yesterday_sales) * 100
    
    stats = {
        "today_sales": today_sales,
        "today_orders": today_orders,
        "yesterday_sales": yesterday_sales,
        "sales_growth": sales_growth,
        "week_sales": week_sales,
        "month_sales": month_sales,
        "total_users": total_users,
        "total_orders": total_orders,
        "total_sales": total_sales,
        "pending_orders": pending_orders
    }
    
    cache_stats["data"] = stats
    cache_stats["time"] = now
    return stats

def invalidate_cache():
    cache_stats["data"] = None

# ========== توابع کمکی ==========
def is_rate_limited(user_id):
    now = time.time()
    RATE_LIMIT[user_id] = [t for t in RATE_LIMIT[user_id] if now - t < 2]
    if len(RATE_LIMIT[user_id]) >= 5:
        return True
    RATE_LIMIT[user_id].append(now)
    return False

def is_blocked(user_id):
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("SELECT is_blocked FROM users WHERE user_id = ?", (str(user_id),))
    result = c.fetchone()
    conn.close()
    return result and result[0] == 1

def block_user(user_id, reason=""):
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("UPDATE users SET is_blocked = 1 WHERE user_id = ?", (str(user_id),))
    conn.commit()
    conn.close()
    add_log(user_id, "blocked", reason)
    invalidate_cache()
    try:
        bot.send_message(user_id, f"🚫 شما توسط ادمین مسدود شدید.\nدلیل: {reason}")
    except:
        pass
    
    # ارسال پیام به ادمین با گزینه رفع بلاک
    admin_msg = f"""🚫 کاربر مسدود شد!

━━━━━━━━━━━━━━━━━━━
🆔 آیدی کاربر: {user_id}
📝 دلیل: {reason}
⏰ زمان: {datetime.now().strftime('%Y/%m/%d %H:%M:%S')}
━━━━━━━━━━━━━━━━━━━
"""
    bot.send_message(ADMIN_ID, admin_msg, reply_markup=unblock_button(user_id))

def unblock_user(user_id):
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("UPDATE users SET is_blocked = 0 WHERE user_id = ?", (str(user_id),))
    conn.commit()
    conn.close()
    add_log(user_id, "unblocked", "")
    invalidate_cache()
    try:
        bot.send_message(user_id, "✅ مسدودیت شما لغو شد.")
    except:
        pass
    
    # ارسال پیام تایید به ادمین
    bot.send_message(ADMIN_ID, f"✅ کاربر {user_id} از مسدودیت خارج شد.")

def add_log(user_id, action, details=""):
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("INSERT INTO logs (user_id, action, details, created_at) VALUES (?, ?, ?, ?)",
              (str(user_id), action, details, datetime.now().isoformat()))
    conn.commit()
    conn.close()

def generate_order_number():
    return datetime.now().strftime("%Y%m%d%H%M%S") + ''.join(random.choices(string.digits, k=4))

def add_user(user_id, username, first_name):
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("SELECT * FROM users WHERE user_id = ?", (str(user_id),))
    if not c.fetchone():
        c.execute("INSERT INTO users (user_id, username, first_name, join_date, last_active) VALUES (?, ?, ?, ?, ?)",
                  (str(user_id), username, first_name, datetime.now().isoformat(), datetime.now().isoformat()))
        conn.commit()
        add_log(user_id, "new_user", "ثبت نام")
    else:
        c.execute("UPDATE users SET last_active = ? WHERE user_id = ?", (datetime.now().isoformat(), str(user_id)))
        conn.commit()
    conn.close()

def get_all_users():
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("SELECT user_id FROM users WHERE is_blocked = 0")
    users = c.fetchall()
    conn.close()
    return [u[0] for u in users]

def get_setting(key, default="0"):
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("SELECT value FROM settings WHERE key = ?", (key,))
    result = c.fetchone()
    conn.close()
    return result[0] if result else default

# ========== جوین اجباری ==========
def is_member(user_id):
    try:
        member = bot.get_chat_member(REQUIRED_CHANNEL, user_id)
        return member.status in ['member', 'administrator', 'creator']
    except:
        return False

def check_join_required(func):
    def wrapper(message):
        user_id = message.from_user.id
        if user_id == ADMIN_ID:
            return func(message)
        if not is_member(user_id):
            bot.send_message(message.chat.id, JOIN_REQUIRED_TEXT.format(channel=REQUIRED_CHANNEL), 
                           reply_markup=join_button())
            return
        return func(message)
    return wrapper

def check_join_required_callback(func):
    def wrapper(call):
        user_id = call.from_user.id
        if user_id == ADMIN_ID:
            return func(call)
        if not is_member(user_id):
            bot.answer_callback_query(call.id, "❌ ابتدا باید در کانال عضو شوید!", show_alert=True)
            bot.edit_message_text(JOIN_REQUIRED_TEXT.format(channel=REQUIRED_CHANNEL), 
                                 call.message.chat.id, call.message.message_id,
                                 reply_markup=join_button())
            return
        return func(call)
    return wrapper

def join_button():
    keyboard = InlineKeyboardMarkup()
    btn = InlineKeyboardButton("📢 عضویت در کانال", url=f"https://t.me/{CHANNEL_USERNAME}")
    check_btn = InlineKeyboardButton("🔄 بررسی عضویت", callback_data="check_join")
    keyboard.add(btn)
    keyboard.add(check_btn)
    return keyboard

# ========== وضعیت انتظار ==========
admin_awaiting_config = {}  # {admin_id: order_number}
admin_awaiting_reply = {}   # {admin_id: user_id} برای پاسخ به پشتیبانی
admin_broadcast_mode = False  # حالت ارسال همگانی

# ========== کیبوردها ==========
def main_menu():
    keyboard = InlineKeyboardMarkup(row_width=2)
    btn1 = InlineKeyboardButton("🛍️ خرید سرویس", callback_data="buy")
    btn2 = InlineKeyboardButton("👤 حساب من", callback_data="account")
    btn3 = InlineKeyboardButton("📞 پشتیبانی", callback_data="support")
    btn4 = InlineKeyboardButton("ℹ️ راهنما", callback_data="help")
    btn5 = InlineKeyboardButton("📢 کانال اطلاع‌رسانی", url=f"https://t.me/{CHANNEL_USERNAME}")
    keyboard.add(btn1, btn2, btn3, btn4, btn5)
    return keyboard

def buy_menu():
    keyboard = InlineKeyboardMarkup(row_width=1)
    for plan_id, plan in PRICES.items():
        btn = InlineKeyboardButton(
            f"{plan['emoji']} {PLAN_NAMES[plan_id]} - {plan['price']:,} تومان {plan['icon']}",
            callback_data=f"buy_{plan_id}"
        )
        keyboard.add(btn)
    keyboard.add(InlineKeyboardButton("🔙 بازگشت", callback_data="back"))
    return keyboard

def payment_info(plan_name, price, order_number):
    text = f"""✅ {plan_name} - {price:,} تومان

━━━━━━━━━━━━━━━━━━━
🆔 شماره سفارش: {order_number}
━━━━━━━━━━━━━━━━━━━

💳 اطلاعات واریز:

🏦 شماره کارت:
{CARD_NUMBER}

👤 به نام: {CARD_OWNER}
🏛 بانک: {BANK_NAME}

━━━━━━━━━━━━━━━━━━━
📌 نکات مهم:
• دقیقاً مبلغ {price:,} تومان واریز کنید
• بعد از واریز، عکس رسید را بفرستید
• پس از تایید، کانفیگ ارسال می‌شود
━━━━━━━━━━━━━━━━━━━

🙏 با تشکر از اعتماد شما
"""
    return text

def admin_menu():
    keyboard = InlineKeyboardMarkup(row_width=2)
    btn1 = InlineKeyboardButton("📊 آمار فروش", callback_data="admin_stats")
    btn2 = InlineKeyboardButton("📦 سفارشات", callback_data="admin_orders")
    btn3 = InlineKeyboardButton("👥 کاربران", callback_data="admin_users")
    btn4 = InlineKeyboardButton("📢 ارسال همگانی", callback_data="admin_broadcast")
    btn5 = InlineKeyboardButton("📋 لاگ‌ها", callback_data="admin_logs")
    btn6 = InlineKeyboardButton("💾 پشتیبان", callback_data="admin_backup")
    btn7 = InlineKeyboardButton("⚙️ تنظیمات", callback_data="admin_settings")
    btn8 = InlineKeyboardButton("🔙 بازگشت", callback_data="back")
    keyboard.add(btn1, btn2, btn3, btn4, btn5, btn6, btn7, btn8)
    return keyboard

def orders_menu(page=0):
    keyboard = InlineKeyboardMarkup(row_width=2)
    
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("SELECT order_number, user_id, plan FROM orders WHERE status = 'waiting_confirm' ORDER BY created_at DESC LIMIT 10 OFFSET ?", (page * 10,))
    orders = c.fetchall()
    conn.close()
    
    for order in orders:
        order_num, user_id, plan = order
        btn = InlineKeyboardButton(f"🆔 {order_num} | {user_id[:8]}... | {PLAN_NAMES[plan][:10]}", callback_data=f"order_{order_num}")
        keyboard.add(btn)
    
    if page > 0:
        keyboard.add(InlineKeyboardButton("⬅️ قبلی", callback_data=f"orders_page_{page-1}"))
    if len(orders) == 10:
        keyboard.add(InlineKeyboardButton("بعدی ➡️", callback_data=f"orders_page_{page+1}"))
    
    keyboard.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_back"))
    return keyboard

# دکمه‌های تأیید / رد / بلاک برای ادمین
def admin_order_buttons(order_number, user_id):
    keyboard = InlineKeyboardMarkup(row_width=2)
    confirm_btn = InlineKeyboardButton("✅ تایید سفارش", callback_data=f"admin_confirm_{order_number}")
    reject_btn = InlineKeyboardButton("❌ عدم تایید", callback_data=f"admin_reject_{order_number}")
    block_btn = InlineKeyboardButton("🚫 بلاک کاربر", callback_data=f"admin_block_{user_id}_{order_number}")
    keyboard.add(confirm_btn, reject_btn)
    keyboard.add(block_btn)
    return keyboard

# دکمه پاسخ به پشتیبانی + بلاک
def support_reply_button(user_id):
    keyboard = InlineKeyboardMarkup(row_width=2)
    reply_btn = InlineKeyboardButton("💬 پاسخ به کاربر", callback_data=f"reply_support_{user_id}")
    block_btn = InlineKeyboardButton("🚫 بلاک کاربر", callback_data=f"support_block_{user_id}")
    keyboard.add(reply_btn, block_btn)
    return keyboard

# دکمه رفع بلاک
def unblock_button(user_id):
    keyboard = InlineKeyboardMarkup()
    btn = InlineKeyboardButton("🔓 رفع بلاک", callback_data=f"unblock_user_{user_id}")
    keyboard.add(btn)
    return keyboard

# دکمه تایید ارسال همگانی
def broadcast_confirm_button():
    keyboard = InlineKeyboardMarkup(row_width=2)
    confirm_btn = InlineKeyboardButton("✅ تایید و ارسال", callback_data="broadcast_confirm")
    cancel_btn = InlineKeyboardButton("❌ لغو", callback_data="broadcast_cancel")
    keyboard.add(confirm_btn, cancel_btn)
    return keyboard

# ========== دکوراتورها ==========
def check_blocked(func):
    def wrapper(message):
        if is_rate_limited(message.from_user.id):
            bot.reply_to(message, "⏳ لطفاً کمی صبر کنید...")
            return
        if is_blocked(message.from_user.id):
            bot.reply_to(message, "🚫 شما توسط ادمین مسدود شده‌اید.")
            return
        return func(message)
    return wrapper

def check_blocked_callback(func):
    def wrapper(call):
        if is_blocked(call.from_user.id):
            bot.answer_callback_query(call.id, "🚫 شما مسدود شده‌اید!", show_alert=True)
            return
        return func(call)
    return wrapper

# ========== هندلرها ==========
@bot.message_handler(commands=['start'])
@check_blocked
def send_welcome(message):
    user_id = message.from_user.id
    username = message.from_user.username or ""
    first_name = message.from_user.first_name
    
    add_user(user_id, username, first_name)
    
    # بررسی جوین اجباری
    if not is_member(user_id) and user_id != ADMIN_ID:
        bot.send_message(message.chat.id, JOIN_REQUIRED_TEXT.format(channel=REQUIRED_CHANNEL), 
                       reply_markup=join_button())
        return
    
    text = WELCOME_TEXT.format(first_name=first_name, channel=CHANNEL_USERNAME)
    bot.send_message(message.chat.id, text, reply_markup=main_menu())

@bot.message_handler(commands=['admin'])
def admin_panel(message):
    if message.from_user.id != ADMIN_ID:
        bot.reply_to(message, "❌ شما دسترسی ندارید.")
        return
    
    stats = get_stats()
    growth_emoji = "📈" if stats['sales_growth'] >= 0 else "📉"
    
    text = f"""🔧 پنل مدیریت پیشرفته

━━━━━━━━━━━━━━━━━━━
📊 آمار لحظه‌ای
━━━━━━━━━━━━━━━━━━━
💰 فروش امروز: {stats['today_sales']:,} تومان
📦 سفارش امروز: {stats['today_orders']}
{growth_emoji} نسبت به دیروز: {abs(stats['sales_growth']):.1f}%
━━━━━━━━━━━━━━━━━━━
📆 فروش هفته: {stats['week_sales']:,} تومان
📅 فروش ماه: {stats['month_sales']:,} تومان
━━━━━━━━━━━━━━━━━━━
💰 کل فروش: {stats['total_sales']:,} تومان
📦 کل سفارش: {stats['total_orders']}
👥 کاربران: {stats['total_users']}
⏳ در انتظار تایید: {stats['pending_orders']}
━━━━━━━━━━━━━━━━━━━

📌 لطفاً یکی از گزینه‌ها را انتخاب کنید:"""
    
    bot.send_message(message.chat.id, text, reply_markup=admin_menu())

@bot.message_handler(commands=['confirm'])
def confirm_order_cmd(message):
    if message.from_user.id != ADMIN_ID:
        bot.reply_to(message, "❌ شما دسترسی ندارید.")
        return
    
    try:
        parts = message.text.split()
        if len(parts) < 2:
            bot.reply_to(message, "⚠️ فرمت: /confirm order_number")
            return
        
        order_number = parts[1]
        admin_awaiting_config[message.from_user.id] = order_number
        bot.reply_to(message, f"🔗 لطفاً متن کانفیگ را برای سفارش {order_number} ارسال کنید.")
    except Exception as e:
        bot.reply_to(message, f"❌ خطا: {e}")

@bot.message_handler(commands=['block'])
def block_user_cmd(message):
    if message.from_user.id != ADMIN_ID:
        bot.reply_to(message, "❌ شما دسترسی ندارید.")
        return
    
    try:
        parts = message.text.split()
        if len(parts) < 2:
            bot.reply_to(message, "⚠️ فرمت: /block 123456789 [دلیل]")
            return
        
        user_id = parts[1]
        reason = " ".join(parts[2:]) if len(parts) > 2 else "ندارد"
        
        block_user(user_id, reason)
        bot.reply_to(message, f"✅ کاربر {user_id} مسدود شد.\nدلیل: {reason}")
    except:
        bot.reply_to(message, "❌ خطا!")

@bot.message_handler(commands=['unblock'])
def unblock_user_cmd(message):
    if message.from_user.id != ADMIN_ID:
        bot.reply_to(message, "❌ شما دسترسی ندارید.")
        return
    
    try:
        parts = message.text.split()
        if len(parts) < 2:
            bot.reply_to(message, "⚠️ فرمت: /unblock 123456789")
            return
        
        user_id = parts[1]
        unblock_user(user_id)
        bot.reply_to(message, f"✅ کاربر {user_id} از مسدودیت خارج شد.")
    except:
        bot.reply_to(message, "❌ خطا!")

@bot.message_handler(commands=['cancel'])
def cancel_admin_await(message):
    global admin_broadcast_mode
    if message.from_user.id != ADMIN_ID:
        return
    if message.from_user.id in admin_awaiting_config:
        del admin_awaiting_config[message.from_user.id]
        bot.reply_to(message, "❌ عملیات تایید لغو شد.")
    elif message.from_user.id in admin_awaiting_reply:
        del admin_awaiting_reply[message.from_user.id]
        bot.reply_to(message, "❌ عملیات پاسخ لغو شد.")
    elif admin_broadcast_mode:
        admin_broadcast_mode = False
        bot.reply_to(message, "❌ ارسال همگانی لغو شد.")
    else:
        bot.reply_to(message, "هیچ عملیات در انتظاری وجود ندارد.")

# هندلر دریافت رسید
@bot.message_handler(content_types=['photo'])
@check_blocked
@check_join_required
def handle_photo(message):
    user_id = str(message.from_user.id)
    
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("SELECT order_number, plan, price FROM orders WHERE user_id = ? AND status = 'waiting' ORDER BY created_at DESC LIMIT 1", (user_id,))
    order = c.fetchone()
    conn.close()
    
    if not order:
        bot.reply_to(message, "❌ سفارش فعالی ندارید.\n\nبرای خرید روی دکمه 🛍️ خرید سرویس بزنید.")
        return
    
    order_number, plan, price = order
    file_id = message.photo[-1].file_id
    
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("UPDATE orders SET receipt_photo = ?, receipt_time = ?, status = 'waiting_confirm' WHERE order_number = ?",
              (file_id, datetime.now().isoformat(), order_number))
    conn.commit()
    conn.close()
    
    bot.reply_to(message, "✅ عکس رسید دریافت شد.\n\n⏳ در انتظار تایید ادمین...\n\nپس از تایید، کانفیگ ارسال می‌شود.")
    
    first_name = message.from_user.first_name
    username = message.from_user.username or "ندارد"
    
    caption = f"""🆕 سفارش جدید - نیاز به تایید

━━━━━━━━━━━━━━━━━━━
👤 نام: {first_name}
🆔 آیدی عددی: {user_id}
👥 یوزرنیم: @{username}
📦 پکیج: {PLAN_NAMES[plan]}
💰 مبلغ: {price:,} تومان
🆔 شماره سفارش: {order_number}
⏰ زمان: {datetime.now().strftime('%H:%M:%S')}
━━━━━━━━━━━━━━━━━━━

لطفاً یکی از گزینه‌های زیر را انتخاب کنید:
"""
    
    bot.send_photo(ADMIN_ID, file_id, caption=caption, reply_markup=admin_order_buttons(order_number, user_id))
    add_log(user_id, "receipt_uploaded", order_number)

# هندلر دریافت متن از ادمین (تایید سفارش)
@bot.message_handler(func=lambda msg: msg.from_user.id == ADMIN_ID and msg.text and not msg.text.startswith('/') and not admin_broadcast_mode)
def handle_admin_message(message):
    admin_id = message.from_user.id
    
    # اولویت با پاسخ به پشتیبانی
    if admin_id in admin_awaiting_reply:
        user_id = admin_awaiting_reply.pop(admin_id)
        reply_text = message.text.strip()
        
        if not reply_text:
            bot.reply_to(message, "❌ متن پاسخ نمی‌تواند خالی باشد.")
            admin_awaiting_reply[admin_id] = user_id
            return
        
        # ذخیره در دیتابیس - کوئری اصلاح شده
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        # پیدا کردن آخرین تیکت pending
        c.execute("SELECT id FROM support_tickets WHERE user_id = ? AND status = 'pending' ORDER BY created_at DESC LIMIT 1", (user_id,))
        ticket = c.fetchone()
        if ticket:
            c.execute("UPDATE support_tickets SET admin_reply = ?, status = 'replied', replied_at = ? WHERE id = ?",
                      (reply_text, datetime.now().isoformat(), ticket[0]))
        else:
            # اگر تیکتی نبود، یک رکورد جدید ایجاد کن
            c.execute("INSERT INTO support_tickets (user_id, message, admin_reply, status, created_at, replied_at) VALUES (?, ?, ?, 'replied', ?, ?)",
                      (user_id, "پیام قبلی", reply_text, datetime.now().isoformat(), datetime.now().isoformat()))
        conn.commit()
        conn.close()
        
        # ارسال پاسخ به کاربر
        user_msg = f"""💬 پاسخ پشتیبانی:

━━━━━━━━━━━━━━━━━━━
{reply_text}
━━━━━━━━━━━━━━━━━━━

✅ در صورت نیاز مجدداً با پشتیبانی تماس بگیرید.
"""
        try:
            bot.send_message(user_id, user_msg)
            bot.reply_to(message, f"✅ پاسخ شما با موفقیت به کاربر ارسال شد.")
            add_log(user_id, "support_reply", reply_text)
        except Exception as e:
            bot.reply_to(message, f"⚠️ ارسال پیام به کاربر با خطا مواجه شد: {e}")
        return
    
    # سپس اولویت با تایید سفارش
    if admin_id in admin_awaiting_config:
        order_number = admin_awaiting_config.pop(admin_id)
        config_text = message.text.strip()
        
        if not config_text:
            bot.reply_to(message, "❌ متن نمی‌تواند خالی باشد.")
            admin_awaiting_config[admin_id] = order_number
            return
        
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        c.execute("SELECT user_id, plan, price FROM orders WHERE order_number = ? AND status = 'waiting_confirm'", (order_number,))
        order = c.fetchone()
        
        if not order:
            bot.reply_to(message, f"❌ سفارش {order_number} یافت نشد یا قبلاً تایید/رد شده است.")
            return
        
        user_id, plan, price = order
        expiry = (datetime.now() + timedelta(days=PRICES[plan]['days'])).isoformat()
        
        c.execute("""UPDATE orders SET status = 'confirmed', confirmed_at = ?, confirmed_by = ?,
                     config_link = ?, expiry_date = ? WHERE order_number = ?""",
                  (datetime.now().isoformat(), str(ADMIN_ID), config_text, expiry, order_number))
        
        c.execute("UPDATE users SET total_spent = total_spent + ?, total_orders = total_orders + 1 WHERE user_id = ?",
                  (price, user_id))
        conn.commit()
        
        confirm_text = f"""✅ سفارش شما تایید شد!

━━━━━━━━━━━━━━━━━━━
📦 {PLAN_NAMES[plan]}
💰 مبلغ: {price:,} تومان
📅 تاریخ انقضا: {expiry[:10]}
━━━━━━━━━━━━━━━━━━━

🔗 اطلاعات کانفیگ:
{config_text}

🙏 با تشکر از خرید شما
"""
        try:
            bot.send_message(user_id, confirm_text)
        except Exception as e:
            bot.reply_to(message, f"⚠️ پیام به کاربر ارسال نشد: {e}")
        
        bot.reply_to(message, f"✅ سفارش {order_number} با موفقیت تایید شد.")
        add_log(user_id, "order_confirmed", order_number)
        invalidate_cache()
        conn.close()
        return

# هندلر ارسال همگانی
@bot.message_handler(func=lambda msg: msg.from_user.id == ADMIN_ID and admin_broadcast_mode)
def handle_broadcast(message):
    global admin_broadcast_mode
    broadcast_text = message.text.strip()
    
    if not broadcast_text:
        bot.reply_to(message, "❌ متن نمی‌تواند خالی باشد.")
        return
    
    # ذخیره موقت متن برای تایید
    admin_broadcast_mode = False
    bot.reply_to(message, f"📢 متن ارسال همگانی:\n\n{broadcast_text}\n\nآیا برای ارسال به همه کاربران تأیید می‌کنید؟", reply_markup=broadcast_confirm_button())
    
    # ذخیره متن در حافظه موقت
    bot.temp_broadcast_text = broadcast_text

@bot.message_handler(func=lambda message: True, content_types=['text'])
@check_blocked
@check_join_required
def handle_user_text(message):
    user_id = str(message.from_user.id)
    text = message.text.strip()
    
    if text.startswith('/'):
        return
    
    # اگر کاربر دکمه پشتیبانی رو زده بود یا پیام عادی فرستاد
    first_name = message.from_user.first_name
    username = message.from_user.username or "ندارد"
    
    # ذخیره در دیتابیس تیکت
    conn = sqlite3.connect('ultimatee_bot.db')
    c = conn.cursor()
    c.execute("INSERT INTO support_tickets (user_id, message, status, created_at) VALUES (?, ?, 'pending', ?)",
              (user_id, text, datetime.now().isoformat()))
    conn.commit()
    conn.close()
    
    admin_msg = f"""💬 پیام پشتیبانی جدید

━━━━━━━━━━━━━━━━━━━
👤 نام: {first_name}
🆔 آیدی عددی: {user_id}
👥 یوزرنیم: @{username}
📝 پیام: {text}
⏰ زمان: {datetime.now().strftime('%H:%M:%S')}
━━━━━━━━━━━━━━━━━━━
"""
    
    bot.send_message(ADMIN_ID, admin_msg, reply_markup=support_reply_button(user_id))
    bot.reply_to(message, "✅ پیام شما با موفقیت به پشتیبانی ارسال شد.\n\nبه زودی پاسخ شما ارسال می‌شود.")

# ========== کالبک هندلرها ==========
@bot.callback_query_handler(func=lambda call: True)
@check_blocked_callback
def handle_callback(call):
    global admin_broadcast_mode
    
    # بررسی جوین اجباری برای کاربران عادی
    if call.from_user.id != ADMIN_ID:
        if not is_member(call.from_user.id):
            bot.answer_callback_query(call.id, "❌ ابتدا باید در کانال عضو شوید!", show_alert=True)
            bot.edit_message_text(JOIN_REQUIRED_TEXT.format(channel=REQUIRED_CHANNEL), 
                                 call.message.chat.id, call.message.message_id,
                                 reply_markup=join_button())
            return
    
    # دکمه بررسی عضویت
    if call.data == "check_join":
        if is_member(call.from_user.id):
            bot.answer_callback_query(call.id, "✅ عضویت شما تأیید شد!", show_alert=True)
            text = WELCOME_TEXT.format(first_name=call.from_user.first_name, channel=CHANNEL_USERNAME)
            bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=main_menu())
        else:
            bot.answer_callback_query(call.id, "❌ شما هنوز عضو کانال نشده‌اید!", show_alert=True)
        return
    
    # دکمه رفع بلاک از پیام بلاک
    if call.data.startswith("unblock_user_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود به ادمین!", show_alert=True)
            return
        user_id = call.data.split("_")[2]
        unblock_user(user_id)
        bot.answer_callback_query(call.id, f"کاربر {user_id} از مسدودیت خارج شد.")
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
        return
    
    # دکمه بلاک از پشتیبانی
    if call.data.startswith("support_block_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود به ادمین!", show_alert=True)
            return
        user_id = call.data.split("_")[2]
        block_user(user_id, "تخلف در پشتیبانی")
        bot.answer_callback_query(call.id, f"کاربر {user_id} مسدود شد.")
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
        return
    
    # دکمه بلاک کاربر از سفارش
    if call.data.startswith("admin_block_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود به ادمین!", show_alert=True)
            return
        
        parts = call.data.split("_")
        user_id = parts[2]
        order_number = parts[3] if len(parts) > 3 else ""
        
        block_user(user_id, "تخلف در سفارش")
        bot.answer_callback_query(call.id, f"کاربر {user_id} مسدود شد.")
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
        return
    
    # دکمه پاسخ به پشتیبانی
    if call.data.startswith("reply_support_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود به ادمین!", show_alert=True)
            return
        
        user_id = call.data.split("_")[2]
        admin_awaiting_reply[call.from_user.id] = user_id
        bot.answer_callback_query(call.id, "لطفاً پاسخ کاربر را در پیام بعدی ارسال کنید.")
        bot.send_message(call.from_user.id, f"💬 لطفاً پاسخ خود را برای کاربر {user_id} ارسال کنید.\n(برای لغو دستور /cancel را بزنید)")
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
        return
    
    # دکمه‌های ادمین برای تایید/رد سفارش
    if call.data.startswith("admin_confirm_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود به ادمین!", show_alert=True)
            return
        
        order_number = call.data.split("_")[2]
        
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        c.execute("SELECT user_id FROM orders WHERE order_number = ? AND status = 'waiting_confirm'", (order_number,))
        order = c.fetchone()
        conn.close()
        
        if not order:
            bot.answer_callback_query(call.id, "سفارش قبلاً تایید یا حذف شده است.", show_alert=True)
            bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
            return
        
        admin_awaiting_config[call.from_user.id] = order_number
        bot.answer_callback_query(call.id, "لطفاً متن کانفیگ را در پیام بعدی ارسال کنید.")
        bot.send_message(call.from_user.id, f"🔗 لطفاً متن کانفیگ را برای سفارش {order_number} ارسال کنید.\n(برای لغو دستور /cancel را بزنید)")
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
        return
    
    if call.data.startswith("admin_reject_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود به ادمین!", show_alert=True)
            return
        
        order_number = call.data.split("_")[2]
        
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        c.execute("SELECT user_id, plan, price FROM orders WHERE order_number = ? AND status = 'waiting_confirm'", (order_number,))
        order = c.fetchone()
        
        if not order:
            bot.answer_callback_query(call.id, "سفارش قبلاً تایید یا حذف شده است.", show_alert=True)
            bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
            return
        
        user_id, plan, price = order
        
        try:
            c.execute("UPDATE orders SET status = 'rejected' WHERE order_number = ?", (order_number,))
            conn.commit()
        except:
            c.execute("UPDATE orders SET status = 'canceled' WHERE order_number = ?", (order_number,))
            conn.commit()
        
        c.execute("SELECT username, first_name FROM users WHERE user_id = ?", (user_id,))
        user_info = c.fetchone()
        username = user_info[0] if user_info and user_info[0] else "ندارد"
        first_name = user_info[1] if user_info else "نامشخص"
        conn.close()
        
        admin_msg = f"""❌ سفارش کاربر تایید نشد.

━━━━━━━━━━━━━━━━━━━
👤 نام: {first_name}
🆔 آیدی: {user_id}
👥 یوزرنیم: @{username}
📦 پکیج: {PLAN_NAMES[plan]}
💰 مبلغ: {price:,} تومان
🆔 شماره سفارش: {order_number}
━━━━━━━━━━━━━━━━━━━

این سفارش توسط ادمین رد شد.
"""
        bot.send_message(ADMIN_ID, admin_msg)
        
        user_msg = f"""❌ سفارش شما تایید نشد.

━━━━━━━━━━━━━━━━━━━
📦 {PLAN_NAMES[plan]}
💰 مبلغ: {price:,} تومان
🆔 شماره سفارش: {order_number}
━━━━━━━━━━━━━━━━━━━

دلیل احتمالی: مشکل در رسید واریز یا اطلاعات ناقص.
لطفاً با پشتیبانی تماس بگیرید یا مجدداً سفارش دهید.

📞 پشتیبانی: @{CHANNEL_USERNAME}
"""
        try:
            bot.send_message(user_id, user_msg)
        except:
            pass
        
        bot.answer_callback_query(call.id, "سفارش با موفقیت رد شد.")
        add_log(user_id, "order_rejected", order_number)
        invalidate_cache()
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
        return
    
    # ارسال همگانی
    if call.data == "admin_broadcast":
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!", show_alert=True)
            return
        admin_broadcast_mode = True
        bot.answer_callback_query(call.id, "لطفاً متن پیام همگانی را ارسال کنید.")
        bot.send_message(call.from_user.id, "📢 لطفاً متن پیامی که می‌خواهید به همه کاربران ارسال شود را بنویسید:\n(برای لغو دستور /cancel را بزنید)")
        return
    
    if call.data == "broadcast_confirm":
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!", show_alert=True)
            return
        
        broadcast_text = getattr(bot, 'temp_broadcast_text', None)
        if not broadcast_text:
            bot.answer_callback_query(call.id, "متنی برای ارسال وجود ندارد!")
            return
        
        users = get_all_users()
        success_count = 0
        fail_count = 0
        
        bot.send_message(call.from_user.id, f"⏳ در حال ارسال پیام به {len(users)} کاربر...")
        
        for user_id in users:
            try:
                bot.send_message(user_id, f"📢 پیام همگانی:\n\n{broadcast_text}")
                success_count += 1
                time.sleep(0.05)
            except:
                fail_count += 1
        
        bot.edit_message_text(f"✅ ارسال همگانی انجام شد.\n\n✅ موفق: {success_count}\n❌ ناموفق: {fail_count}", 
                              call.message.chat.id, call.message.message_id)
        add_log("system", "broadcast", f"ارسال به {success_count} کاربر")
        return
    
    if call.data == "broadcast_cancel":
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!", show_alert=True)
            return
        bot.edit_message_text("❌ ارسال همگانی لغو شد.", call.message.chat.id, call.message.message_id)
        return
    
    # منوی پشتیبانی
    elif call.data == "support":
        bot.edit_message_text("📞 **پشتیبانی**\n\nلطفاً مشکل یا سوال خود را بنویسید تا در اسرع وقت پاسخ دهید.\n\n⚠️ توجه: لطفاً شماره سفارش خود را همراه پیام ارسال کنید.", 
                              call.message.chat.id, call.message.message_id)
        bot.send_message(call.message.chat.id, "✏️ لطفاً پیام خود را ارسال کنید:")
        return
    
    elif call.data == "help":
        help_text = f"""ℹ️ **راهنمای فروشگاه**

━━━━━━━━━━━━━━━━━━━
1️⃣ **خرید سرویس**
• از منوی اصلی گزینه خرید را بزنید
• پکیج مورد نظر را انتخاب کنید
• مبلغ را به کارت اعلام شده واریز کنید
• عکس رسید را ارسال کنید
• پس از تایید، کانفیگ ارسال می‌شود

2️⃣ **مشاهده حساب**
• اطلاعات خریدها و وضعیت سفارش‌ها

3️⃣ **پشتیبانی**
• برای ارتباط با ادمین
━━━━━━━━━━━━━━━━━━━

📢 کانال اطلاع‌رسانی: @{CHANNEL_USERNAME}
"""
        bot.edit_message_text(help_text, call.message.chat.id, call.message.message_id, reply_markup=main_menu())
        return
    
    # منوهای دیگر
    elif call.data == "buy":
        text = """🛍️ انتخاب پکیج مورد نظر

━━━━━━━━━━━━━━━━━━━
✨ لطفاً یکی از پکیج‌های زیر را انتخاب کنید:

⭐️ 2 گیگ - 220,000 تومان
⭐️⭐️ 3 گیگ - 330,000 تومان
💎 5 گیگ - 550,000 تومان
👑 10 گیگ - 1,100,000 تومان
━━━━━━━━━━━━━━━━━━━
"""
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=buy_menu())
    
    elif call.data == "account":
        user_id = str(call.from_user.id)
        
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        c.execute("SELECT total_spent, total_orders FROM users WHERE user_id = ?", (user_id,))
        user = c.fetchone()
        c.execute("SELECT order_number, plan, price, status, created_at, expiry_date FROM orders WHERE user_id = ? ORDER BY created_at DESC LIMIT 5", (user_id,))
        orders = c.fetchall()
        conn.close()
        
        if user:
            total_spent, total_orders = user
            
            if total_spent >= 2000000:
                level = "💎 الماس"
                level_icon = "👑"
            else:
                level = "برنزی"
                level_icon = "🥉"
            
            account_text = f"""👤 حساب کاربری شما

━━━━━━━━━━━━━━━━━━━
🆔 شناسه: {user_id}
🏆 سطح: {level_icon} {level}
💰 مجموع خرید: {total_spent:,} تومان
📦 تعداد سفارش‌ها: {total_orders}
━━━━━━━━━━━━━━━━━━━

📜 آخرین سفارش‌ها:
"""
            if orders:
                for order in orders:
                    order_num, plan, price, status, created_at, expiry = order
                    if status == "confirmed":
                        status_emoji = "✅"
                    elif status == "waiting_confirm":
                        status_emoji = "⏳"
                    else:
                        status_emoji = "❌"
                    account_text += f"\n{status_emoji} {order_num} - {PLAN_NAMES[plan]} - {price:,} تومان"
            else:
                account_text += "\n⚡ هنوز سفارشی ثبت نکرده‌اید."
            
            bot.edit_message_text(account_text, call.message.chat.id, call.message.message_id, reply_markup=main_menu())
        else:
            bot.edit_message_text("⚠️ خطا در دریافت اطلاعات!", call.message.chat.id, call.message.message_id)
    
    elif call.data == "back":
        text = WELCOME_TEXT.format(first_name=call.from_user.first_name, channel=CHANNEL_USERNAME)
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=main_menu())
    
    elif call.data == "admin_back":
        admin_panel(call.message)
    
    elif call.data.startswith("buy_"):
        plan_id = call.data.split("_")[1]
        if plan_id not in PRICES:
            bot.answer_callback_query(call.id, "پکیج نامعتبر!", show_alert=True)
            return
        
        plan = PRICES[plan_id]
        order_number = generate_order_number()
        user_id = str(call.from_user.id)
        
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        c.execute("""INSERT INTO orders (order_number, user_id, plan, price, status, created_at) 
                     VALUES (?, ?, ?, ?, 'waiting', ?)""",
                  (order_number, user_id, plan_id, plan['price'], datetime.now().isoformat()))
        conn.commit()
        conn.close()
        
        text = payment_info(PLAN_NAMES[plan_id], plan['price'], order_number)
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id)
        bot.send_message(call.message.chat.id, "📸 لطفاً عکس رسید واریز را ارسال کنید:")
    
    elif call.data.startswith("order_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!", show_alert=True)
            return
        bot.answer_callback_query(call.id, "برای تایید از دکمه‌های شیشه‌ای استفاده کنید.")
    
    elif call.data.startswith("orders_page_"):
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!")
            return
        page = int(call.data.split("_")[2])
        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=orders_menu(page))
    
    elif call.data == "admin_stats":
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!")
            return
        stats = get_stats()
        text = f"""📊 آمار پیشرفته فروش

━━━━━━━━━━━━━━━━━━━
💰 فروش امروز: {stats['today_sales']:,} تومان
📦 سفارش امروز: {stats['today_orders']}
📈 رشد نسبت به دیروز: {stats['sales_growth']:.1f}%
━━━━━━━━━━━━━━━━━━━
📆 فروش ۷ روز: {stats['week_sales']:,} تومان
📅 فروش ۳۰ روز: {stats['month_sales']:,} تومان
━━━━━━━━━━━━━━━━━━━
👥 کاربران کل: {stats['total_users']}
📦 کل سفارشات: {stats['total_orders']}
💰 مجموع فروش: {stats['total_sales']:,} تومان
⏳ سفارشات در انتظار: {stats['pending_orders']}
"""
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=admin_menu())
    
    elif call.data == "admin_orders":
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!")
            return
        bot.edit_message_text("📦 سفارشات در انتظار تایید:", call.message.chat.id, call.message.message_id, reply_markup=orders_menu())
    
    elif call.data == "admin_users":
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!")
            return
        conn = sqlite3.connect('ultimatee_bot.db')
        c = conn.cursor()
        c.execute("SELECT COUNT(*) FROM users WHERE is_blocked = 0")
        active = c.fetchone()[0]
        c.execute("SELECT COUNT(*) FROM users WHERE is_blocked = 1")
        blocked = c.fetchone()[0]
        conn.close()
        bot.answer_callback_query(call.id, f"👥 کاربران فعال: {active}\n🚫 کاربران مسدود: {blocked}", show_alert=True)
    
    elif call.data in ["admin_logs", "admin_backup", "admin_settings"]:
        if call.from_user.id != ADMIN_ID:
            bot.answer_callback_query(call.id, "دسترسی محدود!")
            return
        bot.answer_callback_query(call.id, "این بخش در حال توسعه است...", show_alert=True)
    
    else:
        bot.answer_callback_query(call.id, "در حال توسعه...")

if __name__ == "__main__":
    print("ربات با موفقیت راه‌اندازی شد...")
    bot.infinity_polling()