import telebot
from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
import sqlite3
import requests
import json
import time
import re
import logging
import shutil
import os
from datetime import datetime, timedelta
import threading
from functools import wraps
from decimal import Decimal, ROUND_HALF_UP
import hashlib
import secrets

# ============================================
# تنظیمات - با آدرس پنل جدید شما
# ============================================
BOT_TOKEN = "8929382405:AAGplxrGHl0WHQUZJRsi_juGVb7RuxIr7gw"

PANEL_BASE_URL = "http://95.38.160.188:2933"
PANEL_SUB_PATH = "/yWC4hC6yClE4Vfo"
PANEL_URL = f"{PANEL_BASE_URL}{PANEL_SUB_PATH}"
PANEL_USERNAME = "1"
PANEL_PASSWORD = "1"

ADMIN_ID = 8046692057
FORCE_CHANNEL = "@zitronshop"

PRICE_PER_GB = 200
PACKAGES = {
    "1g": {"name": "📦 1 گیگابایت", "gb": 1, "price": 200, "days": 30},
    "2g": {"name": "📦 2 گیگابایت", "gb": 2, "price": 380, "days": 30},
    "5g": {"name": "📦 5 گیگابایت", "gb": 5, "price": 900, "days": 30},
    "10g": {"name": "📦 10 گیگابایت", "gb": 10, "price": 1700, "days": 45},
    "20g": {"name": "📦 20 گیگابایت", "gb": 20, "price": 3200, "days": 60},
    "50g": {"name": "📦 50 گیگابایت ویژه", "gb": 50, "price": 7500, "days": 90},
    "special": {"name": "🔥 ویژه: 5 گیگ با 20% تخفیف", "gb": 5, "price": 800, "days": 30}
}

CARD_INFO = "6037-9975-1234-5678\nبه نام: زیتون شاپ\nشبا: IR980123456789012345678901"
USDT_WALLET = "TZitronShopWalletAddress"
USDT_RATE = 65000

MAX_ACTIVE_SUBS = 3
RATE_LIMIT_SECONDS = 2
SESSION_TIMEOUT = 3600

# ============================================
# متن منوی اصلی
# ============================================
MAIN_MENU_TEXT = """🏠 **صفحه اصلی زیتون شاپ**

👋 سلام {name} عزیز!

💰 موجودی کیف پول شما: {wallet:,} تومان

از منوی زیر یکی را انتخاب کنید:"""

# ============================================
# تابع نوار مصرف
# ============================================
def get_usage_bar(percent):
    """ساخت نوار مصرف گرافیکی با محدودیت درصد"""
    if percent > 100:
        percent = 100
    bar_length = 20
    filled = int(bar_length * percent / 100)
    bar = "█" * filled + "░" * (bar_length - filled)
    
    if percent < 50:
        emoji = "🟢"
    elif percent < 80:
        emoji = "🟡"
    else:
        emoji = "🔴"
    
    return f"{emoji} مصرف: {bar} {percent:.0f}%\n"

# ============================================
# تنظیمات لاگ
# ============================================
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('zitron_bot.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# ============================================
# جدول رسیدها
# ============================================
RECEIPTS_TABLE = '''
    CREATE TABLE IF NOT EXISTS receipts (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        order_id INTEGER,
        user_id INTEGER,
        file_id TEXT,
        file_type TEXT,
        created_at TEXT,
        status TEXT DEFAULT 'pending'
    )
'''

# ============================================
# کلاس مدیریت دیتابیس (با قفل threading)
# ============================================
class DatabaseManager:
    def __init__(self, db_name="zitron.db"):
        self.db_name = db_name
        self.connection = None
        self.cursor = None
        self.lock = threading.Lock()  # اضافه شدن قفل برای رفع باگ #5
        self.connect()
        self.create_tables()
    
    def connect(self):
        try:
            if self.connection:
                self.connection.close()
            self.connection = sqlite3.connect(self.db_name, check_same_thread=False)
            self.connection.row_factory = sqlite3.Row
            self.cursor = self.connection.cursor()
            logger.info("اتصال به دیتابیس برقرار شد")
        except Exception as e:
            logger.error(f"خطا در اتصال به دیتابیس: {e}")
            raise
    
    def reconnect_if_needed(self):
        try:
            self.cursor.execute("SELECT 1")
        except:
            logger.warning("اتصال دیتابیس قطع شد، در حال reconnect...")
            self.connect()
    
    def create_tables(self):
        tables = {
            'users': '''
                CREATE TABLE IF NOT EXISTS users (
                    user_id INTEGER PRIMARY KEY,
                    username TEXT,
                    fullname TEXT,
                    wallet INTEGER DEFAULT 0,
                    wallet_locked INTEGER DEFAULT 0,
                    daily_used INTEGER DEFAULT 0,
                    last_reset_date TEXT,
                    total_purchases INTEGER DEFAULT 0,
                    total_spent INTEGER DEFAULT 0,
                    created_at TEXT,
                    last_seen TEXT,
                    is_banned INTEGER DEFAULT 0,
                    ban_reason TEXT
                )
            ''',
            'subs': '''
                CREATE TABLE IF NOT EXISTS subs (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    volume INTEGER,
                    sub_link TEXT,
                    panel_username TEXT,
                    expire_date TEXT,
                    created_at TEXT,
                    last_used TEXT,
                    data_used INTEGER DEFAULT 0,
                    status TEXT DEFAULT 'active'
                )
            ''',
            'orders': '''
                CREATE TABLE IF NOT EXISTS orders (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    volume INTEGER,
                    price INTEGER,
                    status TEXT,
                    payment_method TEXT,
                    transaction_id TEXT,
                    created_at TEXT,
                    completed_at TEXT
                )
            ''',
            'tickets': '''
                CREATE TABLE IF NOT EXISTS tickets (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    message TEXT,
                    reply TEXT,
                    status TEXT,
                    priority TEXT DEFAULT 'normal',
                    created_at TEXT,
                    closed_at TEXT
                )
            ''',
            'admin_logs': '''
                CREATE TABLE IF NOT EXISTS admin_logs (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    admin_id INTEGER,
                    action TEXT,
                    target_user INTEGER,
                    details TEXT,
                    ip_address TEXT,
                    created_at TEXT
                )
            ''',
            'pending_operations': '''
                CREATE TABLE IF NOT EXISTS pending_operations (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    order_id INTEGER,
                    operation_type TEXT,
                    retry_count INTEGER DEFAULT 0,
                    last_error TEXT,
                    created_at TEXT
                )
            ''',
            'user_sessions': '''
                CREATE TABLE IF NOT EXISTS user_sessions (
                    user_id INTEGER PRIMARY KEY,
                    session_token TEXT,
                    expires_at TEXT
                )
            ''',
            'rate_limits': '''
                CREATE TABLE IF NOT EXISTS rate_limits (
                    user_id INTEGER,
                    action_type TEXT,
                    attempts INTEGER DEFAULT 1,
                    last_attempt TEXT,
                    PRIMARY KEY (user_id, action_type)
                )
            ''',
            'discount_codes': '''
                CREATE TABLE IF NOT EXISTS discount_codes (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    code TEXT UNIQUE,
                    discount_percent INTEGER,
                    max_uses INTEGER,
                    used_count INTEGER DEFAULT 0,
                    expires_at TEXT,
                    is_active INTEGER DEFAULT 1
                )
            ''',
            'wallet_transactions': '''
                CREATE TABLE IF NOT EXISTS wallet_transactions (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    amount INTEGER,
                    transaction_type TEXT,
                    reference_id TEXT,
                    description TEXT,
                    created_at TEXT
                )
            ''',
            'receipts': RECEIPTS_TABLE
        }
        
        with self.lock:
            for table_name, query in tables.items():
                try:
                    self.cursor.execute(query)
                    logger.info(f"جدول {table_name} بررسی/ایجاد شد")
                except Exception as e:
                    logger.error(f"خطا در ایجاد جدول {table_name}: {e}")
            
            # اضافه کردن ستون‌های جدید
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN wallet_locked INTEGER DEFAULT 0")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN daily_used INTEGER DEFAULT 0")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN last_reset_date TEXT")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN total_purchases INTEGER DEFAULT 0")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN total_spent INTEGER DEFAULT 0")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN is_banned INTEGER DEFAULT 0")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE users ADD COLUMN ban_reason TEXT")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE subs ADD COLUMN data_used INTEGER DEFAULT 0")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE orders ADD COLUMN transaction_id TEXT")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE orders ADD COLUMN completed_at TEXT")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE tickets ADD COLUMN priority TEXT DEFAULT 'normal'")
            except sqlite3.OperationalError:
                pass
            try:
                self.cursor.execute("ALTER TABLE tickets ADD COLUMN closed_at TEXT")
            except sqlite3.OperationalError:
                pass
                
            self.connection.commit()
    
    def execute(self, query, params=None):
        """اجرای کوئری با قفل threading"""
        with self.lock:
            self.reconnect_if_needed()
            try:
                if params:
                    self.cursor.execute(query, params)
                else:
                    self.cursor.execute(query)
                return self.cursor
            except sqlite3.OperationalError as e:
                if "database is locked" in str(e):
                    time.sleep(0.1)
                    return self.execute(query, params)
                raise
    
    def commit(self):
        with self.lock:
            self.reconnect_if_needed()
            self.connection.commit()
    
    def fetchone(self):
        return self.cursor.fetchone()
    
    def fetchall(self):
        return self.cursor.fetchall()
    
    def lastrowid(self):
        return self.cursor.lastrowid
    
    def close(self):
        with self.lock:
            if self.connection:
                self.connection.close()
                logger.info("اتصال دیتابیس بسته شد")

db_manager = DatabaseManager()

logger.info("دیتابیس با موفقیت راه‌اندازی شد")

# ============================================
# کلاس مدیریت کاربران
# ============================================
class UserManager:
    @staticmethod
    def get_user(user_id):
        cursor = db_manager.execute("SELECT * FROM users WHERE user_id = ?", (user_id,))
        return cursor.fetchone()
    
    @staticmethod
    def add_user(user_id, username, fullname):
        if not UserManager.get_user(user_id):
            db_manager.execute("""INSERT INTO users 
                           (user_id, username, fullname, wallet, created_at, last_seen, last_reset_date) 
                           VALUES (?,?,?,?,?,?,?)""",
                          (user_id, username, fullname, 0, 
                           datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                           datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                           datetime.now().strftime("%Y-%m-%d")))
            db_manager.commit()
            logger.info(f"کاربر جدید اضافه شد: {user_id} - {username}")
            return True
        return False
    
    @staticmethod
    def update_last_seen(user_id):
        db_manager.execute("UPDATE users SET last_seen = ? WHERE user_id = ?",
                      (datetime.now().strftime("%Y-%m-%d %H:%M:%S"), user_id))
        db_manager.commit()
    
    @staticmethod
    def reset_daily_usage_if_needed(user_id):
        cursor = db_manager.execute("SELECT last_reset_date, daily_used FROM users WHERE user_id = ?", (user_id,))
        result = cursor.fetchone()
        if result:
            last_reset = result[0]
            today = datetime.now().strftime("%Y-%m-%d")
            if last_reset != today:
                db_manager.execute("UPDATE users SET daily_used = 0, last_reset_date = ? WHERE user_id = ?",
                              (today, user_id))
                db_manager.commit()
                return True
        return False
    
    @staticmethod
    def get_wallet(user_id):
        cursor = db_manager.execute("SELECT wallet, wallet_locked FROM users WHERE user_id = ?", (user_id,))
        r = cursor.fetchone()
        if r:
            return r[0] - r[1]
        return 0
    
    @staticmethod
    def update_wallet(user_id, amount, description=""):
        current = UserManager.get_total_wallet(user_id)
        new_amount = current + amount
        if new_amount < 0:
            logger.error(f"تلاش برای منفی کردن کیف پول کاربر {user_id}")
            return False
        
        db_manager.execute("UPDATE users SET wallet = wallet + ? WHERE user_id = ?", (amount, user_id))
        
        transaction_type = "deposit" if amount > 0 else "withdraw"
        db_manager.execute("""INSERT INTO wallet_transactions 
                       (user_id, amount, transaction_type, description, created_at) 
                       VALUES (?,?,?,?,?)""",
                      (user_id, abs(amount), transaction_type, description,
                       datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        
        db_manager.commit()
        logger.info(f"کیف پول کاربر {user_id} به مقدار {amount} تغییر کرد - {description}")
        return True
    
    @staticmethod
    def get_total_wallet(user_id):
        cursor = db_manager.execute("SELECT wallet FROM users WHERE user_id = ?", (user_id,))
        r = cursor.fetchone()
        return r[0] if r else 0
    
    @staticmethod
    def lock_wallet_amount(user_id, amount):
        db_manager.execute("UPDATE users SET wallet_locked = wallet_locked + ? WHERE user_id = ?", (amount, user_id))
        db_manager.commit()
    
    @staticmethod
    def unlock_wallet_amount(user_id, amount):
        db_manager.execute("UPDATE users SET wallet_locked = wallet_locked - ? WHERE user_id = ?", (amount, user_id))
        db_manager.commit()
    
    @staticmethod
    def increment_purchases(user_id, amount):
        db_manager.execute("""UPDATE users 
                       SET total_purchases = total_purchases + 1, 
                           total_spent = total_spent + ? 
                       WHERE user_id = ?""", (amount, user_id))
        db_manager.commit()
    
    @staticmethod
    def is_banned(user_id):
        cursor = db_manager.execute("SELECT is_banned, ban_reason FROM users WHERE user_id = ?", (user_id,))
        result = cursor.fetchone()
        if result and result[0] == 1:
            return True, result[1] if result[1] else "نامشخص"
        return False, None
    
    @staticmethod
    def ban_user(user_id, reason=""):
        db_manager.execute("UPDATE users SET is_banned = 1, ban_reason = ? WHERE user_id = ?", (reason, user_id))
        db_manager.commit()
        logger.warning(f"کاربر {user_id} بن شد - دلیل: {reason}")
    
    @staticmethod
    def unban_user(user_id):
        db_manager.execute("UPDATE users SET is_banned = 0, ban_reason = NULL WHERE user_id = ?", (user_id,))
        db_manager.commit()
        logger.info(f"بن کاربر {user_id} برداشته شد")

# ============================================
# کلاس مدیریت اشتراک‌ها
# ============================================
class SubscriptionManager:
    @staticmethod
    def get_active_subs_count(user_id):
        cursor = db_manager.execute("SELECT COUNT(*) FROM subs WHERE user_id = ? AND expire_date > ? AND status = 'active'",
                      (user_id, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        return cursor.fetchone()[0]
    
    @staticmethod
    def can_create_new_sub(user_id):
        active_count = SubscriptionManager.get_active_subs_count(user_id)
        return active_count < MAX_ACTIVE_SUBS
    
    @staticmethod
    def save_sub(user_id, volume, sub_link, panel_user, expire):
        db_manager.execute("""INSERT INTO subs 
                       (user_id, volume, sub_link, panel_username, expire_date, created_at, status) 
                       VALUES (?,?,?,?,?,?,?)""",
                      (user_id, volume, sub_link, panel_user, expire, 
                       datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "active"))
        db_manager.commit()
        logger.info(f"اشتراک جدید برای کاربر {user_id} ثبت شد - حجم: {volume}GB")
        return db_manager.lastrowid()
    
    @staticmethod
    def get_user_subs(user_id):
        cursor = db_manager.execute("""SELECT * FROM subs 
                       WHERE user_id = ? AND expire_date > ? AND status = 'active' 
                       ORDER BY expire_date ASC""",
                      (user_id, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        return cursor.fetchall()
    
    @staticmethod
    def get_all_user_subs(user_id):
        cursor = db_manager.execute("SELECT * FROM subs WHERE user_id = ? ORDER BY expire_date DESC", (user_id,))
        return cursor.fetchall()
    
    @staticmethod
    def deactivate_sub(sub_id):
        db_manager.execute("UPDATE subs SET status = 'expired' WHERE id = ?", (sub_id,))
        db_manager.commit()
    
    @staticmethod
    def update_data_usage(sub_id, used_bytes):
        db_manager.execute("UPDATE subs SET data_used = data_used + ? WHERE id = ?", (used_bytes, sub_id))
        db_manager.commit()

# ============================================
# کلاس مدیریت سفارشات
# ============================================
class OrderManager:
    @staticmethod
    def save_order(user_id, volume, price, method, transaction_id=None):
        db_manager.execute("""INSERT INTO orders 
                       (user_id, volume, price, status, payment_method, transaction_id, created_at) 
                       VALUES (?,?,?,?,?,?,?)""",
                      (user_id, volume, price, "pending", method, transaction_id,
                       datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        db_manager.commit()
        order_id = db_manager.lastrowid()
        logger.info(f"سفارش جدید #{order_id} ثبت شد - کاربر: {user_id}")
        return order_id
    
    @staticmethod
    def update_order(order_id, status):
        db_manager.execute("UPDATE orders SET status = ?, completed_at = ? WHERE id = ?",
                      (status, datetime.now().strftime("%Y-%m-%d %H:%M:%S") if status == "completed" else None, order_id))
        db_manager.commit()
        logger.info(f"وضعیت سفارش #{order_id} به {status} تغییر کرد")
    
    @staticmethod
    def get_order(order_id):
        cursor = db_manager.execute("SELECT * FROM orders WHERE id = ?", (order_id,))
        return cursor.fetchone()
    
    @staticmethod
    def validate_order_access(user_id, order_id):
        cursor = db_manager.execute("SELECT user_id FROM orders WHERE id = ?", (order_id,))
        result = cursor.fetchone()
        return result and result[0] == user_id
    
    @staticmethod
    def get_user_orders(user_id, limit=10):
        cursor = db_manager.execute("SELECT * FROM orders WHERE user_id = ? ORDER BY id DESC LIMIT ?", (user_id, limit))
        return cursor.fetchall()
    
    @staticmethod
    def get_pending_order(user_id):
        cursor = db_manager.execute("""SELECT id, price FROM orders 
                       WHERE user_id = ? AND status IN ('pending', 'waiting_for_payment')
                       ORDER BY id DESC LIMIT 1""", (user_id,))
        return cursor.fetchone()

# ============================================
# کلاس مدیریت رسیدها
# ============================================
class ReceiptManager:
    @staticmethod
    def save_receipt(order_id, user_id, file_id, file_type):
        db_manager.execute("""INSERT INTO receipts 
                       (order_id, user_id, file_id, file_type, created_at) 
                       VALUES (?,?,?,?,?)""",
                      (order_id, user_id, file_id, file_type,
                       datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        db_manager.commit()
        logger.info(f"رسید سفارش #{order_id} در دیتابیس ذخیره شد")
        return db_manager.lastrowid()
    
    @staticmethod
    def get_receipts_by_order(order_id):
        cursor = db_manager.execute("SELECT * FROM receipts WHERE order_id = ? ORDER BY id DESC", (order_id,))
        return cursor.fetchall()

# ============================================
# کلاس مدیریت پنل
# ============================================
class PanelManager:
    def __init__(self):
        self.token_cache = None
        self.token_expiry = None
        self.lock = threading.Lock()
    
    def get_panel_token(self):
        with self.lock:
            if self.token_cache and self.token_expiry and time.time() < self.token_expiry:
                return self.token_cache
            
            try:
                logger.info("در حال دریافت توکن جدید از پنل...")
                response = requests.post(
                    f"{PANEL_URL}/api/admin/token",
                    data={"username": PANEL_USERNAME, "password": PANEL_PASSWORD},
                    timeout=10
                )
                
                if response.status_code == 200:
                    token_data = response.json()
                    self.token_cache = token_data.get("access_token")
                    self.token_expiry = time.time() + 3500
                    logger.info("توکن با موفقیت دریافت شد")
                    return self.token_cache
                else:
                    logger.error(f"خطا در دریافت توکن: {response.status_code} - {response.text}")
                    return None
                    
            except requests.exceptions.Timeout:
                logger.error("Timeout در دریافت توکن از پنل")
            except requests.exceptions.ConnectionError:
                logger.error("خطای اتصال به پنل")
            except Exception as e:
                logger.error(f"خطای ناشناخته در دریافت توکن: {e}")
            return None
    
    def check_user_exists_in_panel(self, username):
        token = self.get_panel_token()
        if not token:
            return False
        
        headers = {"Authorization": f"Bearer {token}"}
        try:
            response = requests.get(f"{PANEL_URL}/api/user/{username}", headers=headers, timeout=10)
            return response.status_code == 200
        except:
            return False
    
    def create_user_in_panel(self, user_id, volume_gb, days=30):
        token = self.get_panel_token()
        if not token:
            logger.error("عدم دریافت توکن برای ساخت کاربر")
            return None
        
        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
        
        unique_id = secrets.token_hex(4)
        username = f"user_{user_id}_{unique_id}"
        
        while self.check_user_exists_in_panel(username):
            unique_id = secrets.token_hex(4)
            username = f"user_{user_id}_{unique_id}"
        
        data_limit = volume_gb * 1073741824
        expire_timestamp = int((datetime.now() + timedelta(days=days)).timestamp())
        
        data = {
            "username": username,
            "data_limit": data_limit,
            "expire": expire_timestamp,
            "status": "active",
            "proxies": {}
        }
        
        try:
            logger.info(f"در حال ساخت کاربر در پنل: {username} با حجم {volume_gb}GB و اعتبار {days} روز")
            
            response = requests.post(f"{PANEL_URL}/api/users", json=data, headers=headers, timeout=15)
            
            if response.status_code in [200, 201]:
                sub_response = requests.get(
                    f"{PANEL_URL}/api/user/{username}/subscription",
                    headers=headers,
                    timeout=10
                )
                
                if sub_response.status_code == 200:
                    sub_data = sub_response.json()
                    sub_url = sub_data.get("subscription_url")
                    
                    if sub_url:
                        logger.info(f"کاربر {username} با موفقیت در پنل ساخته شد")
                        return {"url": sub_url, "username": username}
                    else:
                        logger.error("لینک اشتراک دریافت نشد")
                else:
                    logger.error(f"خطا در دریافت لینک اشتراک: {sub_response.status_code}")
            else:
                logger.error(f"خطا در ساخت کاربر: {response.status_code} - {response.text}")
                
        except requests.exceptions.Timeout:
            logger.error("Timeout در ساخت کاربر در پنل")
        except requests.exceptions.ConnectionError:
            logger.error("خطای اتصال در ساخت کاربر")
        except Exception as e:
            logger.error(f"خطای ناشناخته در ساخت کاربر: {e}")
        
        return None
    
    def create_user_in_panel_with_retry(self, user_id, volume_gb, days=30, retries=5):
        for attempt in range(retries):
            result = self.create_user_in_panel(user_id, volume_gb, days)
            if result:
                return result
            
            wait_time = 2 ** attempt
            logger.warning(f"تلاش {attempt + 1} از {retries} برای ساخت کاربر {user_id} ناموفق بود - انتظار {wait_time} ثانیه")
            time.sleep(wait_time)
        
        return None
    
    def get_panel_stats(self):
        token = self.get_panel_token()
        if not token:
            return None
        
        headers = {"Authorization": f"Bearer {token}"}
        try:
            response = requests.get(f"{PANEL_URL}/api/users", headers=headers, timeout=10)
            if response.status_code == 200:
                users = response.json()
                total_users = len(users)
                active_users = len([u for u in users if u.get('status') == 'active'])
                total_data = sum([u.get('data_limit', 0) for u in users if u.get('data_limit')])
                
                return {
                    "total_users": total_users,
                    "active_users": active_users,
                    "total_data_gb": total_data / 1073741824
                }
        except Exception as e:
            logger.error(f"خطا در دریافت آمار پنل: {e}")
        
        return None
    
    def get_user_usage_from_panel(self, username):
        token = self.get_panel_token()
        if not token:
            return None
        
        headers = {"Authorization": f"Bearer {token}"}
        try:
            response = requests.get(f"{PANEL_URL}/api/user/{username}", headers=headers, timeout=10)
            if response.status_code == 200:
                user_data = response.json()
                used_bytes = user_data.get('used_traffic', 0)
                total_bytes = user_data.get('data_limit', 0)
                
                if total_bytes > 0:
                    used_percent = (used_bytes / total_bytes) * 100
                else:
                    used_percent = 0
                
                return {
                    "used_gb": used_bytes / 1073741824,
                    "total_gb": total_bytes / 1073741824,
                    "used_percent": used_percent,
                    "status": user_data.get('status', 'unknown')
                }
        except Exception as e:
            logger.error(f"خطا در دریافت مصرف کاربر {username}: {e}")
        
        return None

# ============================================
# کلاس مدیریت تیکت‌ها
# ============================================
class TicketManager:
    @staticmethod
    def save_ticket(user_id, msg, priority="normal"):
        db_manager.execute("""INSERT INTO tickets 
                       (user_id, message, status, priority, created_at) 
                       VALUES (?,?,?,?,?)""",
                      (user_id, msg, "open", priority, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        db_manager.commit()
        ticket_id = db_manager.lastrowid()
        logger.info(f"تیکت جدید #{ticket_id} از کاربر {user_id} ثبت شد")
        return ticket_id
    
    @staticmethod
    def close_ticket(ticket_id, reply):
        db_manager.execute("""UPDATE tickets 
                       SET reply = ?, status = 'closed', closed_at = ? 
                       WHERE id = ?""",
                      (reply, datetime.now().strftime("%Y-%m-%d %H:%M:%S"), ticket_id))
        db_manager.commit()
        logger.info(f"تیکت #{ticket_id} بسته شد")
    
    @staticmethod
    def get_all_open_tickets():
        cursor = db_manager.execute("SELECT * FROM tickets WHERE status = 'open' ORDER BY priority DESC, id ASC")
        return cursor.fetchall()
    
    @staticmethod
    def get_ticket(ticket_id):
        cursor = db_manager.execute("SELECT * FROM tickets WHERE id = ?", (ticket_id,))
        return cursor.fetchone()
    
    @staticmethod
    def get_user_tickets(user_id):
        cursor = db_manager.execute("SELECT * FROM tickets WHERE user_id = ? ORDER BY id DESC", (user_id,))
        return cursor.fetchall()

# ============================================
# کلاس مدیریت کدهای تخفیف
# ============================================
class DiscountManager:
    @staticmethod
    def generate_code(prefix="ZITRON", length=6):
        random_part = secrets.token_hex(length // 2).upper()
        return f"{prefix}_{random_part}"
    
    @staticmethod
    def create_discount_code(code, discount_percent, max_uses, days_valid=30):
        expires_at = (datetime.now() + timedelta(days=days_valid)).strftime("%Y-%m-%d %H:%M:%S")
        try:
            db_manager.execute("""INSERT INTO discount_codes 
                           (code, discount_percent, max_uses, expires_at) 
                           VALUES (?,?,?,?)""",
                          (code, discount_percent, max_uses, expires_at))
            db_manager.commit()
            return True
        except sqlite3.IntegrityError:
            return False
    
    @staticmethod
    def validate_code(code):
        cursor = db_manager.execute("""SELECT * FROM discount_codes 
                       WHERE code = ? AND is_active = 1 
                       AND used_count < max_uses 
                       AND expires_at > ?""",
                      (code, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
        return cursor.fetchone()
    
    @staticmethod
    def use_code(code):
        db_manager.execute("UPDATE discount_codes SET used_count = used_count + 1 WHERE code = ?", (code,))
        db_manager.commit()
    
    @staticmethod
    def calculate_discounted_price(original_price, discount_percent):
        discount_amount = (original_price * discount_percent) / 100
        final_price = original_price - discount_amount
        return int(final_price)

# ============================================
# کلاس مدیریت محدودیت سرعت
# ============================================
class RateLimitManager:
    def __init__(self):
        self.rate_limits = {}
        self.lock = threading.Lock()
        self.last_cleanup = datetime.now()
    
    def _cleanup_old_entries(self):
        now = datetime.now()
        if (now - self.last_cleanup).seconds > 3600:
            with self.lock:
                keys_to_delete = []
                for key, (attempts, last_time) in self.rate_limits.items():
                    if (now - last_time).seconds > 3600:
                        keys_to_delete.append(key)
                for key in keys_to_delete:
                    del self.rate_limits[key]
                self.last_cleanup = now
                if keys_to_delete:
                    logger.info(f"{len(keys_to_delete)} ورودی قدیمی از rate_limits پاکسازی شد")
    
    def check_and_increment(self, user_id, action_type, max_attempts=5, time_window=60):
        self._cleanup_old_entries()
        with self.lock:
            now = datetime.now()
            key = f"{user_id}:{action_type}"
            
            if key in self.rate_limits:
                attempts, last_time = self.rate_limits[key]
                if (now - last_time).seconds < time_window:
                    if attempts >= max_attempts:
                        return False
                    self.rate_limits[key] = (attempts + 1, now)
                else:
                    self.rate_limits[key] = (1, now)
            else:
                self.rate_limits[key] = (1, now)
            
            return True
    
    def reset(self, user_id, action_type):
        with self.lock:
            key = f"{user_id}:{action_type}"
            if key in self.rate_limits:
                del self.rate_limits[key]

rate_limit_manager = RateLimitManager()

# ============================================
# توابع کمکی
# ============================================
def backup_database():
    try:
        if not os.path.exists('zitron.db'):
            logger.warning("فایل دیتابیس وجود ندارد!")
            return None
            
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        backup_name = f"backup_{timestamp}.db"
        
        os.makedirs("backups", exist_ok=True)
        backup_path = os.path.join("backups", backup_name)
        
        shutil.copy('zitron.db', backup_path)
        
        backups = sorted([f for f in os.listdir("backups") if f.endswith('.db')])
        if len(backups) > 30:
            for old_backup in backups[:-30]:
                os.remove(os.path.join("backups", old_backup))
        
        logger.info(f"پشتیبان گرفته شد: {backup_path}")
        return backup_path
    except Exception as e:
        logger.error(f"خطا در پشتیبان‌گیری: {e}")
        return None

def log_admin_action(admin_id, action, target_user, details=""):
    db_manager.execute("""INSERT INTO admin_logs 
                   (admin_id, action, target_user, details, created_at) 
                   VALUES (?,?,?,?,?)""",
                  (admin_id, action, target_user, details, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
    db_manager.commit()

def get_total_users():
    cursor = db_manager.execute("SELECT COUNT(*) FROM users")
    return cursor.fetchone()[0]

def get_total_sales():
    cursor = db_manager.execute("SELECT SUM(price) FROM orders WHERE status = 'completed'")
    result = cursor.fetchone()[0]
    return result or 0

def get_completed_orders():
    cursor = db_manager.execute("SELECT COUNT(*) FROM orders WHERE status = 'completed'")
    return cursor.fetchone()[0]

def get_pending_orders():
    cursor = db_manager.execute("SELECT COUNT(*) FROM orders WHERE status = 'waiting_for_payment'")
    return cursor.fetchone()[0]

def get_expiring_subs(days=3):
    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    expire_date = (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
    cursor = db_manager.execute("""SELECT * FROM subs 
                   WHERE expire_date > ? AND expire_date <= ? AND status = 'active'""",
                  (now, expire_date))
    return cursor.fetchall()

def delete_expired_subs():
    db_manager.execute("UPDATE subs SET status = 'expired' WHERE expire_date < ?",
                  (datetime.now().strftime("%Y-%m-%d %H:%M:%S"),))
    db_manager.commit()
    logger.info("اشتراک‌های منقضی شده به روز رسانی شدند")

def add_pending_operation(user_id, order_id, operation_type, error_msg=""):
    db_manager.execute("""INSERT INTO pending_operations 
                   (user_id, order_id, operation_type, last_error, created_at) 
                   VALUES (?,?,?,?,?)""",
                  (user_id, order_id, operation_type, error_msg, 
                   datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
    db_manager.commit()
    logger.info(f"عملیات معلق برای سفارش #{order_id} ثبت شد - نوع: {operation_type}")

def get_pending_operations():
    cursor = db_manager.execute("""SELECT * FROM pending_operations 
                   WHERE retry_count < 5 ORDER BY created_at ASC, retry_count ASC""")
    return cursor.fetchall()

def update_pending_operation_retry(op_id, error_msg=""):
    db_manager.execute("""UPDATE pending_operations 
                   SET retry_count = retry_count + 1, last_error = ? 
                   WHERE id = ?""",
                  (error_msg, op_id))
    db_manager.commit()

def delete_pending_operation(op_id):
    db_manager.execute("DELETE FROM pending_operations WHERE id = ?", (op_id,))
    db_manager.commit()

def format_number(number):
    return f"{number:,}"

def calculate_price_with_tax(price, tax_percent=0):
    if tax_percent <= 0:
        return price
    return int(price * (1 + tax_percent / 100))

def get_package_days_by_volume(volume):
    for pkg in PACKAGES.values():
        if pkg["gb"] == volume:
            return pkg["days"]
    return 30

# ============================================
# راه‌اندازی ربات (قبل از دکوراتورها)
# ============================================
bot = telebot.TeleBot(BOT_TOKEN)
panel_manager = PanelManager()

# ============================================
# دکوراتورها (بعد از تعریف bot)
# ============================================
def admin_only(func):
    @wraps(func)
    def wrapper(message_or_call):
        user_id = message_or_call.from_user.id
        if user_id != ADMIN_ID:
            bot.send_message(user_id, "❌ شما دسترسی ادمین ندارید!")
            logger.warning(f"دسترسی غیرمجاز به پنل ادمین از کاربر {user_id}")
            return
        return func(message_or_call)
    return wrapper

def rate_limit_decorator(action_type="default", max_attempts=10, time_window=60):
    def decorator(func):
        @wraps(func)
        def wrapper(message_or_call):
            user_id = message_or_call.from_user.id
            
            is_banned, reason = UserManager.is_banned(user_id)
            if is_banned:
                bot.send_message(user_id, f"🚫 حساب شما مسدود شده است!\nدلیل: {reason}\nبرای پیگیری با پشتیبانی تماس بگیرید.")
                return
            
            if not rate_limit_manager.check_and_increment(user_id, action_type, max_attempts, time_window):
                bot.send_message(user_id, f"⏰ شما بیش از حد مجاز درخواست ارسال کرده‌اید! لطفاً {time_window} ثانیه صبر کنید.")
                logger.warning(f"Rate limit exceeded for user {user_id} on {action_type}")
                return
            
            UserManager.update_last_seen(user_id)
            UserManager.reset_daily_usage_if_needed(user_id)
            return func(message_or_call)
        return wrapper
    return decorator

def is_member(user_id):
    try:
        member = bot.get_chat_member(FORCE_CHANNEL, user_id)
        return member.status in ['member', 'administrator', 'creator']
    except Exception as e:
        logger.error(f"خطا در بررسی عضویت کاربر {user_id}: {e}")
        return False

def check_member(func):
    @wraps(func)
    def wrapper(message_or_call):
        user_id = message_or_call.from_user.id
        if not is_member(user_id):
            kb = InlineKeyboardMarkup()
            kb.add(InlineKeyboardButton("📢 عضویت در کانال", url=f"https://t.me/{FORCE_CHANNEL[1:]}"))
            kb.add(InlineKeyboardButton("✅ بررسی عضویت", callback_data="check_member"))
            
            text = f"⚠️ لطفاً ابتدا در کانال زیر عضو شوید:\n\n{FORCE_CHANNEL}\n\nپس از عضویت روی دکمه بررسی کلیک کنید."
            
            if hasattr(message_or_call, 'message'):
                try:
                    bot.edit_message_text(text, user_id, message_or_call.message.message_id, reply_markup=kb)
                except:
                    bot.send_message(user_id, text, reply_markup=kb)
            else:
                bot.send_message(user_id, text, reply_markup=kb)
            return  # رفع باگ #4: اضافه شدن return
        return func(message_or_call)
    return wrapper

# ============================================
# کیبوردها
# ============================================
def main_keyboard():
    kb = ReplyKeyboardMarkup(resize_keyboard=True, row_width=2)
    kb.add(
        KeyboardButton("🛍️ خرید اشتراک جدید"),
        KeyboardButton("📋 اشتراک‌های من")
    )
    kb.add(
        KeyboardButton("🆘 پشتیبانی"),
        KeyboardButton("📚 آموزش و راهنما")
    )
    kb.add(
        KeyboardButton("💰 شارژ کیف پول"),
        KeyboardButton("📊 تاریخچه خرید")
    )
    kb.add(
        KeyboardButton("📈 وضعیت مصرف"),
        KeyboardButton("🎁 کد تخفیف")
    )
    return kb

def packages_keyboard():
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("📦 1 گیگ - 200 ت", callback_data="pkg_1g"),
        InlineKeyboardButton("📦 2 گیگ - 380 ت", callback_data="pkg_2g"),
        InlineKeyboardButton("📦 5 گیگ - 900 ت", callback_data="pkg_5g"),
        InlineKeyboardButton("📦 10 گیگ - 1,700 ت", callback_data="pkg_10g"),
        InlineKeyboardButton("📦 20 گیگ - 3,200 ت", callback_data="pkg_20g"),
        InlineKeyboardButton("📦 50 گیگ - 7,500 ت", callback_data="pkg_50g")
    )
    kb.add(
        InlineKeyboardButton("🔥 ویژه 5 گیگ - 800 ت", callback_data="pkg_special"),
        InlineKeyboardButton("✏️ حجم دلخواه", callback_data="custom_volume"),
        InlineKeyboardButton("🎁 کد تخفیف دارم", callback_data="apply_discount")
    )
    kb.add(
        InlineKeyboardButton("🔙 بازگشت", callback_data="back_main")
    )
    return kb

def payment_keyboard(order_id):
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("💳 کارت به کارت", callback_data=f"pay_card_{order_id}"),
        InlineKeyboardButton("💰 ارزی (USDT)", callback_data=f"pay_crypto_{order_id}")
    )
    kb.add(
        InlineKeyboardButton("🎁 استفاده از کد تخفیف", callback_data=f"apply_discount_to_order_{order_id}")
    )
    kb.add(InlineKeyboardButton("❌ انصراف", callback_data="cancel_order"))
    return kb

def invoice_keyboard(order_id, original_price, discounted_price=None):
    kb = InlineKeyboardMarkup(row_width=2)
    price_text = f"💰 پرداخت {discounted_price:,} تومان" if discounted_price else f"💰 پرداخت {original_price:,} تومان"
    kb.add(
        InlineKeyboardButton(price_text, callback_data=f"confirm_order_{order_id}"),
        InlineKeyboardButton("🎁 کد تخفیف", callback_data=f"apply_discount_to_order_{order_id}"),
        InlineKeyboardButton("❌ انصراف", callback_data="back_main")
    )
    return kb

def back_keyboard():
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("🔙 بازگشت به صفحه اصلی", callback_data="back_main"))
    return kb

def renew_keyboard(sub_id, sub_volume):
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("🔄 تمدید اشتراک", callback_data=f"renew_{sub_id}_{sub_volume}"))
    kb.add(InlineKeyboardButton("📊 مصرف", callback_data=f"usage_{sub_id}"))
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="back_main"))
    return kb

def admin_main_keyboard():
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("📦 سفارشات در انتظار", callback_data="admin_pending_orders"),
        InlineKeyboardButton("💰 مدیریت کیف پول", callback_data="admin_wallet"),
        InlineKeyboardButton("📩 تیکت‌های باز", callback_data="admin_tickets"),
        InlineKeyboardButton("📊 آمار پیشرفته", callback_data="admin_stats")
    )
    kb.add(
        InlineKeyboardButton("📢 ارسال همگانی", callback_data="admin_broadcast"),
        InlineKeyboardButton("📋 مدیریت کاربران", callback_data="admin_users_list"),
        InlineKeyboardButton("🎁 مدیریت تخفیف‌ها", callback_data="admin_discounts"),
        InlineKeyboardButton("⚙️ تنظیمات", callback_data="admin_settings")
    )
    return kb

# ============================================
# متغیر کنترل تسک‌های زمانبندی شده (رفع باگ #10)
# ============================================
_task_started = False

# ============================================
# تسک‌های زمانبندی شده
# ============================================
def scheduled_tasks():
    global _task_started
    if _task_started:
        return
    _task_started = True
    
    last_backup_date = None
    
    while True:
        try:
            now = datetime.now()
            
            delete_expired_subs()
            process_pending_operations()
            
            if now.hour == 9 and now.minute == 0:
                expiring_subs = get_expiring_subs(3)
                for sub in expiring_subs:
                    user_id = sub[1]
                    expire_date = datetime.strptime(sub[5], "%Y-%m-%d %H:%M:%S")
                    days_left = (expire_date - now).days
                    
                    if days_left <= 3 and days_left > 0:
                        bot.send_message(
                            user_id,
                            f"⚠️ **اشتراک شما {days_left} روز دیگر منقضی می‌شود!**\n\n"
                            f"📦 حجم: {sub[2]} گیگابایت\n"
                            f"📅 تاریخ انقضا: {sub[5]}\n\n"
                            f"برای تمدید از بخش «اشتراک‌های من» اقدام کنید.",
                            parse_mode='Markdown'
                        )
                        logger.info(f"یادآوری انقضا برای کاربر {user_id} ارسال شد")
            
            if now.hour == 4 and now.minute == 0 and last_backup_date != now.date():
                backup_path = backup_database()
                if backup_path:
                    logger.info(f"پشتیبان روزانه گرفته شد: {backup_path}")
                    if ADMIN_ID:
                        bot.send_document(ADMIN_ID, open(backup_path, 'rb'), caption=f"✅ پشتیبان روزانه - {now.strftime('%Y-%m-%d')}")
                last_backup_date = now.date()
            
            time.sleep(60)
            
        except Exception as e:
            logger.error(f"خطا در تسک زمانبندی شده: {e}")
            time.sleep(300)

def process_pending_operations():
    operations = get_pending_operations()
    
    for op in operations:
        try:
            op_id = op[0]
            user_id = op[1]
            order_id = op[2]
            operation_type = op[3]
            retry_count = op[4]
            
            if operation_type == "create_subscription":
                order = OrderManager.get_order(order_id)
                if order:
                    volume = order[2]
                    
                    active_subs_count = SubscriptionManager.get_active_subs_count(user_id)
                    if active_subs_count >= MAX_ACTIVE_SUBS:
                        bot.send_message(
                            user_id,
                            f"⚠️ شما حداکثر {MAX_ACTIVE_SUBS} اشتراک فعال می‌توانید داشته باشید.\n"
                            "لطفاً ابتدا یکی از اشتراک‌های قدیمی خود را حذف کنید یا منتظر انقضای آن باشید.",
                            reply_markup=main_keyboard()
                        )
                        delete_pending_operation(op_id)
                        continue
                    
                    days = get_package_days_by_volume(volume)
                    result = panel_manager.create_user_in_panel_with_retry(user_id, volume, days=days, retries=3)
                    
                    if result:
                        expire = (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
                        SubscriptionManager.save_sub(user_id, volume, result["url"], result["username"], expire)
                        OrderManager.update_order(order_id, "completed")
                        UserManager.increment_purchases(user_id, order[3])
                        
                        bot.send_message(
                            user_id,
                            f"✅ **اشتراک شما با موفقیت فعال شد!**\n\n"
                            f"📦 حجم: {volume} گیگابایت\n"
                            f"📅 اعتبار: {days} روز\n"
                            f"🔗 **لینک اشتراک:**\n`{result['url']}`\n\n"
                            f"📅 تاریخ انقضا: {expire}\n\n"
                            f"⚠️ لطفاً لینک را ذخیره کنید.\n"
                            f"💡 برای نصب و استفاده به بخش «آموزش و راهنما» مراجعه کنید.",
                            parse_mode='Markdown',
                            reply_markup=main_keyboard()
                        )
                        delete_pending_operation(op_id)
                        logger.info(f"عملیات معلق #{op_id} با موفقیت انجام شد - سفارش #{order_id}")
                    else:
                        update_pending_operation_retry(op_id, "خطا در اتصال به پنل")
                        logger.warning(f"تلاش مجدد {retry_count + 1} برای عملیات #{op_id}")
                        
                        if retry_count >= 4:
                            bot.send_message(
                                user_id,
                                f"❌ **متأسفانه در فعال‌سازی اشتراک شما خطایی رخ داده است!**\n\n"
                                f"کد سفارش: {order_id}\n\n"
                                f"لطفاً با پشتیبانی تماس بگیرید و کد سفارش را ارائه دهید.",
                                reply_markup=main_keyboard()
                            )
                            bot.send_message(
                                ADMIN_ID,
                                f"⚠️ خطا در فعال‌سازی سفارش #{order_id} پس از 5 تلاش\n"
                                f"کاربر: {user_id}\n"
                                f"حجم: {volume}GB"
                            )
                            delete_pending_operation(op_id)
            
            time.sleep(1)
            
        except Exception as e:
            logger.error(f"خطا در پردازش عملیات معلق: {e}")

# ============================================
# هندلرهای استارت و عضویت
# ============================================
@bot.message_handler(commands=['start'])
def cmd_start(message):
    user = message.from_user
    UserManager.add_user(user.id, user.username, user.first_name)
    logger.info(f"کاربر {user.id} استارت زد")
    
    welcome = f"""
✨ **به ربات زیتون شاپ خوش آمدی {user.first_name}!** ✨

🌿 **فروشگاه تخصصی کانفیگ با بهترین کیفیت**

🎯 **ویژگی‌ها:**
• 🚀 ارسال خودکار پس از پرداخت
• 💬 پشتیبانی ۲۴ ساعته
• 💰 کیف پول داخلی با قابلیت شارژ
• 📊 مشاهده مصرف لحظه‌ای
• 🎁 کدهای تخفیف ویژه
• 🔒 امنیت بالا و تحویل آنی

💎 **برای استفاده از ربات، لطفاً ابتدا در کانال زیر عضو شوید:**
"""
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("📢 عضویت در کانال", url=f"https://t.me/{FORCE_CHANNEL[1:]}"))
    kb.add(InlineKeyboardButton("✅ بررسی عضویت", callback_data="check_member"))
    bot.send_message(user.id, welcome, reply_markup=kb, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "check_member")
def check_member_cb(call):
    if is_member(call.from_user.id):
        wallet = UserManager.get_wallet(call.from_user.id)
        text = MAIN_MENU_TEXT.format(
            name=call.from_user.first_name,
            wallet=format_number(wallet)
        )
        try:
            bot.edit_message_text(text, call.from_user.id, call.message.message_id,
                                 reply_markup=main_keyboard(), parse_mode='Markdown')
        except:
            bot.send_message(call.from_user.id, text, reply_markup=main_keyboard(), parse_mode='Markdown')
    else:
        bot.answer_callback_query(call.id, "❌ هنوز عضو نشدی! لطفاً ابتدا عضو شوید.", show_alert=True)

@bot.message_handler(func=lambda m: m.text == "🔙 بازگشت به صفحه اصلی" or m.text == "🏠 صفحه اصلی")
@check_member
@rate_limit_decorator("main_menu")
def go_main(message):
    wallet = UserManager.get_wallet(message.from_user.id)
    text = MAIN_MENU_TEXT.format(
        name=message.from_user.first_name,
        wallet=format_number(wallet)
    )
    bot.send_message(message.from_user.id, text, reply_markup=main_keyboard(), parse_mode='Markdown')

# ============================================
# خرید اشتراک
# ============================================
@bot.message_handler(func=lambda m: m.text == "🛍️ خرید اشتراک جدید")
@check_member
@rate_limit_decorator("buy_package")
def buy_new(message):
    active_count = SubscriptionManager.get_active_subs_count(message.from_user.id)
    
    if active_count >= MAX_ACTIVE_SUBS:
        bot.send_message(
            message.from_user.id,
            f"⚠️ **شما حداکثر {MAX_ACTIVE_SUBS} اشتراک فعال می‌توانید داشته باشید!**\n\n"
            f"📊 تعداد اشتراک‌های فعال شما: {active_count}\n\n"
            f"لطفاً منتظر انقضای اشتراک‌های قدیمی خود باشید یا از بخش «اشتراک‌های من» آن‌ها را مدیریت کنید.",
            reply_markup=main_keyboard(),
            parse_mode='Markdown'
        )
        return
    
    text = """
📦 **پکیج‌های موجود:**  

• 1 گیگابایت → 200 تومان (30 روز)
• 2 گیگابایت → 380 تومان (30 روز)
• 5 گیگابایت → 900 تومان (30 روز)
• 10 گیگابایت → 1,700 تومان (45 روز)
• 20 گیگابایت → 3,200 تومان (60 روز)
• 50 گیگابایت → 7,500 تومان (90 روز)

🔥 **پکیج ویژه:** 5 گیگابایت با 20% تخفیف → 800 تومان

روی هر کدام که خواستی کلیک کن:
"""
    bot.send_message(message.from_user.id, text, reply_markup=packages_keyboard(), parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data.startswith("pkg_"))
def select_package(call):
    pkg_key = call.data.replace("pkg_", "")
    pkg = PACKAGES.get(pkg_key)
    
    if not pkg:
        bot.answer_callback_query(call.id, "پکیج یافت نشد!")
        return
    
    active_count = SubscriptionManager.get_active_subs_count(call.from_user.id)
    if active_count >= MAX_ACTIVE_SUBS:
        bot.answer_callback_query(call.id, f"⚠️ شما حداکثر {MAX_ACTIVE_SUBS} اشتراک فعال می‌توانید داشته باشید!", show_alert=True)
        return
    
    wallet = UserManager.get_wallet(call.from_user.id)
    order_id = OrderManager.save_order(call.from_user.id, pkg["gb"], pkg["price"], None)
    
    UserManager.lock_wallet_amount(call.from_user.id, pkg["price"])
    
    text = f"""
🧾 **فاکتور خرید**

📦 محصول: {pkg['name']}
💾 حجم: {pkg['gb']} گیگابایت
💰 قیمت: {format_number(pkg['price'])} تومان
📅 اعتبار: {pkg['days']} روز

💳 موجودی کیف پول: {format_number(wallet)} تومان

✅ در صورت موجودی کافی، مبلغ از کیف پول کسر می‌شود.
❌ در غیر این صورت می‌توانید با کارت یا ارزی پرداخت کنید.

🆔 کد سفارش: {order_id}
"""
    bot.edit_message_text(
        text,
        call.from_user.id,
        call.message.message_id,
        reply_markup=invoice_keyboard(order_id, pkg["price"]),
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "custom_volume")
def custom_vol(call):
    msg = bot.send_message(
        call.from_user.id,
        "✏️ **حجم مورد نظر خود را به گیگابایت وارد کنید:**\n\n"
        "مثال: 15\n"
        "حداقل: 1 گیگابایت | حداکثر: 500 گیگابایت",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, process_custom_volume)

def process_custom_volume(message):
    try:
        vol = float(message.text.strip())
        
        if vol <= 0 or vol > 500:
            bot.send_message(
                message.from_user.id,
                "❌ حجم باید بین 1 تا 500 گیگابایت باشد!",
                reply_markup=main_keyboard()
            )
            return
        
        if vol != int(vol):
            bot.send_message(
                message.from_user.id,
                "❌ لطفاً حجم را به صورت عدد صحیح وارد کنید!",
                reply_markup=main_keyboard()
            )
            return
        
        vol = int(vol)
        price = vol * PRICE_PER_GB
        
        active_count = SubscriptionManager.get_active_subs_count(message.from_user.id)
        if active_count >= MAX_ACTIVE_SUBS:
            bot.send_message(
                message.from_user.id,
                f"⚠️ شما حداکثر {MAX_ACTIVE_SUBS} اشتراک فعال می‌توانید داشته باشید!",
                reply_markup=main_keyboard()
            )
            return
        
        wallet = UserManager.get_wallet(message.from_user.id)
        order_id = OrderManager.save_order(message.from_user.id, vol, price, None)
        UserManager.lock_wallet_amount(message.from_user.id, price)
        
        text = f"""
🧾 **فاکتور خرید حجم دلخواه**

📦 حجم: {vol} گیگابایت
💰 قیمت: {format_number(price)} تومان
📅 اعتبار: 30 روز

💳 موجودی کیف پول: {format_number(wallet)} تومان

🆔 کد سفارش: {order_id}
"""
        bot.send_message(
            message.from_user.id,
            text,
            reply_markup=invoice_keyboard(order_id, price),
            parse_mode='Markdown'
        )
        
    except ValueError:
        bot.send_message(message.from_user.id, "❌ عدد نامعتبر! لطفاً یک عدد وارد کنید.", reply_markup=main_keyboard())

@bot.callback_query_handler(func=lambda call: call.data == "apply_discount")
def apply_discount_menu(call):
    msg = bot.send_message(
        call.from_user.id,
        "🎁 **کد تخفیف خود را وارد کنید:**\n\n"
        "اگر کد تخفیف دارید، آن را در اینجا وارد کنید.",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, process_discount_code_standalone)

def process_discount_code_standalone(message):
    if not message.text:
        bot.send_message(message.from_user.id, "❌ لطفاً یک کد معتبر وارد کنید!", reply_markup=packages_keyboard())
        return
    
    code = message.text.strip().upper()
    discount = DiscountManager.validate_code(code)
    
    if discount:
        discount_percent = discount[2]
        bot.send_message(
            message.from_user.id,
            f"✅ **کد تخفیف معتبر است!**\n\n"
            f"🎁 تخفیف: {discount_percent}%\n"
            f"📊 تعداد دفعات باقی‌مانده: {discount[3] - discount[4]}\n\n"
            f"لطفاً ابتدا پکیج مورد نظر خود را انتخاب کنید، سپس در صفحه فاکتور از گزینه «کد تخفیف» استفاده کنید.",
            reply_markup=packages_keyboard()
        )
    else:
        bot.send_message(
            message.from_user.id,
            "❌ کد تخفیف نامعتبر است! لطفاً کد صحیح را وارد کنید یا از پکیج‌های عادی استفاده نمایید.",
            reply_markup=packages_keyboard()
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith("apply_discount_to_order_"))
def apply_discount_to_order(call):
    order_id = int(call.data.replace("apply_discount_to_order_", ""))
    
    if not OrderManager.validate_order_access(call.from_user.id, order_id):
        bot.answer_callback_query(call.id, "❌ این سفارش متعلق به شما نیست!")
        return
    
    order = OrderManager.get_order(order_id)
    if not order:
        bot.answer_callback_query(call.id, "سفارش یافت نشد!")
        return
    
    msg = bot.send_message(
        call.from_user.id,
        "🎁 **کد تخفیف خود را وارد کنید:**",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: apply_discount_code(m, order_id, order[3], call.message.message_id))

def apply_discount_code(message, order_id, original_price, original_message_id):
    if not message.text:
        bot.send_message(message.from_user.id, "❌ لطفاً یک کد معتبر وارد کنید!", reply_markup=invoice_keyboard(order_id, original_price))
        return
    
    code = message.text.strip().upper()
    discount = DiscountManager.validate_code(code)
    
    if discount:
        discount_percent = discount[2]
        discounted_price = DiscountManager.calculate_discounted_price(original_price, discount_percent)
        
        if not hasattr(bot, 'discount_cache'):
            bot.discount_cache = {}
        bot.discount_cache[order_id] = {"code": code, "percent": discount_percent, "price": discounted_price}
        
        text = f"""
🧾 **فاکتور با تخفیف**

💰 قیمت اصلی: {format_number(original_price)} تومان
🎁 تخفیف {discount_percent}%: -{format_number(original_price - discounted_price)} تومان
✅ **قیمت نهایی: {format_number(discounted_price)} تومان**

🆔 کد سفارش: {order_id}

برای ادامه روی دکمه زیر کلیک کنید:
"""
        bot.edit_message_text(
            text,
            message.from_user.id,
            original_message_id,
            reply_markup=invoice_keyboard(order_id, original_price, discounted_price),
            parse_mode='Markdown'
        )
    else:
        bot.send_message(
            message.from_user.id,
            "❌ کد تخفیف نامعتبر است!",
            reply_markup=invoice_keyboard(order_id, original_price)
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith("confirm_order_"))
def confirm_order(call):
    order_id = int(call.data.replace("confirm_order_", ""))
    
    if not OrderManager.validate_order_access(call.from_user.id, order_id):
        bot.answer_callback_query(call.id, "❌ این سفارش متعلق به شما نیست!")
        return
    
    order = OrderManager.get_order(order_id)
    if not order:
        bot.answer_callback_query(call.id, "سفارش یافت نشد!")
        return
    
    volume, price, user_id = order[2], order[3], order[1]
    
    final_price = price
    discount_code = None
    if hasattr(bot, 'discount_cache') and order_id in bot.discount_cache:
        final_price = bot.discount_cache[order_id]["price"]
        discount_code = bot.discount_cache[order_id]["code"]
    
    wallet = UserManager.get_wallet(user_id)
    
    if wallet >= final_price:
        UserManager.unlock_wallet_amount(user_id, price)
        
        if UserManager.update_wallet(user_id, -final_price, f"خرید اشتراک #{order_id}"):
            OrderManager.update_order(order_id, "processing")
            
            if discount_code:
                DiscountManager.use_code(discount_code)
            
            if not SubscriptionManager.can_create_new_sub(user_id):
                UserManager.update_wallet(user_id, final_price, "برگشت وجه به دلیل محدودیت اشتراک")
                bot.edit_message_text(
                    f"⚠️ شما حداکثر {MAX_ACTIVE_SUBS} اشتراک فعال می‌توانید داشته باشید!\n\n"
                    f"مبلغ {format_number(final_price)} تومان به کیف پول شما برگشت داده شد.",
                    user_id,
                    call.message.message_id,
                    parse_mode='Markdown'
                )
                return
            
            days = get_package_days_by_volume(volume)
            result = panel_manager.create_user_in_panel_with_retry(user_id, volume, days=days)
            
            if result:
                expire = (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
                SubscriptionManager.save_sub(user_id, volume, result["url"], result["username"], expire)
                OrderManager.update_order(order_id, "completed")
                UserManager.increment_purchases(user_id, final_price)
                
                bot.edit_message_text(
                    f"✅ **پرداخت موفق از کیف پول!**\n\n"
                    f"🎁 اشتراک {volume} گیگابایتی با موفقیت فعال شد.\n\n"
                    f"📅 اعتبار: {days} روز\n"
                    f"🔗 **لینک اشتراک:**\n`{result['url']}`\n\n"
                    f"📅 تاریخ انقضا: {expire}\n\n"
                    f"⚠️ لطفاً لینک را ذخیره کنید.\n"
                    f"💡 برای نصب و استفاده به بخش «آموزش و راهنما» مراجعه کنید.",
                    user_id,
                    call.message.message_id,
                    parse_mode='Markdown'
                )
                bot.send_message(user_id, "🏠 صفحه اصلی", reply_markup=main_keyboard())
                logger.info(f"پرداخت موفق برای کاربر {user_id} - سفارش #{order_id} - مبلغ: {final_price}")
            else:
                UserManager.update_wallet(user_id, final_price, "برگشت وجه به دلیل خطا در ساخت اشتراک")
                add_pending_operation(user_id, order_id, "create_subscription")
                bot.edit_message_text(
                    "⚠️ **سیستم در حال پردازش سفارش شماست**\n\n"
                    "به دلیل ترافیک بالا، اشتراک شما حداکثر تا چند دقیقه دیگر فعال می‌شود.\n"
                    "نیازی به پیگیری نیست، به صورت خودکار فعال می‌شود.\n\n"
                    "پس از فعال‌سازی، پیام تایید برای شما ارسال می‌شود.",
                    user_id,
                    call.message.message_id,
                    parse_mode='Markdown'
                )
                logger.error(f"خطا در ساخت اشتراک برای کاربر {user_id} - سفارش #{order_id}")
    else:
        UserManager.unlock_wallet_amount(user_id, price)
        
        bot.edit_message_text(
            f"⚠️ **موجودی کیف پول کافی نیست!**\n\n"
            f"💰 موجودی شما: {format_number(wallet)} تومان\n"
            f"💵 مبلغ قابل پرداخت: {format_number(final_price)} تومان\n\n"
            f"لطفاً روش پرداخت خود را انتخاب کنید:",
            call.from_user.id,
            call.message.message_id,
            reply_markup=payment_keyboard(order_id),
            parse_mode='Markdown'
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith("pay_card_"))
def pay_card(call):
    order_id = int(call.data.replace("pay_card_", ""))
    
    if not OrderManager.validate_order_access(call.from_user.id, order_id):
        bot.answer_callback_query(call.id, "❌ این سفارش متعلق به شما نیست!")
        return
    
    order = OrderManager.get_order(order_id)
    if not order:
        bot.answer_callback_query(call.id, "خطا!")
        return
    
    volume, price = order[2], order[3]
    
    final_price = price
    if hasattr(bot, 'discount_cache') and order_id in bot.discount_cache:
        final_price = bot.discount_cache[order_id]["price"]
    
    OrderManager.update_order(order_id, "waiting_for_payment")
    
    text = f"""
💳 **پرداخت کارت به کارت**

🏦 **شماره کارت:** {CARD_INFO}

💰 **مبلغ:** {format_number(final_price)} تومان

📝 **مراحل پرداخت:**
1️⃣ مبلغ دقیق {format_number(final_price)} تومان را به کارت بالا واریز کنید
2️⃣ بعد از واریز، روی دکمه «ارسال رسید» کلیک کنید
3️⃣ تصویر رسید را ارسال کنید
4️⃣ پس از تایید ادمین، اشتراک شما فعال می‌شود

🆔 **کد سفارش:** {order_id}

⏱️ توجه: رسید شما حداکثر تا 24 ساعت تایید می‌شود.
"""
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("📸 ارسال رسید", callback_data=f"send_receipt_{order_id}"))
    kb.add(InlineKeyboardButton("🔙 انصراف", callback_data="back_main"))
    
    bot.edit_message_text(
        text,
        call.from_user.id,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )
    
    bot.send_message(
        ADMIN_ID,
        f"💳 سفارش کارت به کارت جدید #{order_id}\n"
        f"👤 کاربر: {call.from_user.id} (@{call.from_user.username})\n"
        f"📦 حجم: {volume}GB\n"
        f"💰 مبلغ: {format_number(final_price)}"
    )
    logger.info(f"سفارش #{order_id} در انتظار پرداخت کارتی - کاربر: {call.from_user.id}")

@bot.callback_query_handler(func=lambda call: call.data.startswith("pay_crypto_"))
def pay_crypto(call):
    order_id = int(call.data.replace("pay_crypto_", ""))
    
    if not OrderManager.validate_order_access(call.from_user.id, order_id):
        bot.answer_callback_query(call.id, "❌ این سفارش متعلق به شما نیست!")
        return
    
    order = OrderManager.get_order(order_id)
    if not order:
        bot.answer_callback_query(call.id, "خطا!")
        return
    
    volume, price = order[2], order[3]
    
    final_price = price
    if hasattr(bot, 'discount_cache') and order_id in bot.discount_cache:
        final_price = bot.discount_cache[order_id]["price"]
    
    usdt_amount = Decimal(final_price) / Decimal(USDT_RATE)
    usdt_amount = usdt_amount.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
    
    OrderManager.update_order(order_id, "waiting_for_payment")
    
    text = f"""
💰 **پرداخت ارزی (USDT)**

🔗 **آدرس ولت (TRC20):** `{USDT_WALLET}`

💵 **مبلغ به تومان:** {format_number(final_price)} تومان
🪙 **مبلغ به USDT:** {usdt_amount} USDT
💱 **نرخ تبدیل:** هر 1 USDT = {format_number(USDT_RATE)} تومان

📝 **مراحل پرداخت:**
1️⃣ مبلغ دقیق {usdt_amount} USDT را به آدرس بالا واریز کنید
2️⃣ بعد از واریز، روی دکمه «اعلام پرداخت» کلیک کنید
3️⃣ پس از تایید ادمین، اشتراک شما فعال می‌شود

🆔 **کد سفارش:** {order_id}

⚠️ **توجه:** حتماً از شبکه TRC20 استفاده کنید. ارسال با شبکه دیگر باعث از دست رفتن وجوه می‌شود.
"""
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("💰 اعلام پرداخت", callback_data=f"crypto_paid_{order_id}"))
    kb.add(InlineKeyboardButton("🔙 انصراف", callback_data="back_main"))
    
    bot.edit_message_text(
        text,
        call.from_user.id,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )
    
    bot.send_message(
        ADMIN_ID,
        f"💰 سفارش ارزی #{order_id}\n"
        f"👤 کاربر: {call.from_user.id} (@{call.from_user.username})\n"
        f"📦 حجم: {volume}GB\n"
        f"🪙 USDT: {usdt_amount}\n"
        f"💵 تومان: {format_number(final_price)}"
    )
    logger.info(f"سفارش ارزی #{order_id} ثبت شد - کاربر: {call.from_user.id}")

@bot.callback_query_handler(func=lambda call: call.data.startswith("send_receipt_"))
def send_receipt(call):
    order_id = int(call.data.replace("send_receipt_", ""))
    msg = bot.send_message(
        call.from_user.id,
        "📸 **لطفاً عکس رسید واریز را ارسال کنید:**\n\n"
        "اطمینان حاصل کنید که:\n"
        "• مبلغ دقیق واریز شده باشد\n"
        "• تاریخ و ساعت در رسید مشخص باشد\n"
        "• تصویر خوانا باشد",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: save_receipt(m, order_id))

def save_receipt(message, order_id):
    if message.photo:
        file_id = message.photo[-1].file_id
        caption = (
            f"📸 رسید سفارش #{order_id}\n"
            f"👤 کاربر: {message.from_user.id}\n"
            f"📝 نام: @{message.from_user.username or message.from_user.first_name}\n"
            f"📅 تاریخ: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
        )
        ReceiptManager.save_receipt(order_id, message.from_user.id, file_id, "photo")
        bot.send_photo(ADMIN_ID, file_id, caption=caption)
        bot.send_message(
            message.from_user.id,
            "✅ رسید شما با موفقیت ارسال و در سیستم ذخیره شد.\n"
            "پس از تایید ادمین، اشتراک شما فعال می‌شود.\n\n"
            "شما می‌توانید از بخش «تاریخچه خرید» وضعیت سفارش خود را پیگیری کنید.",
            reply_markup=main_keyboard()
        )
        logger.info(f"رسید سفارش #{order_id} از کاربر {message.from_user.id} ارسال و ذخیره شد")
    else:
        bot.send_message(
            message.from_user.id,
            "❌ لطفاً یک عکس معتبر ارسال کنید!\n"
            "دوباره روی دکمه «ارسال رسید» کلیک کنید و تصویر را بفرستید.",
            reply_markup=main_keyboard()
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith("crypto_paid_"))
def crypto_paid(call):
    order_id = int(call.data.replace("crypto_paid_", ""))
    
    bot.send_message(
        ADMIN_ID,
        f"💰 اعلام پرداخت ارزی سفارش #{order_id}\n"
        f"👤 کاربر: {call.from_user.id} (@{call.from_user.username})\n"
        f"📅 زمان: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
    )
    
    bot.edit_message_text(
        "✅ **درخواست شما با موفقیت ثبت شد!**\n\n"
        "پس از تایید ادمین و تایید تراکنش در بلاک‌چین، اشتراک شما فعال می‌شود.\n"
        "این فرآیند معمولاً چند دقیقه تا چند ساعت طول می‌کشد.",
        call.from_user.id,
        call.message.message_id,
        parse_mode='Markdown'
    )
    logger.info(f"اعلام پرداخت ارزی برای سفارش #{order_id} - کاربر: {call.from_user.id}")

# ============================================
# اشتراک‌های من و تمدید
# ============================================
@bot.message_handler(func=lambda m: m.text == "📋 اشتراک‌های من")
@check_member
@rate_limit_decorator("my_subs")
def my_subs(message):
    subs = SubscriptionManager.get_user_subs(message.from_user.id)
    
    if not subs:
        bot.send_message(
            message.from_user.id,
            "❌ **شما هیچ اشتراک فعالی ندارید.**\n\n"
            "از بخش «خرید اشتراک جدید» اقدام به خرید کنید.\n\n"
            "✨ نکته: اشتراک‌ها پس از خرید به صورت خودکار فعال می‌شوند.",
            reply_markup=main_keyboard(),
            parse_mode='Markdown'
        )
        return
    
    active_count = len(subs)
    total_volume = sum([sub[2] for sub in subs])
    
    info_text = f"📊 **خلاصه اشتراک‌های شما:**\n"
    info_text += f"• تعداد اشتراک فعال: {active_count}\n"
    info_text += f"• مجموع حجم: {total_volume} گیگابایت\n"
    info_text += f"• حداکثر مجاز: {MAX_ACTIVE_SUBS} اشتراک\n\n"
    info_text += f"━━━━━━━━━━━━━━━━━━\n\n"
    
    bot.send_message(message.from_user.id, info_text, parse_mode='Markdown')
    
    for sub in subs:
        sub_id = sub[0]
        volume = sub[2]
        sub_link = sub[3]
        expire = sub[5]
        created_at = sub[6]
        
        expire_date = datetime.strptime(expire, "%Y-%m-%d %H:%M:%S")
        days_left = (expire_date - datetime.now()).days
        hours_left = (expire_date - datetime.now()).seconds // 3600
        
        if days_left > 0:
            time_left = f"{days_left} روز و {hours_left} ساعت"
        elif hours_left > 0:
            time_left = f"{hours_left} ساعت"
        else:
            time_left = "کمتر از یک ساعت"
        
        usage = panel_manager.get_user_usage_from_panel(sub[4])
        
        text = f"🔹 **اشتراک #{sub_id}**\n"
        text += f"📦 حجم: {volume} گیگابایت\n"
        text += f"📅 تاریخ ساخت: {created_at[:10]}\n"
        text += f"⏰ انقضا: {expire} ({time_left} مونده)\n"
        
        if usage:
            used_gb = usage['used_gb']
            total_gb = usage['total_gb']
            percent = usage['used_percent']
            text += f"📊 مصرف: {used_gb:.1f} / {total_gb:.1f} GB ({percent:.0f}%)\n"
            text += get_usage_bar(percent)
        
        text += f"\n🔗 لینک: `{sub_link[:50]}...`\n\n"
        
        kb = renew_keyboard(sub_id, volume)
        bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')
        time.sleep(0.3)

@bot.callback_query_handler(func=lambda call: call.data.startswith("renew_"))
def renew_subscription(call):
    parts = call.data.split("_")
    sub_id = int(parts[1])
    volume = int(parts[2])
    
    active_count = SubscriptionManager.get_active_subs_count(call.from_user.id)
    if active_count >= MAX_ACTIVE_SUBS:
        bot.answer_callback_query(
            call.id,
            f"⚠️ شما حداکثر {MAX_ACTIVE_SUBS} اشتراک فعال می‌توانید داشته باشید!",
            show_alert=True
        )
        return
    
    price = volume * PRICE_PER_GB
    wallet = UserManager.get_wallet(call.from_user.id)
    
    if wallet >= price:
        if UserManager.update_wallet(call.from_user.id, -price, f"تمدید اشتراک #{sub_id}"):
            days = get_package_days_by_volume(volume)
            result = panel_manager.create_user_in_panel_with_retry(call.from_user.id, volume, days=days)
            
            if result:
                expire = (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
                new_sub_id = SubscriptionManager.save_sub(
                    call.from_user.id, volume, result["url"], result["username"], expire
                )
                SubscriptionManager.deactivate_sub(sub_id)
                
                bot.edit_message_text(
                    f"✅ **اشتراک با موفقیت تمدید شد!**\n\n"
                    f"🎁 اشتراک جدید {volume} گیگابایتی فعال شد.\n"
                    f"📅 اعتبار: {days} روز\n"
                    f"🆔 شناسه جدید: #{new_sub_id}\n\n"
                    f"🔗 **لینک اشتراک جدید:**\n`{result['url']}`\n\n"
                    f"📅 تاریخ انقضا: {expire}\n\n"
                    f"⚠️ لطفاً از لینک جدید استفاده کنید.",
                    call.from_user.id,
                    call.message.message_id,
                    parse_mode='Markdown'
                )
                logger.info(f"تمدید اشتراک برای کاربر {call.from_user.id} - حجم: {volume}GB")
            else:
                UserManager.update_wallet(call.from_user.id, price, "برگشت وجه تمدید به دلیل خطا")
                bot.edit_message_text(
                    "❌ خطا در تمدید اشتراک!\n\n"
                    "لطفاً چند دقیقه دیگر تلاش کنید یا با پشتیبانی تماس بگیرید.",
                    call.from_user.id,
                    call.message.message_id,
                    parse_mode='Markdown'
                )
    else:
        bot.edit_message_text(
            f"⚠️ **موجودی کیف پول کافی نیست!**\n\n"
            f"💰 موجودی شما: {format_number(wallet)} تومان\n"
            f"💵 مبلغ نیاز: {format_number(price)} تومان\n\n"
            f"لطفاً کیف پول خود را از طریق بخش «شارژ کیف پول» افزایش دهید.",
            call.from_user.id,
            call.message.message_id,
            parse_mode='Markdown'
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith("usage_"))
def show_usage_detail(call):
    sub_id = int(call.data.replace("usage_", ""))
    
    cursor = db_manager.execute("SELECT panel_username, volume FROM subs WHERE id = ?", (sub_id,))
    sub = cursor.fetchone()
    
    if sub:
        username = sub[0]
        volume = sub[1]
        
        usage = panel_manager.get_user_usage_from_panel(username)
        
        if usage:
            used_percent = usage['used_percent']
            remaining_gb = usage['total_gb'] - usage['used_gb']
            
            text = f"📊 **مصرف دقیق اشتراک**\n\n"
            text += f"📦 حجم کل: {usage['total_gb']:.1f} GB\n"
            text += f"📈 مصرف شده: {usage['used_gb']:.1f} GB\n"
            text += f"📉 باقی‌مانده: {remaining_gb:.1f} GB\n"
            text += f"📊 درصد مصرف: {used_percent:.1f}%\n\n"
            text += get_usage_bar(used_percent) + "\n"
            
            if used_percent > 90:
                text += "⚠️ **هشدار مصرف!** میزان مصرف شما بالاست. لطفاً به زودی تمدید کنید.\n"
            elif used_percent > 70:
                text += "⚠️ مصرف شما بالاست، پیشنهاد می‌شود به زودی تمدید کنید.\n"
            
            bot.answer_callback_query(call.id)
            bot.send_message(call.from_user.id, text, parse_mode='Markdown')
        else:
            bot.answer_callback_query(call.id, "در حال حاضر اطلاعات مصرف در دسترس نیست!", show_alert=True)

# ============================================
# شارژ کیف پول
# ============================================
@bot.message_handler(func=lambda m: m.text == "💰 شارژ کیف پول")
@check_member
@rate_limit_decorator("charge_wallet")
def charge_wallet(message):
    wallet = UserManager.get_wallet(message.from_user.id)
    
    text = f"""
💰 **شارژ کیف پول**

💳 موجودی فعلی: {format_number(wallet)} تومان

لطفاً روش شارژ خود را انتخاب کنید:

💳 **شارژ با کارت:** حداقل 10,000 تومان
💰 **شارژ با USDT:** حداقل 1 USDT

📌 **نکته:** پس از شارژ، موجودی بلافاصله به کیف پول شما اضافه می‌شود.
🎁 **پاداش ویژه:** شارژ بالای 100,000 تومان، 5% پاداش دریافت کنید!
"""
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("💳 شارژ با کارت", callback_data="charge_card"),
        InlineKeyboardButton("💰 شارژ با USDT", callback_data="charge_crypto")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="back_main"))
    
    bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "charge_card")
def charge_card_request(call):
    msg = bot.send_message(
        call.from_user.id,
        "💰 **مبلغ شارژ را به تومان وارد کنید:**\n\n"
        "مثال: 50000\n"
        "حداقل: 10,000 تومان | حداکثر: 10,000,000 تومان\n\n"
        "💡 نکته: شارژ بالای 100,000 تومان شامل 5% پاداش می‌شود.",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, process_charge_card)

def process_charge_card(message):
    try:
        amount = int(message.text.strip())
        
        if amount < 10000:
            bot.send_message(
                message.from_user.id,
                "❌ حداقل شارژ 10,000 تومان است!",
                reply_markup=main_keyboard()
            )
            return
        
        if amount > 10000000:
            bot.send_message(
                message.from_user.id,
                "❌ حداکثر شارژ 10,000,000 تومان است!",
                reply_markup=main_keyboard()
            )
            return
        
        bonus = 0
        if amount >= 100000:
            bonus = int(amount * 0.05)
            final_amount = amount + bonus
            bonus_text = f"\n🎁 پاداش 5%: +{format_number(bonus)} تومان\n💰 مبلغ نهایی قابل شارژ: {format_number(final_amount)} تومان"
        else:
            final_amount = amount
            bonus_text = ""
        
        order_id = OrderManager.save_order(message.from_user.id, 0, final_amount, "wallet_charge")
        
        text = f"""
💳 **درخواست شارژ کیف پول**

💰 مبلغ شارژ: {format_number(amount)} تومان{bonus_text}

🏦 **شماره کارت:** {CARD_INFO}

📝 **مراحل شارژ:**
1️⃣ مبلغ دقیق {format_number(amount)} تومان را به کارت بالا واریز کنید
2️⃣ بعد از واریز، روی دکمه «ارسال رسید شارژ» کلیک کنید
3️⃣ تصویر رسید را ارسال کنید
4️⃣ پس از تایید ادمین، کیف پول شما شارژ می‌شود

🆔 **کد درخواست:** {order_id}

⚠️ توجه: حتماً مبلغ دقیق را واریز کنید.
"""
        kb = InlineKeyboardMarkup()
        kb.add(InlineKeyboardButton("📸 ارسال رسید شارژ", callback_data=f"charge_receipt_{order_id}"))
        kb.add(InlineKeyboardButton("🔙 انصراف", callback_data="back_main"))
        
        bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')
        bot.send_message(
            ADMIN_ID,
            f"💳 درخواست شارژ کیف پول #{order_id}\n"
            f"👤 کاربر: {message.from_user.id} (@{message.from_user.username})\n"
            f"💰 مبلغ: {format_number(amount)} تومان\n"
            f"🎁 پاداش: {format_number(bonus)} تومان\n"
            f"💵 مبلغ نهایی: {format_number(final_amount)}"
        )
        
    except ValueError:
        bot.send_message(
            message.from_user.id,
            "❌ عدد نامعتبر! لطفاً یک عدد صحیح وارد کنید.",
            reply_markup=main_keyboard()
        )

@bot.callback_query_handler(func=lambda call: call.data == "charge_crypto")
def charge_crypto_request(call):
    msg = bot.send_message(
        call.from_user.id,
        "💰 **مبلغ شارژ را به USDT وارد کنید:**\n\n"
        "مثال: 10\n"
        "حداقل: 1 USDT | حداکثر: 500 USDT\n\n"
        f"💱 نرخ روز: هر 1 USDT = {format_number(USDT_RATE)} تومان",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, process_charge_crypto)

def process_charge_crypto(message):
    try:
        usdt_amount = float(message.text.strip())
        
        if usdt_amount < 1:
            bot.send_message(
                message.from_user.id,
                "❌ حداقل شارژ 1 USDT است!",
                reply_markup=main_keyboard()
            )
            return
        
        if usdt_amount > 500:
            bot.send_message(
                message.from_user.id,
                "❌ حداکثر شارژ 500 USDT است!",
                reply_markup=main_keyboard()
            )
            return
        
        amount_toman = int(usdt_amount * USDT_RATE)
        
        text = f"""
💰 **درخواست شارژ کیف پول با USDT**

🪙 مقدار: {usdt_amount} USDT
💵 معادل تومانی: {format_number(amount_toman)} تومان
💱 نرخ تبدیل: {format_number(USDT_RATE)} تومان

🔗 **آدرس ولت (TRC20):** `{USDT_WALLET}`

📝 **مراحل شارژ:**
1️⃣ مبلغ دقیق {usdt_amount} USDT را به آدرس بالا واریز کنید
2️⃣ بعد از واریز، روی دکمه «اعلام واریز USDT» کلیک کنید
3️⃣ منتظر تایید ادمین باشید

⚠️ **توجه مهم:** 
• حتماً از شبکه TRC20 استفاده کنید
• تراکنش‌های با شبکه دیگر تایید نمی‌شوند
• پس از تایید، موجودی به کیف پول شما اضافه می‌شود
"""
        kb = InlineKeyboardMarkup()
        kb.add(InlineKeyboardButton("💰 اعلام واریز USDT", callback_data=f"crypto_charge_{usdt_amount}"))
        kb.add(InlineKeyboardButton("🔙 انصراف", callback_data="back_main"))
        
        bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')
        bot.send_message(
            ADMIN_ID,
            f"💰 درخواست شارژ USDT\n"
            f"👤 کاربر: {message.from_user.id} (@{message.from_user.username})\n"
            f"🪙 مقدار: {usdt_amount} USDT\n"
            f"💵 معادل تومانی: {format_number(amount_toman)}"
        )
        
    except ValueError:
        bot.send_message(
            message.from_user.id,
            "❌ عدد نامعتبر! لطفاً یک عدد صحیح وارد کنید.",
            reply_markup=main_keyboard()
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith("crypto_charge_"))
def crypto_charge_declare(call):
    usdt_amount = float(call.data.replace("crypto_charge_", ""))
    
    bot.send_message(
        ADMIN_ID,
        f"💰 اعلام واریز USDT برای شارژ کیف پول\n"
        f"👤 کاربر: {call.from_user.id} (@{call.from_user.username})\n"
        f"🪙 مقدار: {usdt_amount} USDT\n"
        f"📅 زمان: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
    )
    
    bot.edit_message_text(
        "✅ **درخواست شارژ شما ثبت شد!**\n\n"
        "پس از تایید ادمین و تایید تراکنش در بلاک‌چین، کیف پول شما شارژ می‌شود.\n"
        "این فرآیند معمولاً چند دقیقه تا چند ساعت طول می‌کشد.\n\n"
        "شما می‌توانید از بخش «تاریخچه خرید» وضعیت درخواست خود را پیگیری کنید.",
        call.from_user.id,
        call.message.message_id,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith("charge_receipt_"))
def charge_receipt(call):
    order_id = int(call.data.replace("charge_receipt_", ""))
    msg = bot.send_message(
        call.from_user.id,
        "📸 **لطفاً عکس رسید واریز شارژ را ارسال کنید:**",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: save_charge_receipt(m, order_id))

def save_charge_receipt(message, order_id):
    if message.photo:
        file_id = message.photo[-1].file_id
        caption = (
            f"📸 رسید شارژ کیف پول #{order_id}\n"
            f"👤 کاربر: {message.from_user.id}\n"
            f"📝 نام: @{message.from_user.username or message.from_user.first_name}\n"
            f"📅 تاریخ: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
        )
        ReceiptManager.save_receipt(order_id, message.from_user.id, file_id, "charge_photo")
        bot.send_photo(ADMIN_ID, file_id, caption=caption)
        bot.send_message(
            message.from_user.id,
            "✅ رسید شارژ شما با موفقیت ارسال و در سیستم ذخیره شد.\n"
            "پس از تایید ادمین، کیف پول شما شارژ می‌شود.\n\n"
            "شما می‌توانید از بخش «تاریخچه خرید» وضعیت درخواست خود را پیگیری کنید.",
            reply_markup=main_keyboard()
        )
        logger.info(f"رسید شارژ #{order_id} از کاربر {message.from_user.id} ارسال و ذخیره شد")
    else:
        bot.send_message(
            message.from_user.id,
            "❌ لطفاً یک عکس معتبر ارسال کنید!",
            reply_markup=main_keyboard()
        )

# ============================================
# تاریخچه خرید
# ============================================
@bot.message_handler(func=lambda m: m.text == "📊 تاریخچه خرید")
@check_member
@rate_limit_decorator("history")
def purchase_history(message):
    orders = OrderManager.get_user_orders(message.from_user.id, 20)
    
    if not orders:
        bot.send_message(
            message.from_user.id,
            "❌ **شما هیچ سفارشی ثبت نکرده‌اید.**\n\n"
            "برای ثبت سفارش، از بخش «خرید اشتراک جدید» اقدام کنید.",
            reply_markup=main_keyboard(),
            parse_mode='Markdown'
        )
        return
    
    total_orders = len(orders)
    completed_orders = len([o for o in orders if o[5] == "completed"])
    total_spent = sum([o[3] for o in orders if o[5] == "completed"])
    
    stats_text = f"📊 **آمار خرید شما:**\n"
    stats_text += f"• کل سفارشات: {total_orders}\n"
    stats_text += f"• سفارشات موفق: {completed_orders}\n"
    stats_text += f"• مجموع هزینه: {format_number(total_spent)} تومان\n\n"
    stats_text += f"━━━━━━━━━━━━━━━━━━\n\n"
    
    bot.send_message(message.from_user.id, stats_text, parse_mode='Markdown')
    
    text = "📋 **لیست آخرین سفارشات شما:**\n\n"
    
    for order in orders:
        status_emoji = {
            "completed": "✅",
            "waiting_for_payment": "⏳",
            "processing": "🔄",
            "rejected": "❌",
            "pending": "⏰",
            "cancelled": "🚫"
        }.get(order[5], "❓")
        
        status_text = {
            "completed": "تکمیل شده",
            "waiting_for_payment": "در انتظار پرداخت",
            "processing": "در حال پردازش",
            "rejected": "رد شده",
            "pending": "در انتظار",
            "cancelled": "لغو شده"
        }.get(order[5], "نامشخص")
        
        text += f"{status_emoji} **#{order[0]}** - {status_text}\n"
        text += f"📦 حجم: {order[2]} گیگابایت\n"
        text += f"💰 قیمت: {format_number(order[3])} تومان\n"
        text += f"📅 تاریخ: {order[6][:16]}\n"
        
        if order[7]:
            text += f"✅ تکمیل: {order[7][:16]}\n"
        
        text += "\n"
    
    for i in range(0, len(text), 4000):
        bot.send_message(
            message.from_user.id,
            text[i:i+4000],
            reply_markup=back_keyboard() if i == 0 else None,
            parse_mode='Markdown'
        )

# ============================================
# وضعیت مصرف
# ============================================
@bot.message_handler(func=lambda m: m.text == "📈 وضعیت مصرف")
@check_member
@rate_limit_decorator("usage_status")
def usage_status(message):
    subs = SubscriptionManager.get_user_subs(message.from_user.id)
    
    if not subs:
        bot.send_message(
            message.from_user.id,
            "❌ شما هیچ اشتراک فعالی ندارید.\nبرای مشاهده مصرف، ابتدا اشتراک تهیه کنید.",
            reply_markup=main_keyboard()
        )
        return
    
    total_volume = sum([sub[2] for sub in subs])
    total_used = 0
    
    text = "📊 **وضعیت مصرف کلی شما**\n\n"
    
    for sub in subs:
        username = sub[4]
        usage = panel_manager.get_user_usage_from_panel(username)
        
        if usage:
            total_used += usage['used_gb']
            used_percent = usage['used_percent']
            text += f"🔹 اشتراک #{sub[0]}: {usage['used_gb']:.1f}/{usage['total_gb']:.1f} GB ({used_percent:.0f}%)\n"
            text += get_usage_bar(used_percent) + "\n"
        else:
            text += f"🔹 اشتراک #{sub[0]}: {sub[2]} گیگابایت - اطلاعات مصرف در دسترس نیست\n\n"
    
    if total_volume > 0:
        total_percent = (total_used / total_volume) * 100
        text += f"\n━━━━━━━━━━━━━━━━━━\n"
        text += f"📈 **جمع کل:**\n"
        text += f"• مصرف شده: {total_used:.1f} گیگابایت\n"
        text += f"• حجم کل: {total_volume} گیگابایت\n"
        text += f"• درصد مصرف: {total_percent:.0f}%\n"
        text += get_usage_bar(total_percent)
    
    bot.send_message(message.from_user.id, text, parse_mode='Markdown')

# ============================================
# کد تخفیف
# ============================================
@bot.message_handler(func=lambda m: m.text == "🎁 کد تخفیف")
@check_member
@rate_limit_decorator("discount")
def discount_menu(message):
    text = """
🎁 **سیستم تخفیف‌های زیتون شاپ**

✨ **کدهای تخفیف فعال:**
• کدهای تخفیف ویژه برای کاربران خاص
• تخفیف‌های فصلی و مناسبتی

🎯 **نحوه دریافت کد تخفیف:**
• شرکت در مسابقات و قرعه‌کشی‌ها
• خرید بالای 100,000 تومان (دریافت خودکار 5% پاداش)
• معرفی دوستان (به زودی)

💡 **نحوه استفاده:**
1. پکیج مورد نظر خود را انتخاب کنید
2. در صفحه فاکتور، گزینه «کد تخفیف» را بزنید
3. کد را وارد کنید
4. از تخفیف لذت ببرید!

📌 کد تخفیف خود را دارید؟ همین حالا استفاده کنید!
"""
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("🎁 وارد کردن کد تخفیف", callback_data="apply_discount"))
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="back_main"))
    
    bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')

# ============================================
# پشتیبانی
# ============================================
@bot.message_handler(func=lambda m: m.text == "🆘 پشتیبانی")
@check_member
@rate_limit_decorator("support")
def support(message):
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("📩 ارسال تیکت جدید", callback_data="new_ticket"),
        InlineKeyboardButton("📋 وضعیت تیکت‌های من", callback_data="my_tickets")
    )
    kb.add(
        InlineKeyboardButton("❓ سوالات متداول", callback_data="faq"),
        InlineKeyboardButton("📞 تماس با ادمین", callback_data="contact_admin")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="back_main"))
    
    text = """
🆘 **پشتیبانی زیتون شاپ**

📌 **راه‌های ارتباط با ما:**

1️⃣ **تیکت پشتیبانی:** 
   • برای مسائل فنی و مشکلات اشتراک
   • پاسخگویی در سریع‌ترین زمان ممکن

2️⃣ **سوالات متداول:**
   • راهنما و آموزش‌های استفاده

⏱️ **ساعت پاسخگویی:** ۲۴ ساعته، ۷ روز هفته

💡 **نکته:** قبل از ارسال تیکت، حتماً بخش «آموزش و راهنما» را مطالعه کنید.
"""
    bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "new_ticket")
def new_ticket(call):
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("🔴 فوری", callback_data="ticket_priority_high"),
        InlineKeyboardButton("🟡 عادی", callback_data="ticket_priority_normal"),
        InlineKeyboardButton("🟢 کم اهمیت", callback_data="ticket_priority_low")
    )
    
    bot.edit_message_text(
        "📝 **اولویت تیکت خود را انتخاب کنید:**\n\n"
        "• فوری: مشکلات قطعی سرویس\n"
        "• عادی: سوالات و مشکلات معمول\n"
        "• کم اهمیت: پیشنهادات و انتقادات",
        call.from_user.id,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith("ticket_priority_"))
def select_ticket_priority(call):
    priority = call.data.replace("ticket_priority_", "")
    priority_map = {
        "high": "فوری - 🔴",
        "normal": "عادی - 🟡",
        "low": "کم اهمیت - 🟢"
    }
    
    bot.edit_message_text(
        f"✅ اولویت {priority_map.get(priority, 'عادی')} انتخاب شد.\n\n"
        "📝 **لطفاً پیام خود را بنویسید:**\n\n"
        "مشکل خود را به طور کامل توضیح دهید.\n"
        "در صورت امکان، تصاویر مربوطه را ارسال کنید.",
        call.from_user.id,
        call.message.message_id,
        parse_mode='Markdown'
    )
    
    msg = bot.send_message(call.from_user.id, "✏️ پیام خود را وارد کنید:")
    bot.register_next_step_handler(msg, lambda m: create_ticket_with_priority(m, priority))

def create_ticket_with_priority(message, priority):
    ticket_id = TicketManager.save_ticket(message.from_user.id, message.text, priority)
    
    bot.send_message(
        message.from_user.id,
        f"✅ **تیکت شما با موفقیت ثبت شد!**\n\n"
        f"🆔 شماره تیکت: #{ticket_id}\n"
        f"🎯 اولویت: {priority}\n\n"
        f"📌 تیم پشتیبانی در اسرع وقت پاسخ شما را خواهد داد.\n"
        f"شما می‌توانید از بخش «وضعیت تیکت‌های من» پاسخ را مشاهده کنید.",
        reply_markup=main_keyboard(),
        parse_mode='Markdown'
    )
    
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("💬 پاسخ به تیکت", callback_data=f"admin_reply_{ticket_id}"))
    
    bot.send_message(
        ADMIN_ID,
        f"📩 **تیکت جدید #{ticket_id}**\n"
        f"👤 کاربر: {message.from_user.id} (@{message.from_user.username})\n"
        f"🎯 اولویت: {priority}\n"
        f"📝 پیام: {message.text}\n"
        f"📅 تاریخ: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
        reply_markup=kb,
        parse_mode='Markdown'
    )
    
    logger.info(f"تیکت جدید #{ticket_id} با اولویت {priority} از کاربر {message.from_user.id} ثبت شد")

@bot.callback_query_handler(func=lambda call: call.data == "my_tickets")
def my_tickets(call):
    tickets = TicketManager.get_user_tickets(call.from_user.id)
    
    if not tickets:
        bot.answer_callback_query(call.id, "❌ شما هیچ تیکتی ثبت نکرده‌اید!")
        return
    
    text = "📋 **لیست تیکت‌های شما:**\n\n"
    
    for ticket in tickets:
        status_emoji = "✅" if ticket[4] == "closed" else "🟡"
        status_text = "بسته شده" if ticket[4] == "closed" else "باز"
        priority_emoji = "🔴" if ticket[5] == "high" else "🟡" if ticket[5] == "normal" else "🟢"
        
        text += f"{status_emoji} **#{ticket[0]}** - {status_text}\n"
        text += f"{priority_emoji} اولویت: {ticket[5]}\n"
        text += f"📝 {ticket[2][:100]}...\n"
        text += f"📅 {ticket[6][:16]}\n"
        
        if ticket[3]:
            text += f"💬 پاسخ: {ticket[3][:100]}...\n"
        
        text += "\n"
    
    bot.send_message(call.from_user.id, text, reply_markup=back_keyboard(), parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "faq")
def faq(call):
    text = """
❓ **سوالات متداول**

**1️⃣ چگونه اشتراک بخرم؟**
از بخش «خرید اشتراک جدید» پکیج مورد نظر را انتخاب کنید و مراحل را طی کنید.

**2️⃣ لینک اشتراک را گم کردم، چکار کنم؟**
از بخش «اشتراک‌های من» می‌توانید لینک اشتراک خود را مشاهده کنید.

**3️⃣ اشتراک من چند روز اعتبار دارد؟**
هر پکیج دارای اعتبار مشخص است (30 تا 90 روز). در بخش «اشتراک‌های من» تاریخ دقیق را ببینید.

**4️⃣ چگونه کیف پول را شارژ کنم؟**
از بخش «شارژ کیف پول» و با کارت بانکی یا USDT می‌توانید شارژ کنید.

**5️⃣ آیا امکان تمدید خودکار وجود دارد؟**
بله، اگر کیف پول شما موجودی کافی داشته باشد، می‌توانید به صورت دستی تمدید کنید.

**6️⃣ مصرف اینترنت من چقدر است؟**
از بخش «وضعیت مصرف» می‌توانید مصرف لحظه‌ای خود را ببینید.

**7️⃣ اتصال کار نمی‌کند، چکار کنم؟**
• اینترنت خود را ریست کنید
• از آخرین نسخه نرم‌افزار استفاده کنید
• لینک را دوباره اضافه کنید
• در بخش پشتیبانی تیکت بزنید

**8️⃣ روش‌های پرداخت چیست؟**
کارت به کارت بانکی و USDT (ارز دیجیتال)

**9️⃣ آیا تخفیف دارید؟**
بله، برای خریدهای بالای 100,000 تومان پاداش 5% تعلق می‌گیرد.

**🔟 پشتیبانی چگونه است؟**
پشتیبانی ۲۴ ساعته از طریق تیکت و پاسخگویی سریع.
"""
    bot.send_message(call.from_user.id, text, reply_markup=back_keyboard(), parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "contact_admin")
def contact_admin(call):
    text = """
📞 **تماس با ادمین**

برای ارتباط مستقیم با ادمین، می‌توانید:

1️⃣ **ارسال تیکت:** 
   از بخش «ارسال تیکت جدید» استفاده کنید

2️⃣ **ایمیل:** 
   support@zitronshop.com

3️⃣ **پیام در تلگرام:** 
   @zitron_admin

⚠️ **نکات مهم:**
• لطفاً ابتدا مشکل خود را در تیکت شرح دهید
• درخواست‌های تجاری و همکاری از طریق ایمیل
• پاسخگویی در اسرع وقت
"""
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("📩 ارسال تیکت جدید", callback_data="new_ticket"))
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="support"))
    
    bot.send_message(call.from_user.id, text, reply_markup=kb, parse_mode='Markdown')

# ============================================
# آموزش و راهنما
# ============================================
@bot.message_handler(func=lambda m: m.text == "📚 آموزش و راهنما")
@check_member
@rate_limit_decorator("tutorial")
def tutorials(message):
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("📱 اندروید", callback_data="tut_android"),
        InlineKeyboardButton("🍏 iOS", callback_data="tut_ios"),
        InlineKeyboardButton("💻 ویندوز", callback_data="tut_windows"),
        InlineKeyboardButton("🍎 مک", callback_data="tut_mac"),
        InlineKeyboardButton("🔧 عیب‌یابی", callback_data="tut_troubleshoot"),
        InlineKeyboardButton("📖 راهنمای کامل", callback_data="tut_full")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="back_main"))
    
    text = """
📚 **راهنمای جامع استفاده از اشتراک‌ها**

📱 **نرم‌افزارهای مورد نیاز:**

• **اندروید:** V2RayNG, Hiddify, Nekobox
• **iOS:** Streisand, V2Box, Shadowrocket
• **ویندوز:** V2RayN, Nekoray, Hiddify
• **مک:** V2RayU, Nekoray

⚙️ **نحوه اتصال عمومی:**
1. لینک اشتراک را کپی کنید
2. نرم‌افزار را باز کنید
3. گزینه «افزودن اشتراک» را انتخاب کنید
4. لینک را پیست کنید
5. ذخیره کنید و اتصال را فعال کنید

💡 **نکات مهم:**
• حتماً از آخرین نسخه نرم‌افزار استفاده کنید
• در صورت قطعی، لینک را به روز کنید
• مصرف خود را مرتباً بررسی کنید

لطفاً سیستم عامل خود را انتخاب کنید:
"""
    bot.send_message(message.from_user.id, text, reply_markup=kb, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data.startswith("tut_"))
def tutorial_detail(call):
    tut_type = call.data.replace("tut_", "")
    
    tutorials_text = {
        "android": """
📱 **آموزش نصب و استفاده در اندروید**

**نرم‌افزار پیشنهادی: V2RayNG**

📥 **نصب:**
1. از گوگل پلی یا دانلود مستقیم، V2RayNG را نصب کنید
2. برنامه را باز کنید

⚙️ **تنظیمات:**
1. روی علامت ➕ در پایین صفحه بزنید
2. گزینه «Import Config from Clipboard» را انتخاب کنید
3. لینک اشتراک را کپی و در برنامه پیست کنید
4. نام دلخواه وارد کنید و Save بزنید

🔌 **اتصال:**
1. روی کانفیگ اضافه شده کلیک کنید
2. دکمه پلی 🟢 را بزنید
3. در صورت درخواست VPN، Allow را بزنید

💡 **نکات:**
• در تنظیمات، گزینه «Enable Local DNS» را فعال کنید
• در صورت مشکل، از Hiddify استفاده کنید که ساده‌تر است
""",
        "ios": """
🍏 **آموزش نصب و استفاده در iOS**

**نرم‌افزار پیشنهادی: Streisand (رایگان)**

📥 **نصب:**
1. از اپ استور، Streisand را نصب کنید
2. برنامه را باز کنید

⚙️ **تنظیمات:**
1. روی دکمه ➕ در بالا بزنید
2. «Import From Clipboard» را انتخاب کنید
3. لینک اشتراک را کپی کنید
4. برنامه خودکار اضافه می‌کند

🔌 **اتصال:**
1. روی کانفیگ ضافه شده کلیک کنید
2. دکمه Connect را بزنید
3. در صورت درخواست VPN، Allow را بزنید

💡 **نکات:**
• نسخه پولی Shadowrocket بسیار قدرتمندتر است
• در تنظیمات VPN، گزینه «Connect On Demand» را فعال کنید
""",
        "windows": """
💻 **آموزش نصب و استفاده در ویندوز**

**نرم‌افزار پیشنهادی: V2RayN**

📥 **نصب:**
1. از گیت‌هاب آخرین نسخه V2RayN را دانلود کنید
2. فایل zip را Extract کنید
3. فایل v2rayN.exe را اجرا کنید

⚙️ **تنظیمات:**
1. روی سرور کلیک راست کنید
2. «Import Config from Clipboard» را بزنید
3. لینک اشتراک را کپی کنید
4. خودکار اضافه می‌شود

🔌 **اتصال:**
1. روی کانفیگ دبل کلیک کنید
2. دکمه Enter را بزنید (در پایین)
3. در صورت درخواست فایروال، Allow کنید

💡 **نکات:**
• Route mode را روی «Whitelist» تنظیم کنید
• Core type: Xray
• برای آپدیت خودکار، Enable Auto Update را بزنید
""",
        "mac": """
🍎 **آموزش نصب و استفاده در مک**

**نرم‌افزار پیشنهادی: V2RayU**

📥 **نصب:**
1. آخرین نسخه V2RayU را از گیت‌هاب دانلود کنید
2. فایل را به Applications ببرید
3. برنامه را باز کنید

⚙️ **تنظیمات:**
1. روی آیکون برنامه در نوار منو کلیک کنید
2. «Import Config from Clipboard» را انتخاب کنید
3. لینک اشتراک را کپی کنید

🔌 **اتصال:**
1. روی آیکون برنامه کلیک کنید
2. «Turn On» را بزنید
3. در صورت درخواست مجوز، Allow کنید

💡 **نکات:**
• در تنظیمات، Mode را روی «Global» بگذارید
• از Nekoray هم می‌توانید استفاده کنید
""",
        "troubleshoot": """
🔧 **راهنمای عیب‌یابی مشکلات رایج**

**مشکل: اتصال برقرار نمی‌شود**
✅ راه حل:
• اینترنت خود را ریست کنید (مودم و دستگاه)
• از لینک اشتراک جدید استفاده کنید
• نرم‌افزار را به روز کنید
• فایروال یا آنتی‌ویروس را موقتاً غیرفعال کنید

**مشکل: سرعت پایین است**
✅ راه حل:
• از اینترنت ثابت استفاده کنید
• نزدیک مودم باشید
• در ساعت‌های کم‌ترافیک اتصال بگیرید
• پروتکل را تغییر دهید (در تنظیمات نرم‌افزار)

**مشکل: اتصال قطع و وصل می‌شود**
✅ راه حل:
• گزینه «Enable Mux» را در تنظیمات فعال کنید
• Timeout را افزایش دهید
• از لینک اشتراک جدید استفاده کنید

**مشکل: لینک اشتراک نامعتبر است**
✅ راه حل:
• لینک را کامل کپی کنید
• تاریخ انقضای اشتراک را بررسی کنید
• از بخش «اشتراک‌های من» لینک جدید بگیرید

**مشکل: در تلگرام باز نمی‌شود**
✅ راه حل:
• از مرورگر استفاده کنید
• Split Tunnel را در تنظیمات فعال کنید

**هنوز مشکل دارید؟**
از بخش «پشتیبانی» تیکت بزنید.
""",
        "full": """
📖 **راهنمای کامل زیتون شاپ**

**مراحل شروع کار:**
1️⃣ عضویت در کانال اجباری
2️⃣ خرید اشتراک از بخش «خرید اشتراک جدید»
3️⃣ دریافت لینک اشتراک
4️⃣ نصب نرم‌افزار مناسب سیستم خود
5️⃣ وارد کردن لینک و اتصال

**مدیریت اشتراک‌ها:**
• مشاهده اشتراک‌های فعال: بخش «اشتراک‌های من»
• مشاهده مصرف: بخش «وضعیت مصرف»
• تمدید اشتراک: از بخش اشتراک‌های من

**مدیریت مالی:**
• شارژ کیف پول: از بخش مربوطه
• تاریخچه خرید: مشاهده تمام سفارشات
• کد تخفیف: استفاده از تخفیف‌های ویژه

**پشتیبانی:**
• ارسال تیکت برای مشکلات فنی
• پاسخگویی در کوتاه‌ترین زمان
• راهنمایی در تمام مراحل

**قوانین و مقررات:**
• استفاده شخصی و غیرتجاری
• عدم اشتراک لینک با دیگران
• رعایت اخلاق در استفاده

💪 **تیم زیتون شاپ، همواره در کنار شماست!**
"""
    }
    
    text = tutorials_text.get(tut_type, "آموزش در حال به‌روزرسانی است...")
    bot.send_message(call.from_user.id, text, reply_markup=back_keyboard(), parse_mode='Markdown')

# ============================================
# بازگشت به صفحه اصلی
# ============================================
@bot.callback_query_handler(func=lambda call: call.data == "back_main")
def back_main_cb(call):
    wallet = UserManager.get_wallet(call.from_user.id)
    text = MAIN_MENU_TEXT.format(
        name=call.from_user.first_name,
        wallet=format_number(wallet)
    )
    try:
        bot.edit_message_text(
            text,
            call.from_user.id,
            call.message.message_id,
            reply_markup=main_keyboard(),
            parse_mode='Markdown'
        )
    except:
        bot.send_message(
            call.from_user.id,
            text,
            reply_markup=main_keyboard(),
            parse_mode='Markdown'
        )

@bot.callback_query_handler(func=lambda call: call.data == "cancel_order")
def cancel_order(call):
    pending_order = OrderManager.get_pending_order(call.from_user.id)
    
    if pending_order:
        order_id, price = pending_order[0], pending_order[1]
        UserManager.unlock_wallet_amount(call.from_user.id, price)
        OrderManager.update_order(order_id, "cancelled")
        logger.info(f"سفارش #{order_id} لغو شد و موجودی {price} تومان آزاد شد")
    
    try:
        bot.edit_message_text(
            "❌ **پرداخت لغو شد.**\n\n"
            "موجودی قفل شده شما آزاد شد.",
            call.from_user.id,
            call.message.message_id,
            parse_mode='Markdown'
        )
    except:
        pass
    
    bot.send_message(
        call.from_user.id,
        "🏠 صفحه اصلی",
        reply_markup=main_keyboard()
    )

# ============================================
# بخش ادمین
# ============================================
@bot.message_handler(commands=['admin'])
@admin_only
def admin_panel(message):
    kb = admin_main_keyboard()
    bot.send_message(
        ADMIN_ID,
        "🔧 **پنل مدیریت ربات زیتون شاپ**\n\n"
        "لطفاً یکی از گزینه‌های زیر را انتخاب کنید:",
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "admin_pending_orders")
@admin_only
def admin_pending_orders(call):
    cursor = db_manager.execute("""SELECT id, user_id, volume, price, payment_method, created_at 
                   FROM orders WHERE status = 'waiting_for_payment' ORDER BY id DESC""")
    orders = cursor.fetchall()
    
    if not orders:
        bot.answer_callback_query(call.id, "📭 هیچ سفارش در انتظاری وجود ندارد")
        return
    
    for order in orders:
        order_id, user_id, volume, price, method, created_at = order
        
        user = UserManager.get_user(user_id)
        username = user[1] if user else "نامشخص"
        
        text = (
            f"🆔 **سفارش #{order_id}**\n"
            f"👤 کاربر: {user_id}\n"
            f"📝 نام: @{username}\n"
            f"📦 حجم: {volume}GB\n"
            f"💰 مبلغ: {format_number(price)} تومان\n"
            f"💳 روش: {method or 'نامشخص'}\n"
            f"📅 تاریخ: {created_at[:16]}\n"
        )
        
        kb = InlineKeyboardMarkup()
        kb.add(
            InlineKeyboardButton("✅ تایید و فعال‌سازی", callback_data=f"admin_approve_{order_id}"),
            InlineKeyboardButton("❌ رد سفارش", callback_data=f"admin_reject_{order_id}")
        )
        kb.add(InlineKeyboardButton("🔍 اطلاعات کاربر", callback_data=f"admin_user_info_{user_id}"))
        
        bot.send_message(ADMIN_ID, text, reply_markup=kb, parse_mode='Markdown')
        time.sleep(0.3)

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_approve_"))
@admin_only
def admin_approve(call):
    order_id = int(call.data.replace("admin_approve_", ""))
    order = OrderManager.get_order(order_id)
    
    if order:
        user_id, volume, price = order[1], order[2], order[3]
        
        OrderManager.update_order(order_id, "processing")
        log_admin_action(ADMIN_ID, "approve_order", user_id, f"سفارش #{order_id}")
        
        if not SubscriptionManager.can_create_new_sub(user_id):
            bot.send_message(
                ADMIN_ID,
                f"⚠️ کاربر {user_id} به حداکثر مجاز اشتراک رسیده است!\n"
                f"لطفاً ابتدا یکی از اشتراک‌های قدیمی را حذف کنید."
            )
            return
        
        days = get_package_days_by_volume(volume)
        result = panel_manager.create_user_in_panel_with_retry(user_id, volume, days=days, retries=3)
        
        if result:
            expire = (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
            SubscriptionManager.save_sub(user_id, volume, result["url"], result["username"], expire)
            OrderManager.update_order(order_id, "completed")
            UserManager.increment_purchases(user_id, price)
            
            bot.send_message(
                user_id,
                f"✅ **پرداخت شما تایید شد!**\n\n"
                f"🎁 اشتراک {volume} گیگابایتی با موفقیت فعال شد.\n\n"
                f"📅 اعتبار: {days} روز\n"
                f"🔗 **لینک اشتراک:**\n`{result['url']}`\n\n"
                f"📅 تاریخ انقضا: {expire}\n\n"
                f"📚 برای آموزش نصب به بخش «آموزش و راهنما» مراجعه کنید.",
                parse_mode='Markdown',
                reply_markup=main_keyboard()
            )
            
            bot.edit_message_text(
                f"✅ سفارش #{order_id} تایید و اشتراک ارسال شد.",
                ADMIN_ID,
                call.message.message_id
            )
            logger.info(f"ادمین سفارش #{order_id} را تایید کرد - کاربر: {user_id}")
        else:
            add_pending_operation(user_id, order_id, "create_subscription", "خطا در ساخت اشتراک توسط ادمین")
            bot.send_message(
                ADMIN_ID,
                f"⚠️ سفارش #{order_id} در صف پردازش قرار گرفت.\n"
                f"سیستم خودکار تلاش خواهد کرد."
            )
            bot.send_message(
                user_id,
                f"✅ پرداخت شما تایید شد!\n\n"
                f"🔄 اشتراک شما در حال آماده‌سازی است.\n"
                f"حداکثر تا چند دقیقه دیگر فعال می‌شود.\n"
                f"پس از فعال‌سازی، پیام تایید برای شما ارسال می‌شود.",
                reply_markup=main_keyboard()
            )
            logger.error(f"خطا در ساخت اشتراک سفارش #{order_id} - در صف قرار گرفت")
    else:
        bot.send_message(ADMIN_ID, "❌ سفارش یافت نشد!")

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_reject_"))
@admin_only
def admin_reject(call):
    order_id = int(call.data.replace("admin_reject_", ""))
    order = OrderManager.get_order(order_id)
    
    if order:
        user_id, price = order[1], order[3]
        
        UserManager.unlock_wallet_amount(user_id, price)
        
        OrderManager.update_order(order_id, "rejected")
        log_admin_action(ADMIN_ID, "reject_order", user_id, f"سفارش #{order_id}")
        
        bot.send_message(
            user_id,
            f"❌ **متأسفانه سفارش شما رد شد!**\n\n"
            f"🆔 کد سفارش: {order_id}\n"
            f"💰 مبلغ {format_number(price)} تومان از قفل خارج شد.\n\n"
            f"دلایل احتمالی:\n"
            f"• رسید ارسال نشده یا نامعتبر بوده\n"
            f"• مبلغ واریزی با مبلغ سفارش مطابقت ندارد\n\n"
            f"لطفاً با پشتیبانی تماس بگیرید و کد سفارش را ارائه دهید.",
            parse_mode='Markdown'
        )
        
        bot.edit_message_text(
            f"❌ سفارش #{order_id} رد شد و موجودی کاربر آزاد شد.",
            ADMIN_ID,
            call.message.message_id
        )
        logger.info(f"ادمین سفارش #{order_id} را رد کرد - کاربر: {user_id}")

@bot.callback_query_handler(func=lambda call: call.data == "admin_tickets")
@admin_only
def admin_tickets(call):
    tickets = TicketManager.get_all_open_tickets()
    
    if not tickets:
        bot.answer_callback_query(call.id, "📭 هیچ تیکت بازی وجود ندارد")
        return
    
    for ticket in tickets:
        ticket_id, user_id, message, reply, status, priority, created_at, closed_at = ticket
        
        priority_emoji = "🔴" if priority == "high" else "🟡" if priority == "normal" else "🟢"
        priority_text = {"high": "فوری", "normal": "عادی", "low": "کم اهمیت"}.get(priority, "عادی")
        
        text = (
            f"🎫 **تیکت #{ticket_id}**\n"
            f"👤 کاربر: {user_id}\n"
            f"{priority_emoji} اولویت: {priority_text}\n"
            f"📝 پیام: {message[:200]}\n"
            f"📅 تاریخ: {created_at[:16]}\n"
        )
        
        kb = InlineKeyboardMarkup()
        kb.add(InlineKeyboardButton("💬 پاسخ به تیکت", callback_data=f"admin_reply_{ticket_id}"))
        kb.add(InlineKeyboardButton("🔍 اطلاعات کاربر", callback_data=f"admin_user_info_{user_id}"))
        
        bot.send_message(ADMIN_ID, text, reply_markup=kb, parse_mode='Markdown')
        time.sleep(0.3)

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_reply_"))
@admin_only
def admin_reply_ticket(call):
    ticket_id = int(call.data.replace("admin_reply_", ""))
    ticket = TicketManager.get_ticket(ticket_id)
    
    if not ticket:
        bot.send_message(ADMIN_ID, "❌ تیکت یافت نشد!")
        return
    
    user_id = ticket[1]
    
    msg = bot.send_message(
        ADMIN_ID,
        f"📝 **پاسخ به تیکت #{ticket_id}**\n\n"
        f"👤 کاربر: {user_id}\n"
        f"📝 پیام اصلی: {ticket[2][:100]}...\n\n"
        f"لطفاً پاسخ خود را بنویسید:",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: send_ticket_reply(m, ticket_id, user_id))

def send_ticket_reply(message, ticket_id, user_id):
    reply_text = message.text
    TicketManager.close_ticket(ticket_id, reply_text)
    log_admin_action(ADMIN_ID, "reply_ticket", user_id, f"تیکت #{ticket_id}")
    
    bot.send_message(
        user_id,
        f"📩 **پاسخ پشتیبانی زیتون شاپ**\n\n"
        f"{reply_text}\n\n"
        f"🆔 کد تیکت: {ticket_id}\n"
        f"✅ این تیکت بسته شد.\n\n"
        f"در صورت نیاز مجدد، از بخش «پشتیبانی» تیکت جدید ثبت کنید.",
        reply_markup=main_keyboard(),
        parse_mode='Markdown'
    )
    
    bot.send_message(
        ADMIN_ID,
        f"✅ پاسخ به تیکت #{ticket_id} ارسال و تیکت بسته شد."
    )
    logger.info(f"پاسخ به تیکت #{ticket_id} ارسال شد - کاربر: {user_id}")

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_user_info_"))
@admin_only
def admin_user_info(call):
    user_id = int(call.data.replace("admin_user_info_", ""))
    user = UserManager.get_user(user_id)
    
    if not user:
        bot.send_message(ADMIN_ID, "❌ کاربر یافت نشد!")
        return
    
    wallet = UserManager.get_wallet(user_id)
    total_wallet = UserManager.get_total_wallet(user_id)
    active_subs = SubscriptionManager.get_active_subs_count(user_id)
    total_purchases = user[7] if len(user) > 7 else 0
    total_spent = user[8] if len(user) > 8 else 0
    is_banned = user[9] if len(user) > 9 else 0
    
    text = (
        f"👤 **اطلاعات کاربر**\n\n"
        f"🆔 آیدی: `{user_id}`\n"
        f"👤 نام: {user[2]}\n"
        f"📝 یوزرنیم: @{user[1] or 'ندارد'}\n"
        f"💰 موجودی کیف پول: {format_number(wallet)} تومان\n"
        f"🔒 موجودی قفل شده: {format_number(total_wallet - wallet)} تومان\n"
        f"📦 اشتراک فعال: {active_subs}\n"
        f"🛍️ تعداد خرید: {total_purchases}\n"
        f"💵 مجموع خرید: {format_number(total_spent)} تومان\n"
        f"📅 تاریخ عضویت: {user[4]}\n"
        f"🚫 وضعیت: {'مسدود' if is_banned else 'فعال'}\n"
    )
    
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("💰 مدیریت کیف پول", callback_data=f"admin_wallet_user_{user_id}"),
        InlineKeyboardButton("📋 اشتراک‌های کاربر", callback_data=f"admin_user_subs_{user_id}")
    )
    if is_banned:
        kb.add(InlineKeyboardButton("✅ رفع مسدودیت", callback_data=f"admin_unban_{user_id}"))
    else:
        kb.add(InlineKeyboardButton("🚫 مسدود کردن", callback_data=f"admin_ban_{user_id}"))
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_users_list"))
    
    bot.send_message(ADMIN_ID, text, reply_markup=kb, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_wallet_user_"))
@admin_only
def admin_wallet_user(call):
    user_id = int(call.data.replace("admin_wallet_user_", ""))
    user = UserManager.get_user(user_id)
    
    if not user:
        bot.send_message(ADMIN_ID, "❌ کاربر یافت نشد!")
        return
    
    wallet = UserManager.get_wallet(user_id)
    
    text = (
        f"💰 **مدیریت کیف پول کاربر**\n\n"
        f"👤 کاربر: {user_id}\n"
        f"💰 موجودی فعلی: {format_number(wallet)} تومان\n\n"
        f"لطفاً عملیات مورد نظر را انتخاب کنید:"
    )
    
    kb = InlineKeyboardMarkup()
    kb.add(
        InlineKeyboardButton("➕ افزایش موجودی", callback_data=f"admin_wallet_add_{user_id}"),
        InlineKeyboardButton("➖ کاهش موجودی", callback_data=f"admin_wallet_remove_{user_id}")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data=f"admin_user_info_{user_id}"))
    
    bot.send_message(ADMIN_ID, text, reply_markup=kb, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_wallet_add_"))
@admin_only
def admin_wallet_add_user(call):
    user_id = int(call.data.replace("admin_wallet_add_", ""))
    msg = bot.send_message(ADMIN_ID, f"💰 **مبلغ افزایش موجودی برای کاربر {user_id} را وارد کنید:**\n\nمثال: 50000", parse_mode='Markdown')
    bot.register_next_step_handler(msg, lambda m: process_wallet_change_for_user(m, user_id, "add"))

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_wallet_remove_"))
@admin_only
def admin_wallet_remove_user(call):
    user_id = int(call.data.replace("admin_wallet_remove_", ""))
    msg = bot.send_message(ADMIN_ID, f"💰 **مبلغ کاهش موجودی برای کاربر {user_id} را وارد کنید:**\n\nمثال: 50000", parse_mode='Markdown')
    bot.register_next_step_handler(msg, lambda m: process_wallet_change_for_user(m, user_id, "remove"))

def process_wallet_change_for_user(message, user_id, action):
    if message.from_user.id != ADMIN_ID:
        return
    
    try:
        amount = int(message.text.strip())
        
        if amount <= 0:
            bot.send_message(ADMIN_ID, "❌ مبلغ باید بیشتر از صفر باشد!")
            return
        
        if action == "remove":
            amount = -amount
        
        if UserManager.update_wallet(user_id, amount, f"مدیریت توسط ادمین - {action}"):
            new_balance = UserManager.get_wallet(user_id)
            log_admin_action(ADMIN_ID, f"{action}_wallet", user_id, f"مقدار: {abs(amount)}")
            
            bot.send_message(
                ADMIN_ID,
                f"✅ عملیات با موفقیت انجام شد.\n"
                f"موجودی جدید کاربر {user_id}: {format_number(new_balance)} تومان"
            )
            
            if amount > 0:
                bot.send_message(
                    user_id,
                    f"💰 مبلغ {format_number(amount)} تومان به کیف پول شما اضافه شد.\n"
                    f"💰 موجودی جدید: {format_number(new_balance)} تومان"
                )
            else:
                bot.send_message(
                    user_id,
                    f"💰 مبلغ {format_number(abs(amount))} تومان از کیف پول شما کسر شد.\n"
                    f"💰 موجودی جدید: {format_number(new_balance)} تومان"
                )
        else:
            bot.send_message(ADMIN_ID, "❌ خطا در تغییر موجودی!")
            
    except Exception as e:
        bot.send_message(ADMIN_ID, f"❌ خطا در پردازش! لطفاً یک عدد صحیح وارد کنید.\nخطا: {e}")

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_user_subs_"))
@admin_only
def admin_user_subs(call):
    user_id = int(call.data.replace("admin_user_subs_", ""))
    subs = SubscriptionManager.get_all_user_subs(user_id)
    
    if not subs:
        bot.send_message(ADMIN_ID, f"❌ کاربر {user_id} هیچ اشتراکی ندارد")
        return
    
    text = f"📋 **لیست اشتراک‌های کاربر {user_id}**\n\n"
    
    for sub in subs:
        sub_id, user_id, volume, sub_link, panel_user, expire, created_at, last_used, data_used, status = sub
        
        status_emoji = "✅" if status == "active" else "❌"
        text += f"{status_emoji} #{sub_id} - {volume}GB\n"
        text += f"📅 انقضا: {expire[:10]}\n"
        text += f"📊 مصرف: {data_used / 1073741824:.1f}/{volume} GB\n"
        text += f"🔧 وضعیت: {status}\n\n"
    
    bot.send_message(ADMIN_ID, text, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_ban_"))
@admin_only
def admin_ban_user(call):
    user_id = int(call.data.replace("admin_ban_", ""))
    
    msg = bot.send_message(ADMIN_ID, f"🚫 **دلیل مسدود کردن کاربر {user_id} را وارد کنید:**\n\n(اختیاری)", parse_mode='Markdown')
    bot.register_next_step_handler(msg, lambda m: ban_user_with_reason(m, user_id))

def ban_user_with_reason(message, user_id):
    reason = message.text.strip() if message.text else "نامشخص"
    UserManager.ban_user(user_id, reason)
    log_admin_action(ADMIN_ID, "ban_user", user_id, f"دلیل: {reason}")
    
    bot.send_message(ADMIN_ID, f"✅ کاربر {user_id} مسدود شد.\nدلیل: {reason}")
    bot.send_message(
        user_id,
        f"🚫 **حساب شما مسدود شده است!**\n\n"
        f"دلیل: {reason}\n\n"
        f"برای پیگیری و اعتراض، لطفاً با پشتیبانی تماس بگیرید.",
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith("admin_unban_"))
@admin_only
def admin_unban_user(call):
    user_id = int(call.data.replace("admin_unban_", ""))
    UserManager.unban_user(user_id)
    log_admin_action(ADMIN_ID, "unban_user", user_id, "رفع مسدودیت")
    
    bot.send_message(ADMIN_ID, f"✅ کاربر {user_id} از مسدودیت خارج شد.")
    bot.send_message(
        user_id,
        f"✅ **حساب شما از مسدودیت خارج شد!**\n\n"
        f"می‌توانید مجدداً از خدمات زیتون شاپ استفاده کنید.\n"
        f"لطفاً قوانین را رعایت کنید.",
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "admin_wallet")
@admin_only
def admin_wallet(call):
    kb = InlineKeyboardMarkup(row_width=1)
    kb.add(
        InlineKeyboardButton("➕ افزایش موجودی (با آیدی)", callback_data="admin_wallet_add_by_id"),
        InlineKeyboardButton("➖ کاهش موجودی (با آیدی)", callback_data="admin_wallet_remove_by_id"),
        InlineKeyboardButton("🔍 جستجوی کاربر", callback_data="admin_wallet_search")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel"))
    
    bot.edit_message_text(
        "💰 **مدیریت کیف پول کاربران**\n\n"
        "لطفاً عملیات مورد نظر را انتخاب کنید:",
        ADMIN_ID,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "admin_wallet_add_by_id")
@admin_only
def admin_wallet_add_by_id(call):
    msg = bot.send_message(
        ADMIN_ID,
        "🔢 **آیدی کاربر و مبلغ را وارد کنید:**\n\n"
        "مثال: 8046692057 50000\n\n"
        "این مبلغ به کیف پول کاربر اضافه خواهد شد.",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: process_wallet_change_by_id(m, "add"))

@bot.callback_query_handler(func=lambda call: call.data == "admin_wallet_remove_by_id")
@admin_only
def admin_wallet_remove_by_id(call):
    msg = bot.send_message(
        ADMIN_ID,
        "🔢 **آیدی کاربر و مبلغ را وارد کنید:**\n\n"
        "مثال: 8046692057 50000\n\n"
        "این مبلغ از کیف پول کاربر کسر خواهد شد.",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: process_wallet_change_by_id(m, "remove"))

def process_wallet_change_by_id(message, action):
    if message.from_user.id != ADMIN_ID:
        return
    
    try:
        parts = message.text.strip().split()
        if len(parts) != 2:
            raise ValueError("فرمت نامعتبر")
        
        user_id = int(parts[0])
        amount = int(parts[1])
        
        if amount <= 0:
            bot.send_message(ADMIN_ID, "❌ مبلغ باید بیشتر از صفر باشد!")
            return
        
        if action == "remove":
            amount = -amount
        
        if UserManager.update_wallet(user_id, amount, f"مدیریت توسط ادمین - {action}"):
            new_balance = UserManager.get_wallet(user_id)
            log_admin_action(ADMIN_ID, f"{action}_wallet", user_id, f"مقدار: {abs(amount)}")
            
            bot.send_message(
                ADMIN_ID,
                f"✅ عملیات با موفقیت انجام شد.\n"
                f"موجودی جدید کاربر {user_id}: {format_number(new_balance)} تومان"
            )
            
            if amount > 0:
                bot.send_message(
                    user_id,
                    f"💰 مبلغ {format_number(amount)} تومان به کیف پول شما اضافه شد.\n"
                    f"💰 موجودی جدید: {format_number(new_balance)} تومان"
                )
            else:
                bot.send_message(
                    user_id,
                    f"💰 مبلغ {format_number(abs(amount))} تومان از کیف پول شما کسر شد.\n"
                    f"💰 موجودی جدید: {format_number(new_balance)} تومان"
                )
        else:
            bot.send_message(ADMIN_ID, "❌ خطا در تغییر موجودی! آیا کاربر وجود دارد؟")
            
    except Exception as e:
        bot.send_message(ADMIN_ID, f"❌ خطا! فرمت صحیح: `8046692057 50000`\nخطا: {e}", parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "admin_wallet_search")
@admin_only
def admin_wallet_search(call):
    msg = bot.send_message(ADMIN_ID, "🔍 **آیدی کاربر را وارد کنید:**\n\nمثال: 8046692057", parse_mode='Markdown')
    bot.register_next_step_handler(msg, search_user_wallet)

def search_user_wallet(message):
    if message.from_user.id != ADMIN_ID:
        return
    
    try:
        user_id = int(message.text.strip())
        user = UserManager.get_user(user_id)
        
        if user:
            wallet = UserManager.get_wallet(user_id)
            orders = OrderManager.get_user_orders(user_id, 10)
            
            text = f"👤 **اطلاعات کاربر**\n\n"
            text += f"🆔 آیدی: `{user_id}`\n"
            text += f"👤 نام: {user[2]}\n"
            text += f"💰 موجودی کیف پول: {format_number(wallet)} تومان\n"
            text += f"📅 تاریخ عضویت: {user[4]}\n\n"
            text += f"📊 **آخرین سفارشات:**\n"
            
            for order in orders:
                status_text = "✅" if order[5] == "completed" else "⏳" if order[5] == "waiting_for_payment" else "❌"
                text += f"- #{order[0]}: {order[2]}GB - {format_number(order[3])} تومان - {status_text}\n"
            
            kb = InlineKeyboardMarkup()
            kb.add(
                InlineKeyboardButton("💰 مدیریت کیف پول", callback_data=f"admin_wallet_user_{user_id}"),
                InlineKeyboardButton("📋 اشتراک‌ها", callback_data=f"admin_user_subs_{user_id}")
            )
            
            bot.send_message(ADMIN_ID, text, reply_markup=kb, parse_mode='Markdown')
        else:
            bot.send_message(ADMIN_ID, "❌ کاربر یافت نشد!")
            
    except ValueError:
        bot.send_message(ADMIN_ID, "❌ آیدی نامعتبر! لطفاً یک عدد صحیح وارد کنید.")

@bot.callback_query_handler(func=lambda call: call.data == "admin_stats")
@admin_only
def admin_stats(call):
    users_count = get_total_users()
    orders_count = get_completed_orders()
    total_sales = get_total_sales()
    pending_orders = get_pending_orders()
    
    panel_stats = panel_manager.get_panel_stats()
    
    cursor = db_manager.execute("SELECT SUM(price) FROM orders WHERE status = 'waiting_for_payment'")
    pending_amount = cursor.fetchone()[0] or 0
    
    cursor = db_manager.execute("SELECT COUNT(*) FROM subs WHERE expire_date > ?", (datetime.now().strftime("%Y-%m-%d %H:%M:%S"),))
    active_subs = cursor.fetchone()[0]
    
    cursor = db_manager.execute("SELECT COUNT(*) FROM tickets WHERE status = 'open'")
    open_tickets = cursor.fetchone()[0]
    
    cursor = db_manager.execute("SELECT COUNT(*) FROM pending_operations WHERE retry_count < 5")
    pending_ops = cursor.fetchone()[0]
    
    cursor = db_manager.execute("SELECT SUM(total_spent) FROM users")
    total_spent = cursor.fetchone()[0] or 0
    
    cursor = db_manager.execute("SELECT COUNT(*) FROM orders WHERE created_at > date('now', '-7 days')")
    weekly_orders = cursor.fetchone()[0]
    
    cursor = db_manager.execute("SELECT SUM(price) FROM orders WHERE created_at > date('now', '-7 days') AND status = 'completed'")
    weekly_sales = cursor.fetchone()[0] or 0
    
    today = datetime.now().strftime("%Y-%m-%d")
    cursor = db_manager.execute("SELECT COUNT(*) FROM orders WHERE date(created_at) = ?", (today,))
    today_orders = cursor.fetchone()[0]
    
    cursor = db_manager.execute("SELECT SUM(price) FROM orders WHERE date(created_at) = ? AND status = 'completed'", (today,))
    today_sales = cursor.fetchone()[0] or 0
    
    text = f"📊 **آمار جامع ربات زیتون شاپ**\n\n"
    text += f"👥 **کاربران:**\n"
    text += f"• کل کاربران: {users_count}\n"
    text += f"• اشتراک فعال: {active_subs}\n\n"
    
    text += f"💰 **فروش:**\n"
    text += f"• کل فروش: {format_number(total_sales)} تومان\n"
    text += f"• مجموع شارژ کاربران: {format_number(total_spent)} تومان\n"
    text += f"• سفارشات موفق: {orders_count}\n"
    text += f"• سفارشات در انتظار: {pending_orders}\n"
    text += f"• مبلغ در انتظار: {format_number(pending_amount)} تومان\n\n"
    
    text += f"📅 **آمار امروز ({today}):**\n"
    text += f"• سفارشات امروز: {today_orders}\n"
    text += f"• فروش امروز: {format_number(today_sales)} تومان\n\n"
    
    text += f"📈 **آمار هفته گذشته:**\n"
    text += f"• سفارشات: {weekly_orders}\n"
    text += f"• فروش: {format_number(weekly_sales)} تومان\n\n"
    
    if panel_stats:
        text += f"🖥️ **آمار پنل:**\n"
        text += f"• کل کاربران پنل: {panel_stats['total_users']}\n"
        text += f"• کاربران فعال: {panel_stats['active_users']}\n"
        text += f"• حجم کل: {panel_stats['total_data_gb']:.0f} GB\n\n"
    
    text += f"🎫 **پشتیبانی:**\n"
    text += f"• تیکت‌های باز: {open_tickets}\n\n"
    
    text += f"⏳ **صف پردازش:**\n"
    text += f"• عملیات معلق: {pending_ops}\n"
    
    for i in range(0, len(text), 4000):
        bot.send_message(ADMIN_ID, text[i:i+4000], parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "admin_broadcast")
@admin_only
def admin_broadcast(call):
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("📢 ارسال به همه", callback_data="broadcast_all"),
        InlineKeyboardButton("✅ ارسال به کاربران فعال", callback_data="broadcast_active"),
        InlineKeyboardButton("💰 ارسال به کاربران دارای اشتراک", callback_data="broadcast_subscribers")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel"))
    
    bot.edit_message_text(
        "📢 **ارسال پیام همگانی**\n\n"
        "لطفاً نوع مخاطبان را انتخاب کنید:\n\n"
        "• **همه کاربران:** تمام کاربرانی که ربات را استارت کرده‌اند\n"
        "• **کاربران فعال:** کاربرانی که در 7 روز اخیر فعالیت داشته‌اند\n"
        "• **دارندگان اشتراک:** کاربرانی که اشتراک فعال دارند",
        ADMIN_ID,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith("broadcast_"))
@admin_only
def broadcast_type_selected(call):
    broadcast_type = call.data.replace("broadcast_", "")
    
    msg = bot.send_message(
        ADMIN_ID,
        "📢 **پیام خود را ارسال کنید:**\n\n"
        "می‌توانید از Markdown استفاده کنید.\n"
        "مثال:\n"
        "`**متن پررنگ**`\n"
        "`[متن لینک](https://example.com)`\n\n"
        "برای ارسال تصویر، عکس را به همراه کپشن ارسال کنید.",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, lambda m: send_broadcast_by_type(m, broadcast_type))

def send_broadcast_by_type(message, broadcast_type):
    if message.from_user.id != ADMIN_ID:
        return
    
    if broadcast_type == "all":
        cursor = db_manager.execute("SELECT user_id FROM users")
    elif broadcast_type == "active":
        seven_days_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d %H:%M:%S")
        cursor = db_manager.execute("SELECT user_id FROM users WHERE last_seen > ?", (seven_days_ago,))
    elif broadcast_type == "subscribers":
        cursor = db_manager.execute("SELECT DISTINCT user_id FROM subs WHERE expire_date > ?", (datetime.now().strftime("%Y-%m-%d %H:%M:%S"),))
    else:
        bot.send_message(ADMIN_ID, "❌ نوع نامعتبر!")
        return
    
    users = cursor.fetchall()
    users_list = [user[0] for user in users]
    total_users = len(users_list)
    
    if total_users == 0:
        bot.send_message(ADMIN_ID, "❌ هیچ کاربری برای ارسال وجود ندارد!")
        return
    
    status_msg = bot.send_message(ADMIN_ID, f"🔄 در حال ارسال پیام همگانی به {total_users} کاربر...")
    
    success_count = 0
    fail_count = 0
    start_time = time.time()
    
    for idx, user_id in enumerate(users_list):
        try:
            if message.photo:
                bot.send_photo(user_id, message.photo[-1].file_id, caption=message.caption, parse_mode='Markdown')
            elif message.document:
                bot.send_document(user_id, message.document.file_id, caption=message.caption, parse_mode='Markdown')
            else:
                bot.send_message(user_id, message.text, parse_mode='Markdown')
            
            success_count += 1
            
            if idx % 10 == 0:
                bot.edit_message_text(
                    f"🔄 در حال ارسال...\n"
                    f"✓ موفق: {success_count}\n"
                    f"✗ ناموفق: {fail_count}\n"
                    f"📊 پیشرفت: {idx}/{total_users}",
                    ADMIN_ID,
                    status_msg.message_id
                )
            
            time.sleep(0.05)
                
        except Exception as e:
            fail_count += 1
            logger.error(f"خطا در ارسال به {user_id}: {e}")
    
    elapsed_time = time.time() - start_time
    
    log_admin_action(ADMIN_ID, "broadcast", 0, f"موفق: {success_count}, ناموفق: {fail_count}, نوع: {broadcast_type}")
    
    bot.edit_message_text(
        f"✅ **ارسال پیام همگانی تکمیل شد!**\n\n"
        f"📊 **آمار ارسال:**\n"
        f"✓ ارسال موفق: {success_count}\n"
        f"✗ ارسال ناموفق: {fail_count}\n"
        f"👥 کل کاربران: {total_users}\n"
        f"⏱️ زمان اجرا: {elapsed_time:.1f} ثانیه\n\n"
        f"📝 نوع پیام: {broadcast_type}",
        ADMIN_ID,
        status_msg.message_id
    )
    
    logger.info(f"ارسال همگانی تکمیل شد - موفق: {success_count}, ناموفق: {fail_count}")

@bot.callback_query_handler(func=lambda call: call.data == "admin_users_list")
@admin_only
def admin_users_list(call):
    cursor = db_manager.execute("SELECT COUNT(*) FROM users")
    total = cursor.fetchone()[0]
    
    cursor = db_manager.execute("SELECT COUNT(*) FROM users WHERE last_seen > datetime('now', '-7 days')")
    active = cursor.fetchone()[0]
    
    text = f"📊 **آمار کاربران:**\n"
    text += f"• کل کاربران: {total}\n"
    text += f"• کاربران فعال (۷ روز اخیر): {active}\n\n"
    text += f"📋 **لیست ۲۰ کاربر اخیر:**\n\n"
    
    cursor = db_manager.execute("SELECT user_id, username, fullname, wallet, created_at, last_seen FROM users ORDER BY created_at DESC LIMIT 20")
    users = cursor.fetchall()
    
    for user in users:
        user_id, username, fullname, wallet, created_at, last_seen = user
        username_text = f"@{username}" if username else "ندارد"
        
        text += f"🆔 `{user_id}` | {fullname[:20]}\n"
        text += f"📝 {username_text}\n"
        text += f"💰 {format_number(wallet)} تومان\n"
        text += f"📅 عضویت: {created_at[:10]}\n"
        text += f"🟢 آخرین فعالیت: {last_seen[:10] if last_seen else 'نامشخص'}\n"
        text += f"➖➖➖➖➖➖\n\n"
    
    kb = InlineKeyboardMarkup()
    kb.add(InlineKeyboardButton("🔍 جستجوی کاربر", callback_data="admin_wallet_search"))
    kb.add(InlineKeyboardButton("📊 آمار کامل", callback_data="admin_stats"))
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel"))
    
    for i in range(0, len(text), 4000):
        bot.send_message(ADMIN_ID, text[i:i+4000], reply_markup=kb if i == 0 else None, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "admin_discounts")
@admin_only
def admin_discounts(call):
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("➕ ایجاد کد تخفیف جدید", callback_data="admin_create_discount"),
        InlineKeyboardButton("📋 لیست کدهای تخفیف", callback_data="admin_list_discounts")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel"))
    
    bot.edit_message_text(
        "🎁 **مدیریت کدهای تخفیف**\n\n"
        "از این بخش می‌توانید کدهای تخفیف ایجاد و مدیریت کنید.\n\n"
        "💡 نکته: پاداش خودکار 5% برای شارژهای بالای 100,000 تومان اعمال می‌شود.",
        ADMIN_ID,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "admin_create_discount")
@admin_only
def admin_create_discount(call):
    msg = bot.send_message(
        ADMIN_ID,
        "🎁 **ایجاد کد تخفیف جدید**\n\n"
        "لطفاً اطلاعات را به صورت زیر وارد کنید:\n\n"
        "`درصد_تخفیف تعداد_استفاده روزهای_اعتبار`\n\n"
        "مثال: `20 100 30`\n"
        "• 20 درصد تخفیف\n"
        "• حداکثر 100 بار استفاده\n"
        "• 30 روز اعتبار\n\n"
        "کد به صورت خودکار تولید می‌شود.",
        parse_mode='Markdown'
    )
    bot.register_next_step_handler(msg, process_create_discount)

def process_create_discount(message):
    if message.from_user.id != ADMIN_ID:
        return
    
    try:
        parts = message.text.strip().split()
        if len(parts) != 3:
            raise ValueError("فرمت نامعتبر")
        
        discount_percent = int(parts[0])
        max_uses = int(parts[1])
        days_valid = int(parts[2])
        
        if not (1 <= discount_percent <= 90):
            bot.send_message(ADMIN_ID, "❌ درصد تخفیف باید بین 1 تا 90 باشد!")
            return
        
        if max_uses < 1:
            bot.send_message(ADMIN_ID, "❌ تعداد استفاده باید حداقل 1 باشد!")
            return
        
        if days_valid < 1:
            bot.send_message(ADMIN_ID, "❌ روزهای اعتبار باید حداقل 1 باشد!")
            return
        
        code = DiscountManager.generate_code()
        
        if DiscountManager.create_discount_code(code, discount_percent, max_uses, days_valid):
            log_admin_action(ADMIN_ID, "create_discount", 0, f"کد: {code}, تخفیف: {discount_percent}%")
            
            text = (
                f"✅ **کد تخفیف با موفقیت ایجاد شد!**\n\n"
                f"🎁 **کد:** `{code}`\n"
                f"📊 درصد تخفیف: {discount_percent}%\n"
                f"🔢 تعداد دفعات قابل استفاده: {max_uses}\n"
                f"📅 اعتبار: {days_valid} روز\n\n"
                f"کاربران می‌توانند این کد را در زمان خرید وارد کنند."
            )
            bot.send_message(ADMIN_ID, text, parse_mode='Markdown')
        else:
            bot.send_message(ADMIN_ID, "❌ خطا در ایجاد کد تخفیف! احتمالاً کد تکراری است.")
            
    except Exception as e:
        bot.send_message(ADMIN_ID, f"❌ خطا! فرمت صحیح: `20 100 30`\nخطا: {e}", parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "admin_list_discounts")
@admin_only
def admin_list_discounts(call):
    cursor = db_manager.execute("SELECT * FROM discount_codes ORDER BY id DESC")
    discounts = cursor.fetchall()
    
    if not discounts:
        bot.answer_callback_query(call.id, "هیچ کد تخفیفی وجود ندارد!")
        return
    
    text = "🎁 **لیست کدهای تخفیف:**\n\n"
    
    for discount in discounts:
        discount_id, code, percent, max_uses, used_count, expires_at, is_active = discount
        
        status = "✅ فعال" if is_active else "❌ غیرفعال"
        expires_date = datetime.strptime(expires_at, "%Y-%m-%d %H:%M:%S")
        days_left = (expires_date - datetime.now()).days
        
        text += f"🔹 `{code}`\n"
        text += f"   📊 تخفیف: {percent}%\n"
        text += f"   🔢 استفاده: {used_count}/{max_uses}\n"
        text += f"   📅 اعتبار: {days_left} روز مانده\n"
        text += f"   🟢 وضعیت: {status}\n\n"
    
    bot.send_message(ADMIN_ID, text, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "admin_settings")
@admin_only
def admin_settings(call):
    try:
        cpu_percent = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        
        system_stats = (
            f"💻 **وضعیت سرور:**\n"
            f"• CPU: {cpu_percent}%\n"
            f"• RAM: {memory.percent}% ({memory.used // (1024**3)}/{memory.total // (1024**3)} GB)\n"
            f"• Disk: {disk.percent}% ({disk.used // (1024**3)}/{disk.total // (1024**3)} GB)\n\n"
        )
    except:
        system_stats = ""
    
    kb = InlineKeyboardMarkup(row_width=2)
    kb.add(
        InlineKeyboardButton("💾 پشتیبان‌گیری", callback_data="admin_backup_db"),
        InlineKeyboardButton("📊 مشاهده لاگ‌ها", callback_data="admin_view_logs"),
        InlineKeyboardButton("🔄 ریست دیتابیس", callback_data="admin_reset_db"),
        InlineKeyboardButton("👥 کاربران آنلاین", callback_data="admin_online_users")
    )
    kb.add(InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel"))
    
    bot.edit_message_text(
        f"⚙️ **تنظیمات ربات زیتون شاپ**\n\n"
        f"{system_stats}"
        f"لطفاً گزینه مورد نظر را انتخاب کنید:",
        ADMIN_ID,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "admin_backup_db")
@admin_only
def admin_backup_db_cmd(call):
    backup_path = backup_database()
    
    if backup_path:
        bot.answer_callback_query(call.id, "✅ پشتیبان با موفقیت گرفته شد!")
        
        with open(backup_path, 'rb') as f:
            bot.send_document(
                ADMIN_ID,
                f,
                caption=f"✅ پشتیبان دیتابیس - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            )
        log_admin_action(ADMIN_ID, "backup_db", 0, f"فایل: {backup_path}")
    else:
        bot.answer_callback_query(call.id, "❌ خطا در پشتیبان‌گیری!", show_alert=True)

@bot.callback_query_handler(func=lambda call: call.data == "admin_view_logs")
@admin_only
def admin_view_logs_cmd(call):
    try:
        with open('zitron_bot.log', 'rb') as f:
            bot.send_document(
                ADMIN_ID,
                f,
                caption=f"📋 لاگ‌های ربات - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            )
        
        try:
            with open('zitron_bot.log', 'r', encoding='utf-8') as f:
                lines = f.readlines()
                errors = [line for line in lines if 'ERROR' in line]
                
                if errors:
                    error_text = "❌ **آخرین خطاها:**\n\n"
                    for error in errors[-10:]:
                        error_text += f"{error[:200]}\n"
                    bot.send_message(ADMIN_ID, error_text, parse_mode='Markdown')
        except:
            pass
            
    except Exception as e:
        bot.send_message(ADMIN_ID, f"❌ خطا در ارسال لاگ: {e}")

@bot.callback_query_handler(func=lambda call: call.data == "admin_online_users")
@admin_only
def admin_online_users(call):
    thirty_min_ago = (datetime.now() - timedelta(minutes=30)).strftime("%Y-%m-%d %H:%M:%S")
    cursor = db_manager.execute("SELECT user_id, username, fullname, last_seen FROM users WHERE last_seen > ? ORDER BY last_seen DESC", (thirty_min_ago,))
    online_users = cursor.fetchall()
    
    if not online_users:
        bot.send_message(ADMIN_ID, "📭 هیچ کاربر آنلاینی در 30 دقیقه اخیر وجود ندارد")
        return
    
    text = f"🟢 **کاربران آنلاین (آخرین 30 دقیقه):**\n\n"
    text += f"👥 تعداد: {len(online_users)} نفر\n\n"
    
    for user in online_users[:30]:
        user_id, username, fullname, last_seen = user
        username_text = f"@{username}" if username else "ندارد"
        time_ago = (datetime.now() - datetime.strptime(last_seen, "%Y-%m-%d %H:%M:%S")).seconds // 60
        
        text += f"🆔 `{user_id}` | {fullname[:20]}\n"
        text += f"📝 {username_text}\n"
        text += f"⏱️ {time_ago} دقیقه پیش\n\n"
    
    bot.send_message(ADMIN_ID, text, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data == "admin_reset_db")
@admin_only
def admin_reset_db_confirm(call):
    kb = InlineKeyboardMarkup()
    kb.add(
        InlineKeyboardButton("⚠️ بله، حذف شود", callback_data="admin_reset_db_confirm"),
        InlineKeyboardButton("❌ انصراف", callback_data="admin_settings")
    )
    
    bot.edit_message_text(
        "⚠️ **هشدار جدی!**\n\n"
        "آیا از حذف تمام دیتابیس اطمینان دارید؟\n\n"
        "عملیات زیر حذف خواهد شد:\n"
        "• تمام کاربران و اطلاعات کیف پول\n"
        "• تمام اشتراک‌ها و سفارشات\n"
        "• تمام تیکت‌ها و لاگ‌ها\n\n"
        "⚠️ این عمل غیرقابل بازگشت است!\n"
        "⚠️ قبل از انجام، پشتیبان تهیه کنید!",
        ADMIN_ID,
        call.message.message_id,
        reply_markup=kb,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data == "admin_reset_db_confirm")
@admin_only
def admin_reset_db_execute(call):
    try:
        backup_path = backup_database()
        
        db_manager.execute("DELETE FROM users")
        db_manager.execute("DELETE FROM subs")
        db_manager.execute("DELETE FROM orders")
        db_manager.execute("DELETE FROM tickets")
        db_manager.execute("DELETE FROM admin_logs")
        db_manager.execute("DELETE FROM pending_operations")
        db_manager.execute("DELETE FROM wallet_transactions")
        db_manager.execute("DELETE FROM discount_codes")
        db_manager.execute("DELETE FROM user_sessions")
        db_manager.execute("DELETE FROM rate_limits")
        db_manager.execute("DELETE FROM receipts")
        db_manager.commit()
        
        log_admin_action(ADMIN_ID, "reset_db", 0, "کل دیتابیس ریست شد")
        
        text = "✅ **دیتابیس با موفقیت ریست شد!**\n\n"
        if backup_path:
            text += f"💾 پشتیبان تهیه شده: {backup_path}\n"
        text += "\n⚠️ تمام اطلاعات پاک شد."
        
        bot.edit_message_text(text, ADMIN_ID, call.message.message_id, parse_mode='Markdown')
        logger.warning("دیتابیس توسط ادمین ریست شد!")
        
    except Exception as e:
        bot.edit_message_text(f"❌ خطا در ریست دیتابیس: {e}", ADMIN_ID, call.message.message_id)

# ============================================
# هندلرهای عمومی
# ============================================
@bot.message_handler(content_types=['new_chat_members'])
def welcome_new_member(message):
    for new_member in message.new_chat_members:
        if new_member.id == bot.get_me().id:
            bot.send_message(message.chat.id, "🤖 ربات زیتون شاپ به گروه اضافه شد!\nبرای استفاده از ربات، پیام خصوصی بدهید.")
            return

@bot.message_handler(func=lambda m: True)
def handle_unknown(message):
    # بررسی عضویت به صورت دستی (بدون دکوراتور برای جلوگیری از حلقه بی‌نهایت)
    if not is_member(message.from_user.id):
        kb = InlineKeyboardMarkup()
        kb.add(InlineKeyboardButton("📢 عضویت در کانال", url=f"https://t.me/{FORCE_CHANNEL[1:]}"))
        kb.add(InlineKeyboardButton("✅ بررسی عضویت", callback_data="check_member"))
        text = f"⚠️ لطفاً ابتدا در کانال زیر عضو شوید:\n\n{FORCE_CHANNEL}\n\nپس از عضویت روی دکمه بررسی کلیک کنید."
        bot.send_message(message.from_user.id, text, reply_markup=kb)
        return
    
    wallet = UserManager.get_wallet(message.from_user.id)
    text = MAIN_MENU_TEXT.format(
        name=message.from_user.first_name,
        wallet=format_number(wallet)
    )
    bot.send_message(message.from_user.id, text, reply_markup=main_keyboard(), parse_mode='Markdown')
    
from flask import Flask, request
app = Flask(__name__)
application = app

@app.route("/", methods=['GET', 'POST'])
def webhook():
    if request.method == 'POST':
        json_str = request.get_data().decode('UTF-8')
        update = telebot.types.Update.de_json(json_str)
        bot.process_new_updates([update])
        return "OK", 200
    return "Bot is running!", 200

# ============================================
# اجرای ربات با روش Polling
# ============================================
if __name__ == "__main__":
    print("🤖 ربات در حال اجرا است...")
    bot.infinity_polling(timeout=10, long_polling_timeout=10)