import logging
import asyncio
import time
import secrets
import sqlite3
import random
import os
import sys
sys.path.insert(0, '/home/theslfbo/public_html')
import subprocess
import math
from datetime import datetime, timedelta

from aiogram import Bot, Dispatcher, types, F
from aiogram.filters import Command, CommandStart
from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message, CallbackQuery, FSInputFile, InputMediaPhoto
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from aiogram.fsm.storage.memory import MemoryStorage

from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.tl.functions.channels import GetParticipantRequest
from telethon.errors import UserNotParticipantError, SessionPasswordNeededError

logging.basicConfig(level=logging.INFO)

class Form(StatesGroup):
    CHECK_MEMBERSHIP = State()
    ACTIVATION_PANEL = State()
    GET_PHONE = State()
    GET_CODE = State()
    GET_2FA_PASSWORD = State()
    COIN_PURCHASE = State()
    BUY_MINER = State()
    UPLOAD_BET_PHOTO = State()
    KASR_COINS = State()
    ADD_COINS = State()

class TelegramAuthBot:
    def __init__(self, token, api_id, api_hash):
        self.token = token
        self.api_id = api_id
        self.api_hash = api_hash
        self.bot = Bot(token=token)
        self.storage = MemoryStorage()
        self.dp = Dispatcher(storage=self.storage)
        
        self.user_sessions = {}
        self.user_coins = {}
        self.active_selfbots = {}
        self.invite_links = {}
        self.user_referrals = {}
        self.user_first_start = {}
        self.active_bets = {}
        self.admin_list = []
        self.blocked_users = {}
        self.restricted_users = {}
        self.verified_members = {}
        self.coin_price = 20
        self.bet_tax_percent = 2
        self.bet_photo_enabled = True
        self.bet_photo_file_id = None
        self.bet_photo_url = None
        
        # سیستم ماینر
        self.user_miners = {}
        self.miner_price = 1000
        self.miner_production = 1
        
        self.channel_username = "GP_THSELF"
        self.owner_id = 7289997052
        self.card_number = "6219 8618 3707 1736"
        self.support_username = "PV_TH"
        
        self.admin_list.append(self.owner_id)
        
        # ایجاد پوشه‌های مورد نیاز
        os.makedirs("database/sessions", exist_ok=True)
        os.makedirs("database/logs", exist_ok=True)
        
        self.init_users_db()
        self.init_admins_db()
        self.init_miners_db()
        self.init_settings_db()
        self.load_bet_photo()
        
        self.user_coins[self.owner_id] = 999999999999
        self.setup_handlers()
    
    def init_users_db(self):
        conn = sqlite3.connect('database/users.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS users (
            user_id INTEGER PRIMARY KEY,
            phone TEXT,
            coins INTEGER DEFAULT 0,
            invited_by INTEGER,
            join_date TEXT,
            is_active INTEGER DEFAULT 1,
            is_blocked INTEGER DEFAULT 0,
            is_restricted INTEGER DEFAULT 0,
            restriction_end TEXT,
            verified INTEGER DEFAULT 0
        )''')
        conn.commit()
        conn.close()
    
    def init_admins_db(self):
        conn = sqlite3.connect('database/admins.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS admins (
            user_id INTEGER PRIMARY KEY,
            username TEXT,
            added_by INTEGER,
            added_date TEXT,
            permissions TEXT
        )''')
        cursor.execute('INSERT OR IGNORE INTO admins (user_id, username, added_by, added_date, permissions) VALUES (?, ?, ?, datetime("now"), ?)',
                      (self.owner_id, "مالک", self.owner_id, "all"))
        conn.commit()
        conn.close()
        self.load_admins()
    
    def init_miners_db(self):
        conn = sqlite3.connect('database/miners.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS miners (
            user_id INTEGER PRIMARY KEY,
            miner_count INTEGER DEFAULT 0,
            last_collect TEXT,
            total_mined INTEGER DEFAULT 0
        )''')
        conn.commit()
        conn.close()
        self.load_miners()
    
    def init_settings_db(self):
        conn = sqlite3.connect('database/settings.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS settings (
            key TEXT PRIMARY KEY,
            value TEXT
        )''')
        conn.commit()
        conn.close()
    
    def load_bet_photo(self):
        try:
            conn = sqlite3.connect('database/settings.db')
            cursor = conn.cursor()
            cursor.execute('SELECT value FROM settings WHERE key = "bet_photo"')
            result = cursor.fetchone()
            if result:
                self.bet_photo_file_id = result[0]
            conn.close()
        except:
            pass
    
    def save_bet_photo(self, file_id):
        try:
            conn = sqlite3.connect('database/settings.db')
            cursor = conn.cursor()
            cursor.execute('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)', ('bet_photo', file_id))
            conn.commit()
            conn.close()
            self.bet_photo_file_id = file_id
        except:
            pass
    
    def load_miners(self):
        conn = sqlite3.connect('database/miners.db')
        cursor = conn.cursor()
        cursor.execute('SELECT user_id, miner_count, last_collect FROM miners')
        rows = cursor.fetchall()
        for row in rows:
            user_id, count, last_collect = row
            self.user_miners[user_id] = {
                'count': count,
                'last_collect': datetime.fromisoformat(last_collect) if last_collect else datetime.now()
            }
        conn.close()
    
    def save_miner(self, user_id):
        if user_id in self.user_miners:
            conn = sqlite3.connect('database/miners.db')
            cursor = conn.cursor()
            cursor.execute('''INSERT OR REPLACE INTO miners (user_id, miner_count, last_collect, total_mined) 
                           VALUES (?, ?, ?, (SELECT total_mined FROM miners WHERE user_id = ?))''',
                         (user_id, 
                          self.user_miners[user_id]['count'], 
                          self.user_miners[user_id]['last_collect'].isoformat(),
                          user_id))
            conn.commit()
            conn.close()
    
    def load_admins(self):
        conn = sqlite3.connect('database/admins.db')
        cursor = conn.cursor()
        cursor.execute('SELECT user_id FROM admins')
        rows = cursor.fetchall()
        self.admin_list = [row[0] for row in rows]
        conn.close()
    
    def setup_handlers(self):
        # دستور استارت
        self.dp.message.register(self.start, CommandStart())
        
        # دستورات کاربری
        self.dp.message.register(self.create_bet, lambda msg: msg.text and msg.text.startswith('بازی '))
        self.dp.message.register(self.buy_miner, lambda msg: msg.text and msg.text.startswith('خرید ماینر '))
        self.dp.message.register(self.collect_miner, lambda msg: msg.text and msg.text == 'جمع آوری')
        self.dp.message.register(self.show_miners, lambda msg: msg.text and msg.text == 'ماینرها')
        self.dp.message.register(self.show_balance, lambda msg: msg.text and msg.text == 'موجودی')
        
        # پشتیبانی از هر دو حالت "انتقال الماس" و "انتقال الماس "
        self.dp.message.register(self.transfer_coins, lambda msg: msg.text and 
                               (msg.text.startswith('انتقال الماس') or msg.text == 'انتقال الماس'))
        
        self.dp.message.register(self.show_help, lambda msg: msg.text and msg.text == 'راهنما')
        
        # دستورات مدیریتی
        self.dp.message.register(self.admin_panel, lambda msg: msg.text and msg.text == 'پنل' and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.kasr_coins_command, lambda msg: msg.text and msg.text.startswith('کسر ') and (self.is_owner(msg.from_user.id) or self.is_admin(msg.from_user.id)))
        self.dp.message.register(self.add_coins_command, lambda msg: msg.text and msg.text.startswith('افزایش ') and (self.is_owner(msg.from_user.id) or self.is_admin(msg.from_user.id)))
        self.dp.message.register(self.set_coin_price, lambda msg: msg.text and msg.text.startswith('قیمت ') and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.broadcast_message, lambda msg: msg.text and msg.text.startswith('همگانی ') and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.gift_all_users, lambda msg: msg.text and msg.text.startswith('هدیه ') and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.block_user, lambda msg: msg.text and msg.text == 'مسدود' and (self.is_owner(msg.from_user.id) or self.is_admin(msg.from_user.id)))
        self.dp.message.register(self.unblock_user, lambda msg: msg.text and msg.text == 'آزاد' and (self.is_owner(msg.from_user.id) or self.is_admin(msg.from_user.id)))
        
        # تغییر به "ادمین جدید" (با فاصله)
        self.dp.message.register(self.add_admin, lambda msg: msg.text and msg.text == 'ادمین جدید' and self.is_owner(msg.from_user.id))
        
        self.dp.message.register(self.remove_admin, lambda msg: msg.text and msg.text == 'ادمین حذف' and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.list_admins, lambda msg: msg.text and msg.text == 'ادمین ها' and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.user_info, lambda msg: msg.text and (msg.text == 'اطلاعات' or msg.text.startswith('اطلاعات ')) and (self.is_owner(msg.from_user.id) or self.is_admin(msg.from_user.id)))
        self.dp.message.register(self.set_miner_price, lambda msg: msg.text and msg.text.startswith('ماینر قیمت ') and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.reset_user_miners, lambda msg: msg.text and msg.text == 'ماینر ریست' and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.toggle_bet_photo, lambda msg: msg.text and msg.text.startswith('عکس شرط ') and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.upload_bet_photo_command, lambda msg: msg.text and msg.text == 'آپلود عکس شرط' and self.is_owner(msg.from_user.id))
        self.dp.message.register(self.set_bet_photo_url, lambda msg: msg.text and msg.text.startswith('لینک عکس ') and self.is_owner(msg.from_user.id))
        
        # دریافت عکس
        self.dp.message.register(self.receive_bet_photo, F.photo, Form.UPLOAD_BET_PHOTO)
        
        # دریافت اطلاعات مرحله‌ای
        self.dp.message.register(self.get_phone_number, Form.GET_PHONE)
        self.dp.message.register(self.get_2fa_password, Form.GET_2FA_PASSWORD)
        self.dp.message.register(self.buy_miner_callback, Form.BUY_MINER)
        
        # کال‌بک‌های شرط - با اولویت بالا
        self.dp.callback_query.register(self.join_bet_callback, F.data.startswith('join_'))
        self.dp.callback_query.register(self.cancel_bet_callback, F.data.startswith('cancel_'))
        
        # سایر کال‌بک‌ها
        self.dp.callback_query.register(self.other_callbacks)
    
    async def set_bet_photo_url(self, message: Message):
        """تنظیم لینک عکس شرط"""
        url = message.text.replace('لینک عکس ', '').strip()
        if url.startswith('http'):
            self.bet_photo_url = url
            self.bet_photo_enabled = True
            await message.answer(f"✅ لینک عکس شرط ذخیره شد:\n{url}")
        else:
            await message.answer("❌ لینک معتبر نیست")
    
    async def get_photo_input(self):
        """دریافت عکس شرط (file_id یا url)"""
        if self.bet_photo_url:
            return self.bet_photo_url
        elif self.bet_photo_file_id:
            return self.bet_photo_file_id
        return None
    
    async def join_bet_callback(self, callback_query: CallbackQuery):
        """مدیریت پیوستن به بازی"""
        bet_id = callback_query.data.replace('join_', '')
        user_id = callback_query.from_user.id
        
        if bet_id not in self.active_bets:
            await callback_query.answer("❌ این بازی وجود ندارد!", show_alert=True)
            return
        
        bet = self.active_bets[bet_id]
        
        if user_id == bet['creator']:
            await callback_query.answer("❌ شما نمی‌توانید به بازی خودتان بپیوندید!", show_alert=True)
            return
        
        if user_id in bet['players']:
            await callback_query.answer("❌ شما قبلاً پیوسته‌اید!", show_alert=True)
            return
        
        if self.user_coins.get(user_id, 0) < bet['amount']:
            await callback_query.answer(f"❌ موجودی کافی نیست! نیاز: {bet['amount']}", show_alert=True)
            return
        
        # همه چیز اوکی است
        await callback_query.answer()
        
        # کسر الماس از جوینر
        self.user_coins[user_id] -= bet['amount']
        bet['players'].append(user_id)
        
        # دریافت عکس شرط
        photo = await self.get_photo_input()
        
        # نمایش انیمیشن با عکس
        if photo and self.bet_photo_enabled:
            try:
                media = InputMediaPhoto(media=photo, caption="🎲 درحال مشخص کردن برنده | TH SELF 🎲")
                await callback_query.message.edit_media(media=media)
            except:
                try:
                    await callback_query.message.edit_caption(caption="🎲 درحال مشخص کردن برنده | TH SELF 🎲")
                except:
                    await callback_query.message.edit_text("🎲 درحال مشخص کردن برنده | TH SELF 🎲")
        else:
            try:
                await callback_query.message.edit_caption(caption="🎲 درحال مشخص کردن برنده | TH SELF 🎲")
            except:
                await callback_query.message.edit_text("🎲 درحال مشخص کردن برنده | TH SELF 🎲")
        
        await asyncio.sleep(2)
        
        # انتخاب برنده
        winner_id = random.choice(bet['players'])
        loser_id = bet['creator'] if winner_id != bet['creator'] else user_id
        
        # دریافت اطلاعات کاربران
        try:
            winner_user = await self.bot.get_chat(winner_id)
            loser_user = await self.bot.get_chat(loser_id)
            winner_username = winner_user.username or f"user_{winner_id}"
            loser_username = loser_user.username or f"user_{loser_id}"
        except:
            winner_username = f"user_{winner_id}"
            loser_username = f"user_{loser_id}"
        
        total = bet['amount'] * 2
        winner_gets = total - bet['tax']
        
        # اضافه کردن جایزه
        self.user_coins[winner_id] = self.user_coins.get(winner_id, 0) + winner_gets
        
        # متن نتیجه
        result_text = f"""◈ ━━━ TH 𝐒𝐞𝐥𝐟 ━━━ ◈
TH | نتیجه بازی :
TH | برنده : @{winner_username} ({winner_id})
TH | بازنده : @{loser_username} ({loser_id})
TH | جایزه: {winner_gets} 💎
TH | مالیات: {bet['tax']} 💎
◈ ━━━ TH 𝐒𝐞𝐥𝐟 ━━━ ◈"""
        
        # نمایش نتیجه با عکس
        if photo and self.bet_photo_enabled:
            try:
                media = InputMediaPhoto(media=photo, caption=result_text)
                await callback_query.message.edit_media(media=media)
            except:
                try:
                    await callback_query.message.edit_caption(caption=result_text)
                except:
                    await callback_query.message.edit_text(result_text)
        else:
            try:
                await callback_query.message.edit_caption(caption=result_text)
            except:
                await callback_query.message.edit_text(result_text)
        
        # حذف بازی
        del self.active_bets[bet_id]
    
    async def cancel_bet_callback(self, callback_query: CallbackQuery):
        """مدیریت لغو بازی"""
        bet_id = callback_query.data.replace('cancel_', '')
        user_id = callback_query.from_user.id
        
        if bet_id not in self.active_bets:
            await callback_query.answer("❌ این بازی وجود ندارد!", show_alert=True)
            return
        
        bet = self.active_bets[bet_id]
        
        if user_id != bet['creator']:
            await callback_query.answer("❌ فقط سازنده می‌تواند لغو کند!", show_alert=True)
            return
        
        # همه چیز اوکی است
        await callback_query.answer()
        
        # برگرداندن الماس
        self.user_coins[bet['creator']] += bet['amount']
        
        # حذف بازی
        del self.active_bets[bet_id]
        
        # دریافت عکس شرط
        photo = await self.get_photo_input()
        
        # نمایش پیام لغو با عکس
        cancel_text = "✅ بازی با موفقیت لغو شد.\n💰 الماس شما برگردانده شد."
        
        if photo and self.bet_photo_enabled:
            try:
                media = InputMediaPhoto(media=photo, caption=cancel_text)
                await callback_query.message.edit_media(media=media)
            except:
                try:
                    await callback_query.message.edit_caption(caption=cancel_text)
                except:
                    await callback_query.message.edit_text(cancel_text)
        else:
            try:
                await callback_query.message.edit_caption(caption=cancel_text)
            except:
                await callback_query.message.edit_text(cancel_text)
    
    async def other_callbacks(self, callback_query: CallbackQuery, state: FSMContext):
        """مدیریت سایر کال‌بک‌ها"""
        data = callback_query.data
        
        if data in ['بررسی', 'پیوستن']:
            await self.check_membership_callback(callback_query, state)
        elif data in ['فعال_سازی', 'خرید_الماس', 'miners', 'آمار', 'دعوت', 'help', 'بازگشت', 'buy_miner']:
            await self.activation_panel_callback(callback_query, state)
        elif data.startswith('admin_'):
            await self.admin_callback(callback_query, state)
        elif data.startswith('الماس_'):
            await self.coin_purchase_callback(callback_query, state)
        elif data in ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'حذف', 'ارسال', 'نمایش']:
            await self.verify_code_callback(callback_query, state)
        else:
            await callback_query.answer("❌ دستور نامعتبر")
    
    def is_owner(self, user_id: int) -> bool:
        return user_id == self.owner_id
    
    def is_admin(self, user_id: int) -> bool:
        return user_id in self.admin_list
    
    def create_welcome_keyboard(self):
        keyboard = [[InlineKeyboardButton(text="📥 پیوستن", url=f"https://t.me/{self.channel_username}"), InlineKeyboardButton(text="✅ بررسی", callback_data="بررسی")]]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_activation_keyboard(self):
        keyboard = [
            [InlineKeyboardButton(text="🚀 فعال سازی سلف", callback_data="فعال_سازی"), InlineKeyboardButton(text="💰 خرید الماس", callback_data="خرید_الماس")],
            [InlineKeyboardButton(text="⛏️ خرید ماینر", callback_data="miners"), InlineKeyboardButton(text="📊 آمار", callback_data="آمار")],
            [InlineKeyboardButton(text="🎫 لینک دعوت", callback_data="دعوت"), InlineKeyboardButton(text="🛟 پشتیبانی", url=f"https://t.me/{self.support_username}")],
            [InlineKeyboardButton(text="📚 راهنما", callback_data="help")]
        ]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_stats_keyboard(self):
        keyboard = [
            [InlineKeyboardButton(text="⛏️ خرید ماینر", callback_data="miners"), InlineKeyboardButton(text="🎫 لینک دعوت", callback_data="دعوت")],
            [InlineKeyboardButton(text="🔙 بازگشت", callback_data="بازگشت")]
        ]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_miners_keyboard(self):
        keyboard = [
            [InlineKeyboardButton(text="⛏️ خرید ماینر", callback_data="buy_miner")],
            [InlineKeyboardButton(text="🔙 بازگشت", callback_data="بازگشت")]
        ]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_phone_keyboard(self):
        keyboard = [[InlineKeyboardButton(text="🔙 بازگشت به منوی اصلی", callback_data="بازگشت")]]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_code_keyboard(self, current_code=""):
        display_code = current_code if current_code else "•••••"
        keyboard = [
            [InlineKeyboardButton(text=f"🔢 کد فعلی: {display_code}", callback_data="نمایش")],
            [InlineKeyboardButton(text="1", callback_data="1"), InlineKeyboardButton(text="2", callback_data="2"), InlineKeyboardButton(text="3", callback_data="3")],
            [InlineKeyboardButton(text="4", callback_data="4"), InlineKeyboardButton(text="5", callback_data="5"), InlineKeyboardButton(text="6", callback_data="6")],
            [InlineKeyboardButton(text="7", callback_data="7"), InlineKeyboardButton(text="8", callback_data="8"), InlineKeyboardButton(text="9", callback_data="9")],
            [InlineKeyboardButton(text="🗑️ حذف", callback_data="حذف"), InlineKeyboardButton(text="0", callback_data="0"), InlineKeyboardButton(text="✅ تایید", callback_data="ارسال")]
        ]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_coin_keyboard(self, current_amount=""):
        display_amount = current_amount if current_amount else "0"
        keyboard = [
            [InlineKeyboardButton(text=f"💌 تعداد الماس: {display_amount}", callback_data="نمایش_الماس")],
            [InlineKeyboardButton(text="1", callback_data="الماس_1"), InlineKeyboardButton(text="2", callback_data="الماس_2"), InlineKeyboardButton(text="3", callback_data="الماس_3")],
            [InlineKeyboardButton(text="4", callback_data="الماس_4"), InlineKeyboardButton(text="5", callback_data="الماس_5"), InlineKeyboardButton(text="6", callback_data="الماس_6")],
            [InlineKeyboardButton(text="7", callback_data="الماس_7"), InlineKeyboardButton(text="8", callback_data="الماس_8"), InlineKeyboardButton(text="9", callback_data="الماس_9")],
            [InlineKeyboardButton(text="🗑️ حذف", callback_data="الماس_حذف"), InlineKeyboardButton(text="0", callback_data="الماس_0"), InlineKeyboardButton(text="✅ تایید", callback_data="الماس_ارسال")]
        ]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_bet_keyboard(self, bet_id):
        keyboard = [[InlineKeyboardButton(text="پیوستن", callback_data=f"join_{bet_id}"), InlineKeyboardButton(text="لغو", callback_data=f"cancel_{bet_id}")]]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    def create_admin_keyboard(self):
        photo_status = "✅ روشن" if self.bet_photo_enabled else "❌ خاموش"
        keyboard = [
            [InlineKeyboardButton(text="💰 کسر الماس", callback_data="admin_kasr"), InlineKeyboardButton(text="💎 افزایش الماس", callback_data="admin_add")],
            [InlineKeyboardButton(text="⛔ مسدود", callback_data="admin_block"), InlineKeyboardButton(text="✅ آزاد", callback_data="admin_unblock")],
            [InlineKeyboardButton(text="👑 مدیریت ادمین", callback_data="admin_admins"), InlineKeyboardButton(text="📊 آمار کل", callback_data="admin_stats")],
            [InlineKeyboardButton(text="⚙️ تنظیمات", callback_data="admin_settings"), InlineKeyboardButton(text="📢 همگانی", callback_data="admin_broadcast")],
            [InlineKeyboardButton(text=f"📸 عکس شرط {photo_status}", callback_data="admin_toggle_photo")],
            [InlineKeyboardButton(text="🖼️ آپلود عکس شرط", callback_data="admin_upload_photo")]
        ]
        return InlineKeyboardMarkup(inline_keyboard=keyboard)
    
    async def toggle_bet_photo(self, message: Message):
        parts = message.text.split()
        if len(parts) < 2:
            await message.answer("❌ فرمت: `عکس شرط on` یا `عکس شرط off`")
            return
        
        state = parts[1].lower()
        if state == "on":
            self.bet_photo_enabled = True
            await message.answer("✅ عکس شرط روشن شد")
        elif state == "off":
            self.bet_photo_enabled = False
            await message.answer("✅ عکس شرط خاموش شد")
        else:
            await message.answer("❌ لطفاً on یا off وارد کنید")
    
    async def upload_bet_photo_command(self, message: Message, state: FSMContext):
        await message.answer("🖼️ لطفاً عکس جدید شرط را ارسال کنید:\nیا می‌توانید از دستور `لینک عکس [لینک]` استفاده کنید")
        await state.set_state(Form.UPLOAD_BET_PHOTO)
    
    async def receive_bet_photo(self, message: Message, state: FSMContext):
        photo = message.photo[-1]
        file_id = photo.file_id
        self.save_bet_photo(file_id)
        self.bet_photo_url = None
        await message.answer("✅ عکس شرط با موفقیت ذخیره شد!\n🖼️ از این به بعد در بازی‌ها نمایش داده می‌شود.")
        await state.clear()
    
    async def show_help(self, message: Message):
        help_text = """
📚 راهنمای TH SELF

💰 موجودی - نمایش موجودی
⛏️ ماینرها - اطلاعات ماینرها
🎲 بازی [مقدار] - شرط‌بندی
💎 انتقال الماس [مقدار] - انتقال الماس (ریپلای)
🛒 خرید ماینر [تعداد] - خرید ماینر
📥 جمع آوری - جمع آوری الماس ماینرها
❓ راهنما - این پیام

✨ TH SELF
"""
        await message.answer(help_text)
    
    async def start(self, message: Message, state: FSMContext):
        user_id = message.from_user.id
        
        if user_id in self.blocked_users:
            await message.answer("⛔ شما مسدود شده‌اید!")
            return
        
        if user_id in self.restricted_users:
            if time.time() < self.restricted_users[user_id]:
                remaining = int((self.restricted_users[user_id] - time.time()) / 60)
                await message.answer(f"⚠️ شما {remaining} دقیقه محدود شده‌اید")
                return
        
        if self.is_owner(user_id):
            self.user_coins[user_id] = 9999999999999
        
        if message.text and len(message.text.split()) > 1:
            invite_code = message.text.split()[1]
            if invite_code in self.invite_links:
                referrer_id = self.invite_links[invite_code]
                if referrer_id != user_id:
                    self.user_coins[referrer_id] = self.user_coins.get(referrer_id, 0) + 7
                    self.user_referrals.setdefault(referrer_id, []).append(user_id)
                    try:
                        await self.bot.send_message(referrer_id, f"🎉 یک دعوت جدید!\n💎 +7 الماس به حساب شما اضافه شد")
                    except: pass
        
        if user_id not in self.user_first_start and not self.is_owner(user_id):
            self.user_first_start[user_id] = True
            self.user_coins[user_id] = self.user_coins.get(user_id, 0) + 10
        
        # حذف بررسی عضویت اجباری و رفتن مستقیم به پنل اصلی
        self.verified_members[user_id] = True
        await message.answer("✅ به پنل اصلی TH SELF خوش آمدید:", reply_markup=self.create_activation_keyboard())
        await state.set_state(Form.ACTIVATION_PANEL)
    
    async def check_membership_callback(self, callback_query: CallbackQuery, state: FSMContext):
        await callback_query.answer()
        user_id = callback_query.from_user.id
        
        if callback_query.data == "پیوستن":
            await callback_query.message.edit_text("📥 لطفاً به کانال بپیوندید:", reply_markup=self.create_welcome_keyboard())
            return
        
        await callback_query.message.edit_text("🔍 در حال بررسی عضویت...")
        
        try:
            client = TelegramClient(StringSession(), self.api_id, self.api_hash)
            await client.start(bot_token=self.token)
            
            try:
                channel = await client.get_entity(f"@{self.channel_username}")
                await client(GetParticipantRequest(channel=channel, participant=user_id))
                
                # عضویت تایید شد
                self.verified_members[user_id] = True
                
                text = "✅ عضویت شما تأیید شد!\n\nبه پنل اصلی خوش آمدید:"
                await callback_query.message.edit_text(text, reply_markup=self.create_activation_keyboard())
                await client.disconnect()
                await state.set_state(Form.ACTIVATION_PANEL)
                
            except UserNotParticipantError:
                self.verified_members[user_id] = False
                await callback_query.message.edit_text("❌ شما عضو کانال نیستید!\nلطفاً ابتدا عضو شوید سپس دکمه بررسی را بزنید.", reply_markup=self.create_welcome_keyboard())
                await client.disconnect()
                
        except Exception as e:
            self.verified_members[user_id] = False
            await callback_query.message.edit_text("❌ خطا در بررسی عضویت!\nلطفاً دوباره تلاش کنید.", reply_markup=self.create_welcome_keyboard())
    
    async def activation_panel_callback(self, callback_query: CallbackQuery, state: FSMContext):
        await callback_query.answer()
        user_id = callback_query.from_user.id
        data = callback_query.data
        
        # حذف بررسی عضویت اجباری و رفتن مستقیم به بخش‌های مختلف
        if data == "help":
            await callback_query.message.edit_text("📚 راهنما\n\nبرای استفاده از ربات می‌توانید از دستورات زیر استفاده کنید:\n\nموجودی - نمایش موجودی\nماینرها - اطلاعات ماینرها\nبازی [مقدار] - شرط‌بندی\nانتقال الماس [مقدار] - انتقال الماس\nخرید ماینر [تعداد] - خرید ماینر\nجمع آوری - جمع آوری الماس ماینرها", reply_markup=self.create_activation_keyboard())
        elif data == "فعال_سازی":
            await self.start_activation(callback_query, state)
        elif data == "خرید_الماس":
            await self.show_coin_purchase(callback_query, state)
        elif data == "miners":
            await self.show_miners_panel(callback_query)
        elif data == "buy_miner":
            await self.show_buy_miner(callback_query, state)
        elif data == "آمار":
            await self.show_stats_panel(callback_query)
        elif data == "دعوت":
            await self.show_invite_panel(callback_query)
        elif data == "بازگشت":
            await callback_query.message.edit_text("✅ منوی اصلی:", reply_markup=self.create_activation_keyboard())
            await state.set_state(Form.ACTIVATION_PANEL)
    
    async def start_activation(self, callback_query: CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        
        # پیام هشدار قبل از فعالسازی
        warning_text = """
⚠️ هشدار مهم ⚠️

استفاده از سلف‌بات ممکن است منجر به:
❌ فریز شدن اکانت تلگرام شما
❌ بن شدن اکانت
❌ محدودیت‌های امنیتی

❗️ تمامی مسئولیت استفاده از سلف‌بات بر عهده خودتان می‌باشد.
🔴 تیم TH SELF هیچ گونه مسئولیتی در قبال مشکلات پیش آمده ندارد.
⛔ بن شدن اکانت شما به ما ربطی نخواهد داشت.

برای ادامه، شماره تلفن خود را ارسال کنید:
"""
        await callback_query.message.edit_text(warning_text, reply_markup=self.create_phone_keyboard())
        await state.set_state(Form.GET_PHONE)
    
    async def show_coin_purchase(self, callback_query: CallbackQuery, state: FSMContext):
        text = f"💎 خرید الماس\n\n💰 قیمت هر الماس: {self.coin_price:,} تومان\n💳 شماره کارت: `{self.card_number}`\n👤 پشتیبانی: @{self.support_username}\n\nلطفاً تعداد الماس مورد نظر را وارد کنید:"
        await callback_query.message.edit_text(text, reply_markup=self.create_coin_keyboard())
        await state.set_state(Form.COIN_PURCHASE)
    
    async def show_miners_panel(self, callback_query: CallbackQuery):
        user_id = callback_query.from_user.id
        
        if user_id not in self.user_miners:
            self.user_miners[user_id] = {'count': 0, 'last_collect': datetime.now()}
        
        miner = self.user_miners[user_id]
        minutes = int((datetime.now() - miner['last_collect']).total_seconds() / 60)
        pending = miner['count'] * minutes * self.miner_production
        hourly = miner['count'] * self.miner_production * 60
        
        text = f"⛏️ سیستم ماینر\n\n"
        text += f"تعداد ماینرها: {miner['count']}\n"
        text += f"تولید در ساعت: {hourly} الماس\n"
        text += f"الماس قابل جمع‌آوری: {pending}\n"
        text += f"💰 قیمت هر ماینر: {self.miner_price} الماس"
        
        await callback_query.message.edit_text(text, reply_markup=self.create_miners_keyboard())
    
    async def show_buy_miner(self, callback_query: CallbackQuery, state: FSMContext):
        user_id = callback_query.from_user.id
        if self.user_coins.get(user_id, 0) < self.miner_price:
            await callback_query.answer("❌ موجودی شما کافی نیست!", show_alert=True)
            return
        
        await callback_query.message.edit_text("⛏️ لطفاً تعداد ماینر مورد نظر برای خرید را وارد کنید:")
        await state.set_state(Form.BUY_MINER)
    
    async def buy_miner_callback(self, message: Message, state: FSMContext):
        user_id = message.from_user.id
        try:
            count = int(message.text)
            if count <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            total = count * self.miner_price
            if self.user_coins.get(user_id, 0) < total:
                await message.answer(f"❌ موجودی شما کافی نیست!\n💰 نیاز: {total} الماس\n💰 موجودی: {self.user_coins.get(user_id, 0)}")
                await state.clear()
                return
            
            self.user_coins[user_id] -= total
            
            if user_id not in self.user_miners:
                self.user_miners[user_id] = {'count': 0, 'last_collect': datetime.now()}
            
            self.user_miners[user_id]['count'] += count
            self.save_miner(user_id)
            
            await message.answer(f"✅ خرید با موفقیت انجام شد!\n⛏️ {count} ماینر به حساب شما اضافه شد.\n💰 موجودی جدید: {self.user_coins[user_id]} الماس")
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
        except Exception as e:
            await message.answer("❌ خطایی رخ داد. لطفاً دوباره تلاش کنید.")
        
        await state.clear()
    
    async def collect_miner(self, message: Message):
        user_id = message.from_user.id
        
        if user_id not in self.user_miners or self.user_miners[user_id]['count'] == 0:
            await message.answer("⛔ شما ماینری ندارید!")
            return
        
        miner = self.user_miners[user_id]
        now = datetime.now()
        minutes_passed = int((now - miner['last_collect']).total_seconds() / 60)
        
        if minutes_passed <= 0:
            await message.answer("⏳ هنوز الماسی برای جمع‌آوری ندارید!")
            return
        
        earned = minutes_passed * miner['count'] * self.miner_production
        
        if earned > 0:
            self.user_coins[user_id] = self.user_coins.get(user_id, 0) + earned
            miner['last_collect'] = now
            self.save_miner(user_id)
            
            text = f"✅ جمع‌آوری با موفقیت انجام شد\n\n"
            text += f"⛏️ تعداد ماینر: {miner['count']}\n"
            text += f"⏱️ مدت زمان: {minutes_passed} دقیقه\n"
            text += f"💎 الماس دریافتی: {earned}\n"
            text += f"💰 موجودی جدید: {self.user_coins[user_id]}"
            
            await message.answer(text)
    
    async def get_phone_number(self, message: Message, state: FSMContext):
        phone = message.text.strip()
        
        phone = ''.join(filter(str.isdigit, phone))
        if phone.startswith('0'):
            phone = '98' + phone[1:]
        if not phone.startswith('98'):
            phone = '98' + phone
        phone = '+' + phone
        
        if len(phone) < 12:
            await message.answer("❌ شماره تلفن معتبر نیست. لطفاً دوباره ارسال کنید:", reply_markup=self.create_phone_keyboard())
            return
        
        await message.answer("⏳ در حال ارسال کد تأیید...")
        
        try:
            client = TelegramClient(StringSession(), self.api_id, self.api_hash)
            await client.connect()
            result = await client.send_code_request(phone)
            
            self.user_sessions[message.from_user.id] = {
                'phone': phone,
                'hash': result.phone_code_hash,
                'client': client,
                'code': ''
            }
            
            await message.answer("🔓 کد تأیید 5 رقمی را وارد کنید:", reply_markup=self.create_code_keyboard())
            await state.set_state(Form.GET_CODE)
            
        except Exception as e:
            await message.answer(f"❌ خطا در ارسال کد. لطفاً دوباره تلاش کنید.", reply_markup=self.create_phone_keyboard())
    
    async def verify_code_callback(self, callback_query: CallbackQuery, state: FSMContext):
        await callback_query.answer()
        user_id = callback_query.from_user.id
        
        if user_id not in self.user_sessions:
            await callback_query.message.edit_text("❌ نشست شما منقضی شده است. دوباره شروع کنید.", reply_markup=self.create_welcome_keyboard())
            await state.clear()
            return
        
        session = self.user_sessions[user_id]
        data = callback_query.data
        
        if data == "حذف":
            session['code'] = ''
            await callback_query.message.edit_text("🗑️ کد پاک شد. کد جدید را وارد کنید:", reply_markup=self.create_code_keyboard())
        
        elif data == "ارسال":
            if len(session['code']) != 5:
                await callback_query.message.edit_text("❌ کد باید 5 رقم باشد!", reply_markup=self.create_code_keyboard(session['code']))
                return
            await self.check_code(callback_query, state, session['code'])
        
        elif data in "0123456789":
            if len(session['code']) < 5:
                session['code'] += data
                await callback_query.message.edit_text(f"🔢 کد وارد شده: {session['code']}", reply_markup=self.create_code_keyboard(session['code']))
    
    async def check_code(self, callback_query, state, code):
        user_id = callback_query.from_user.id
        session = self.user_sessions[user_id]
        
        await callback_query.message.edit_text("⏳ در حال ورود به حساب...")
        
        try:
            await session['client'].sign_in(phone=session['phone'], code=code, phone_code_hash=session['hash'])
            await self.login_success(callback_query, state, session['client'], user_id, session['phone'])
            
        except SessionPasswordNeededError:
            await callback_query.message.edit_text("🔐 رمز عبور دو مرحله‌ای را وارد کنید:")
            await state.set_state(Form.GET_2FA_PASSWORD)
            
        except Exception as e:
            await callback_query.message.edit_text("❌ کد وارد شده اشتباه است!", reply_markup=self.create_code_keyboard())
            session['code'] = ''
    
    async def get_2fa_password(self, message: Message, state: FSMContext):
        user_id = message.from_user.id
        
        if user_id not in self.user_sessions:
            await message.answer("❌ نشست شما منقضی شده است.")
            await state.clear()
            return
        
        session = self.user_sessions[user_id]
        password = message.text
        
        await message.answer("⏳ در حال بررسی رمز عبور...")
        
        try:
            await session['client'].sign_in(password=password)
            await self.login_success(message, state, session['client'], user_id, session['phone'])
        except Exception as e:
            await message.answer("❌ رمز عبور اشتباه است. لطفاً دوباره تلاش کنید:")
    
    async def login_success(self, msg, state, client, user_id, phone):
        session_str = client.session.save()
        success = await self.activate_selfbot(session_str, user_id, phone)
        
        if success and self.user_coins.get(user_id, 0) >= 3:
            self.user_coins[user_id] -= 3
        
        if success:
            text = "✅ سلف‌بات با موفقیت فعال شد!"
        else:
            text = "⚠️ خطا در اجرای سلف‌بات. اما اطلاعات شما ذخیره شد."
        
        if isinstance(msg, CallbackQuery):
            await msg.message.answer(text)
        else:
            await msg.answer(text)
        
        if user_id in self.user_sessions:
            await client.disconnect()
            del self.user_sessions[user_id]
        
        await state.clear()
    
    async def activate_selfbot(self, session_str: str, user_id: int, phone: str):
        try:
            os.makedirs("database/sessions", exist_ok=True)
            session_file = f"database/sessions/session_{user_id}.txt"
            with open(session_file, 'w', encoding='utf-8') as f:
                f.write(session_str)
            
            # مسیر فایل سلف بات
            selfbot_path = os.path.join(os.path.dirname(__file__), 'self.py')
            
            # لاگ برای دیباگ
            print(f"🔍 مسیر سلف بات: {selfbot_path}")
            print(f"🔍 فایل وجود دارد: {os.path.exists(selfbot_path)}")
            
            if os.path.exists(selfbot_path):
                try:
                    # اجرای سلف بات با آرگومان‌های صحیح
                    process = subprocess.Popen(
                        [sys.executable, selfbot_path, phone, session_file],
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE,
                        text=True
                    )
                    
                    self.active_selfbots[user_id] = {
                        'process': process,
                        'phone': phone,
                        'file': session_file,
                        'start_time': datetime.now()
                    }
                    
                    # لاگ موفقیت
                    print(f"✅ سلف‌بات برای کاربر {user_id} فعال شد")
                    
                    # ذخیره در دیتابیس
                    conn = sqlite3.connect('database/users.db')
                    cursor = conn.cursor()
                    cursor.execute('''INSERT OR REPLACE INTO users 
                                   (user_id, phone, coins, join_date, is_active, verified) 
                                   VALUES (?, ?, ?, datetime("now"), 1, 1)''',
                                 (user_id, phone, self.user_coins.get(user_id, 0)))
                    conn.commit()
                    conn.close()
                    
                    return True
                    
                except Exception as e:
                    print(f"❌ خطا در اجرای سلف‌بات: {e}")
                    return False
            else:
                print(f"❌ فایل self.py یافت نشد در مسیر: {selfbot_path}")
                return False
            
        except Exception as e:
            print(f"❌ خطا در فعال‌سازی سلف‌بات: {e}")
            return False
    
    async def coin_purchase_callback(self, callback_query: CallbackQuery, state: FSMContext):
        await callback_query.answer()
        user_id = callback_query.from_user.id
        data = callback_query.data
        
        if data == "الماس_حذف":
            await state.update_data(coin_amount='')
            await callback_query.message.edit_text("🗑️ پاک شد. تعداد جدید را وارد کنید:", reply_markup=self.create_coin_keyboard())
        
        elif data == "الماس_ارسال":
            state_data = await state.get_data()
            amount = state_data.get('coin_amount', '')
            
            if not amount or int(amount) <= 0:
                await callback_query.message.edit_text("❌ لطفاً یک عدد معتبر وارد کنید.", reply_markup=self.create_coin_keyboard(amount))
                return
            
            total = int(amount) * self.coin_price
            text = f"💎 درخواست خرید\n\n"
            text += f"تعداد الماس: {amount}\n"
            text += f"مبلغ قابل پرداخت: {total:,} تومان\n\n"
            text += f"💳 شماره کارت:\n`{self.card_number}`\n\n"
            text += f"👤 پس از واریز، به پشتیبانی @{self.support_username} اطلاع دهید."
            
            await callback_query.message.edit_text(text)
            await state.clear()
        
        elif data.startswith("الماس_"):
            digit = data.split("_")[1]
            if digit.isdigit():
                state_data = await state.get_data()
                current = state_data.get('coin_amount', '')
                new = current + digit
                await state.update_data(coin_amount=new)
                await callback_query.message.edit_text(f"💎 تعداد الماس: {new}", reply_markup=self.create_coin_keyboard(new))
    
    async def create_bet(self, message: Message):
        user_id = message.from_user.id
        
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `بازی [مقدار]`")
                return
            
            amount = int(parts[1])
            if amount <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            if self.user_coins.get(user_id, 0) < amount:
                await message.answer(f"❌ موجودی شما کافی نیست!\n💰 موجودی: {self.user_coins.get(user_id, 0)} الماس")
                return
            
            tax = math.ceil(amount * self.bet_tax_percent / 100)
            net = amount - tax
            
            bet_id = str(int(time.time())) + str(random.randint(1000, 9999))
            username = message.from_user.username or f"user_{user_id}"
            
            self.active_bets[bet_id] = {
                'creator': user_id,
                'username': username,
                'amount': amount,
                'net': net,
                'tax': tax,
                'players': [user_id],
                'start_time': datetime.now()
            }
            
            self.user_coins[user_id] -= amount
            
            text = f"◈ ━ TH 𝐒𝐞𝐥𝐟 ━ ◈\nTH | بازی :\nTH | مقدار الماس : {amount}\nTH | سازنده: @{username}\n◈ ━ TH 𝐒𝐞𝐥𝐟 ━ ◈"
            
            keyboard = self.create_bet_keyboard(bet_id)
            
            # دریافت عکس شرط
            photo = await self.get_photo_input()
            
            # ارسال با عکس اگر فعال است
            if photo and self.bet_photo_enabled:
                try:
                    await message.answer_photo(
                        photo=photo,
                        caption=text,
                        reply_markup=keyboard
                    )
                    return
                except Exception as e:
                    print(f"خطا در ارسال عکس: {e}")
            
            # ارسال بدون عکس
            await message.answer(text, reply_markup=keyboard)
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
        except Exception as e:
            print(f"خطا در create_bet: {e}")
            await message.answer("❌ خطایی رخ داد. لطفاً دوباره تلاش کنید.")
    
    async def show_balance(self, message: Message):
        user_id = message.from_user.id
        coins = self.user_coins.get(user_id, 0)
        total_value = coins * self.coin_price
        
        text = f"💎 موجودی شما: {coins} الماس\n💰 ارزش تقریبی: {total_value:,} تومان"
        
        await message.reply(text)
    
    async def transfer_coins(self, message: Message):
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر مورد نظر ریپلای کنید.")
            return
        
        try:
            text = message.text.strip()
            parts = text.split()
            
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `انتقال الماس [مقدار]`")
                return
            
            # اگر دستور به صورت "انتقال الماس" باشه، مقدار در index 2 هست
            # اگر به صورت "انتقال الماس" (بدون فاصله) باشه، مقدار در index 1 هست
            if parts[0] == "انتقال" and parts[1] == "الماس":
                if len(parts) < 3:
                    await message.answer("❌ فرمت صحیح: `انتقال الماس [مقدار]`")
                    return
                amount_str = parts[2]
            else:
                # حالت "انتقال الماس" (بدون فاصله)
                amount_str = parts[1]
            
            amount = int(amount_str)
            if amount <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            user_id = message.from_user.id
            if self.user_coins.get(user_id, 0) < amount:
                await message.answer("❌ موجودی شما کافی نیست.")
                return
            
            target = message.reply_to_message.from_user
            if target.id == user_id:
                await message.answer("❌ نمی‌توانید به خودتان الماس انتقال دهید.")
                return
            
            self.user_coins[user_id] -= amount
            self.user_coins[target.id] = self.user_coins.get(target.id, 0) + amount
            
            sender_username = message.from_user.username or f"user_{user_id}"
            target_username = target.username or f"user_{target.id}"
            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            receipt = f"✅ {amount} الماس به @{target_username} منتقل شد.\n🧾 رسید شما:\n📤 فرستنده: @{sender_username}\n📥 گیرنده: @{target_username}\n💎 مقدار: {amount}\n⏰ {current_time}"
            
            await message.answer(receipt)
            
            try:
                await self.bot.send_message(target.id, f"📥 شما {amount} الماس از {message.from_user.first_name} دریافت کردید!")
            except:
                pass
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
        except Exception as e:
            await message.answer("❌ خطایی رخ داد. لطفاً دوباره تلاش کنید.")
    
    async def show_miners(self, message: Message):
        user_id = message.from_user.id
        
        if user_id not in self.user_miners:
            self.user_miners[user_id] = {'count': 0, 'last_collect': datetime.now()}
        
        if self.user_miners[user_id]['count'] == 0:
            await message.answer("⛏️ شما هیچ ماینری ندارید.\nبرای خرید از دستور `خرید ماینر [تعداد]` استفاده کنید.")
            return
        
        miner = self.user_miners[user_id]
        minutes = int((datetime.now() - miner['last_collect']).total_seconds() / 60)
        pending = minutes * miner['count'] * self.miner_production
        hourly = miner['count'] * self.miner_production * 60
        daily = hourly * 24
        
        text = f"⛏️ ماینرهای شما\n\n"
        text += f"تعداد ماینر: {miner['count']}\n"
        text += f"تولید در ساعت: {hourly} الماس\n"
        text += f"تولید در روز: {daily} الماس\n"
        text += f"الماس قابل جمع‌آوری: {pending}\n\n"
        text += f"💰 برای جمع‌آوری از دستور `جمع آوری` استفاده کنید."
        
        await message.answer(text)
    
    async def buy_miner(self, message: Message):
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `خرید ماینر [تعداد]`")
                return
            
            count = int(parts[1])
            if count <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            user_id = message.from_user.id
            total = count * self.miner_price
            
            if self.user_coins.get(user_id, 0) < total:
                await message.answer(f"❌ موجودی شما کافی نیست!\n💰 نیاز: {total} الماس\n💰 موجودی: {self.user_coins.get(user_id, 0)}")
                return
            
            self.user_coins[user_id] -= total
            
            if user_id not in self.user_miners:
                self.user_miners[user_id] = {'count': 0, 'last_collect': datetime.now()}
            
            self.user_miners[user_id]['count'] += count
            self.save_miner(user_id)
            
            await message.answer(f"✅ خرید با موفقیت انجام شد!\n⛏️ {count} ماینر به حساب شما اضافه شد.\n💰 موجودی جدید: {self.user_coins[user_id]}")
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
    
    async def show_stats_panel(self, callback_query: CallbackQuery):
        user_id = callback_query.from_user.id
        coins = self.user_coins.get(user_id, 0)
        miners = self.user_miners.get(user_id, {}).get('count', 0)
        referrals = len(self.user_referrals.get(user_id, []))
        
        text = f"📊 آمار شما\n\n"
        text += f"💰 الماس: {coins}\n"
        text += f"⛏️ ماینر: {miners}\n"
        text += f"👥 دعوت‌ها: {referrals}"
        
        await callback_query.message.edit_text(text, reply_markup=self.create_stats_keyboard())
    
    async def show_invite_panel(self, callback_query: CallbackQuery):
        user_id = callback_query.from_user.id
        code = secrets.token_urlsafe(8)
        self.invite_links[code] = user_id
        
        bot_info = await self.bot.get_me()
        link = f"https://t.me/{bot_info.username}?start={code}"
        referrals = len(self.user_referrals.get(user_id, []))
        
        text = f"🎫 لینک دعوت شما\n\n"
        text += f"🔗 لینک:\n`{link}`\n\n"
        text += f"👥 تعداد دعوت‌ها: {referrals}\n"
        text += f"🎁 پاداش هر دعوت: 7 الماس\n\n"
        text += "با اشتراک‌گذاری این لینک، از دعوت دوستان خود الماس دریافت کنید!"
        
        await callback_query.message.edit_text(text, reply_markup=self.create_stats_keyboard())
    
    async def admin_panel(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ شما دسترسی به این بخش ندارید!")
            return
        
        text = f"👑 پنل مدیریت\n\n"
        text += f"💰 قیمت الماس: {self.coin_price:,} تومان\n"
        text += f"⛏️ قیمت ماینر: {self.miner_price} الماس\n"
        text += f"📸 وضعیت عکس شرط: {'✅ فعال' if self.bet_photo_enabled else '❌ غیرفعال'}"
        if self.bet_photo_url:
            text += f"\n🔗 لینک عکس: {self.bet_photo_url[:50]}..."
        
        await message.answer(text, reply_markup=self.create_admin_keyboard())
    
    async def admin_callback(self, callback_query: CallbackQuery, state: FSMContext):
        await callback_query.answer()
        if not self.is_owner(callback_query.from_user.id):
            await callback_query.answer("❌ دسترسی غیرمجاز!", show_alert=True)
            return
        
        action = callback_query.data.replace('admin_', '')
        
        if action == 'kasr':
            await callback_query.message.answer("💰 برای کسر الماس، روی پیام کاربر ریپلای کرده و بنویسید: `کسر [مقدار]`")
        elif action == 'add':
            await callback_query.message.answer("💎 برای افزایش الماس، روی پیام کاربر ریپلای کرده و بنویسید: `افزایش [مقدار]`")
        elif action == 'block':
            await callback_query.message.answer("⛔ برای مسدود کردن کاربر، روی پیام او ریپلای کرده و بنویسید: `مسدود`")
        elif action == 'unblock':
            await callback_query.message.answer("✅ برای آزاد کردن کاربر، روی پیام او ریپلای کرده و بنویسید: `آزاد`")
        elif action == 'admins':
            text = "👑 مدیریت ادمین‌ها\n\n"
            text += "• افزودن ادمین: روی پیام کاربر ریپلای کرده و بنویسید `ادمین جدید`\n"
            text += "• حذف ادمین: روی پیام کاربر ریپلای کرده و بنویسید `ادمین حذف`\n"
            text += "• لیست ادمین‌ها: بنویسید `ادمین ها`"
            await callback_query.message.answer(text)
        elif action == 'stats':
            users = len(self.user_coins)
            total_coins = sum(self.user_coins.values())
            total_miners = sum(m['count'] for m in self.user_miners.values() if 'count' in m)
            active_bets = len(self.active_bets)
            
            text = f"📊 آمار کلی\n\n"
            text += f"👥 کاربران: {users}\n"
            text += f"💰 کل الماس: {total_coins:,}\n"
            text += f"⛏️ کل ماینرها: {total_miners}\n"
            text += f"🎲 بازی‌های فعال: {active_bets}"
            
            await callback_query.message.answer(text)
        elif action == 'settings':
            text = f"⚙️ تنظیمات\n\n"
            text += f"💰 قیمت الماس: {self.coin_price:,} تومان\n"
            text += f"⛏️ قیمت ماینر: {self.miner_price} الماس\n"
            text += f"📸 عکس شرط: {'✅ فعال' if self.bet_photo_enabled else '❌ غیرفعال'}\n\n"
            text += "برای تغییر:\n"
            text += "• `قیمت [مقدار]` - تغییر قیمت الماس\n"
            text += "• `ماینر قیمت [مقدار]` - تغییر قیمت ماینر\n"
            text += "• `عکس شرط on/off` - روشن/خاموش کردن عکس شرط\n"
            text += "• `لینک عکس [لینک]` - تنظیم لینک عکس"
            
            await callback_query.message.answer(text)
        elif action == 'broadcast':
            await callback_query.message.answer("📢 برای ارسال پیام همگانی بنویسید: `همگانی [متن پیام]`")
        elif action == 'toggle_photo':
            self.bet_photo_enabled = not self.bet_photo_enabled
            status = "✅ روشن" if self.bet_photo_enabled else "❌ خاموش"
            await callback_query.message.edit_reply_markup(reply_markup=self.create_admin_keyboard())
            await callback_query.answer(f"📸 وضعیت عکس شرط: {status}", show_alert=True)
        elif action == 'upload_photo':
            await callback_query.message.answer("🖼️ لطفاً عکس جدید شرط را ارسال کنید:\nیا می‌توانید از دستور `لینک عکس [لینک]` استفاده کنید")
            await state.set_state(Form.UPLOAD_BET_PHOTO)
    
    async def kasr_coins_command(self, message: Message):
        if not (self.is_owner(message.from_user.id) or self.is_admin(message.from_user.id)):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `کسر [مقدار]`")
                return
            
            amount = int(parts[1])
            if amount <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            target = message.reply_to_message.from_user
            current = self.user_coins.get(target.id, 0)
            
            if current < amount:
                deducted = current
                self.user_coins[target.id] = 0
            else:
                deducted = amount
                self.user_coins[target.id] -= amount
            
            admin_username = message.from_user.username or f"user_{message.from_user.id}"
            target_username = target.username or f"user_{target.id}"
            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            receipt = f"✅ {deducted} الماس از @{target_username} کسر شد.\n🧾 رسید:\n🔻 مقدار کسر: {deducted}\n👤 کاربر: @{target_username}\n🆔 {target.id}\n💰 موجودی جدید: {self.user_coins[target.id]}\n👮‍♂️ توسط: @{admin_username}\n⏰ {current_time}"
            
            await message.answer(receipt)
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
    
    async def add_coins_command(self, message: Message):
        if not (self.is_owner(message.from_user.id) or self.is_admin(message.from_user.id)):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `افزایش [مقدار]`")
                return
            
            amount = int(parts[1])
            if amount <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            target = message.reply_to_message.from_user
            self.user_coins[target.id] = self.user_coins.get(target.id, 0) + amount
            
            admin_username = message.from_user.username or f"user_{message.from_user.id}"
            target_username = target.username or f"user_{target.id}"
            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            receipt = f"✅ {amount} الماس به @{target_username} اضافه شد.\n🧾 رسید:\n🔺 مقدار افزایش: {amount}\n👤 کاربر: @{target_username}\n🆔 {target.id}\n💰 موجودی جدید: {self.user_coins[target.id]}\n👮‍♂️ توسط: @{admin_username}\n⏰ {current_time}"
            
            await message.answer(receipt)
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
    
    async def set_coin_price(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `قیمت [مقدار]`")
                return
            
            price = int(parts[1])
            if price <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            self.coin_price = price
            await message.answer(f"✅ قیمت الماس به {price:,} تومان تغییر یافت.")
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
    
    async def broadcast_message(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        parts = message.text.split(maxsplit=1)
        if len(parts) < 2:
            await message.answer("❌ فرمت صحیح: `همگانی [متن]`")
            return
        
        text = parts[1]
        
        await message.answer(f"📤 در حال ارسال پیام به {len(self.user_coins)} کاربر...")
        
        success = 0
        failed = 0
        
        for uid in self.user_coins:
            if uid == self.owner_id:
                continue
            try:
                await self.bot.send_message(uid, f"📢 پیام همگانی\n\n{text}")
                success += 1
                await asyncio.sleep(0.05)
            except:
                failed += 1
        
        await message.answer(f"✅ ارسال شد!\n📨 موفق: {success}\n❌ ناموفق: {failed}")
    
    async def gift_all_users(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `هدیه [مقدار]`")
                return
            
            amount = int(parts[1])
            if amount <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            count = 0
            for uid in self.user_coins:
                if uid != self.owner_id:
                    self.user_coins[uid] = self.user_coins.get(uid, 0) + amount
                    count += 1
            
            await message.answer(f"✅ هدیه {amount} الماس به {count} کاربر ارسال شد.")
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
    
    async def block_user(self, message: Message):
        if not (self.is_owner(message.from_user.id) or self.is_admin(message.from_user.id)):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        target = message.reply_to_message.from_user
        self.blocked_users[target.id] = True
        
        await message.answer(f"⛔ کاربر {target.first_name} مسدود شد.")
        
        try:
            await self.bot.send_message(target.id, "⛔ شما توسط مدیریت مسدود شده‌اید!")
        except:
            pass
    
    async def unblock_user(self, message: Message):
        if not (self.is_owner(message.from_user.id) or self.is_admin(message.from_user.id)):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        target = message.reply_to_message.from_user
        if target.id in self.blocked_users:
            del self.blocked_users[target.id]
        
        await message.answer(f"✅ کاربر {target.first_name} آزاد شد.")
        
        try:
            await self.bot.send_message(target.id, "✅ مسدودیت شما توسط مدیریت برداشته شد.")
        except:
            pass
    
    async def add_admin(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        target = message.reply_to_message.from_user
        if target.id in self.admin_list:
            await message.answer("❌ این کاربر قبلاً ادمین است.")
            return
        
        self.admin_list.append(target.id)
        
        conn = sqlite3.connect('database/admins.db')
        cursor = conn.cursor()
        cursor.execute('''INSERT OR REPLACE INTO admins 
                       (user_id, username, added_by, added_date, permissions) 
                       VALUES (?, ?, ?, datetime("now"), ?)''',
                      (target.id, target.username or "", message.from_user.id, "limited"))
        conn.commit()
        conn.close()
        
        await message.answer(f"✅ {target.first_name} به جمع ادمین‌ها اضافه شد.")
        
        try:
            await self.bot.send_message(target.id, "👑 شما به عنوان ادمین ربات منصوب شدید!")
        except:
            pass
    
    async def remove_admin(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        target = message.reply_to_message.from_user
        if target.id == self.owner_id:
            await message.answer("❌ نمی‌توانید مالک را حذف کنید!")
            return
        
        if target.id not in self.admin_list:
            await message.answer("❌ این کاربر ادمین نیست.")
            return
        
        self.admin_list.remove(target.id)
        
        conn = sqlite3.connect('database/admins.db')
        cursor = conn.cursor()
        cursor.execute('DELETE FROM admins WHERE user_id = ?', (target.id,))
        conn.commit()
        conn.close()
        
        await message.answer(f"✅ {target.first_name} از ادمین‌ها حذف شد.")
        
        try:
            await self.bot.send_message(target.id, "❌ دسترسی ادمین شما لغو شد.")
        except:
            pass
    
    async def list_admins(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        conn = sqlite3.connect('database/admins.db')
        cursor = conn.cursor()
        cursor.execute('SELECT user_id, username, added_date FROM admins ORDER BY added_date')
        admins = cursor.fetchall()
        conn.close()
        
        if not admins:
            await message.answer("📭 هیچ ادمینی وجود ندارد.")
            return
        
        text = "👑 لیست ادمین‌ها\n\n"
        for uid, username, date in admins:
            role = "👑 مالک" if uid == self.owner_id else "👤 ادمین"
            username_display = f"@{username}" if username else f"کاربر {uid}"
            text += f"{role}: {username_display}\n"
            if uid != self.owner_id:
                text += f"🆔: {uid}\n"
                text += f"📅: {date}\n\n"
        
        await message.answer(text)
    
    async def user_info(self, message: Message):
        if not (self.is_owner(message.from_user.id) or self.is_admin(message.from_user.id)):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        target_id = None
        target_name = ""
        
        if message.reply_to_message:
            target = message.reply_to_message.from_user
            target_id = target.id
            target_name = target.first_name
        elif len(message.text.split()) > 1:
            try:
                target_id = int(message.text.split()[1])
                target = await self.bot.get_chat(target_id)
                target_name = target.first_name
            except:
                await message.answer("❌ کاربر یافت نشد.")
                return
        else:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید یا آیدی ارسال کنید.")
            return
        
        coins = self.user_coins.get(target_id, 0)
        miners = self.user_miners.get(target_id, {}).get('count', 0)
        referrals = len(self.user_referrals.get(target_id, []))
        blocked = "⛔ بله" if target_id in self.blocked_users else "✅ خیر"
        admin = "👑 بله" if target_id in self.admin_list else "❌ خیر"
        
        text = f"👤 اطلاعات کاربر\n\n"
        text += f"نام: {target_name}\n"
        text += f"🆔: {target_id}\n"
        text += f"💰 الماس: {coins}\n"
        text += f"⛏️ ماینر: {miners}\n"
        text += f"👥 دعوت‌ها: {referrals}\n"
        text += f"🔒 مسدود: {blocked}\n"
        text += f"👑 ادمین: {admin}"
        
        await message.answer(text)
    
    async def set_miner_price(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        try:
            parts = message.text.split()
            if len(parts) < 2:
                await message.answer("❌ فرمت صحیح: `ماینر قیمت [مقدار]`")
                return
            
            price = int(parts[1])
            if price <= 0:
                await message.answer("❌ لطفاً یک عدد مثبت وارد کنید.")
                return
            
            self.miner_price = price
            await message.answer(f"✅ قیمت ماینر به {price} الماس تغییر یافت.")
            
        except ValueError:
            await message.answer("❌ لطفاً یک عدد معتبر وارد کنید.")
    
    async def reset_user_miners(self, message: Message):
        if not self.is_owner(message.from_user.id):
            await message.answer("❌ دسترسی غیرمجاز!")
            return
        
        if not message.reply_to_message:
            await message.answer("❌ لطفاً روی پیام کاربر ریپلای کنید.")
            return
        
        target = message.reply_to_message.from_user
        
        if target.id in self.user_miners:
            del self.user_miners[target.id]
            
            conn = sqlite3.connect('database/miners.db')
            cursor = conn.cursor()
            cursor.execute('DELETE FROM miners WHERE user_id = ?', (target.id,))
            conn.commit()
            conn.close()
        
        await message.answer(f"✅ ماینرهای {target.first_name} با موفقیت ریست شد.")
    
    async def run(self):
        print("=" * 50)
        print("🤖 TH SELF Bot - نسخه نهایی")
        print("=" * 50)
        print(f"👑 مالک: {self.owner_id}")
        print(f"📢 کانال: @{self.channel_username}")
        print(f"💰 قیمت الماس: {self.coin_price:,} تومان")
        print(f"⛏️ قیمت ماینر: {self.miner_price} الماس")
        print(f"📸 عکس شرط: {'✅ فعال' if self.bet_photo_enabled else '❌ غیرفعال'}")
        if self.bet_photo_url:
            print(f"🔗 لینک عکس: {self.bet_photo_url[:50]}...")
        print(f"📊 تعداد کاربران: {len(self.user_coins)}")
        print(f"📁 دیتابیس: database/")
        print("=" * 50)
        print("⚠️ هشدار: استفاده از سلف‌بات با مسئولیت خود کاربر")
        print("=" * 50)
        print("✅ ربات در حال اجراست...")
        
        await self.bot.delete_webhook(drop_pending_updates=True)
        await self.dp.start_polling(self.bot)

if __name__ == "__main__":
    BOT_TOKEN = "8440841767:AAGHOgskFPLIWF_J1O4O-DE8IhFZHBOpEVw"
    API_ID = 23960325
    API_HASH = "e3ddc02e05b4227241d459dffc7324f9"
    
    bot = TelegramAuthBot(BOT_TOKEN, API_ID, API_HASH)
    asyncio.run(bot.run())