import os
import asyncio
import smtplib
import json
import logging
import random
import time
from email.mime.text import MIMEText
from datetime import datetime, timedelta
import pytz
from telethon import TelegramClient, events, Button, errors
from telethon.sessions import StringSession
from telethon.tl.functions.account import ReportPeerRequest
from telethon.tl.functions.channels import JoinChannelRequest
from telethon.tl.types import (
    InputReportReasonSpam,
    InputReportReasonViolence,
    InputReportReasonPornography,
    InputReportReasonFake,
    InputReportReasonChildAbuse,
    InputReportReasonCopyright,
    InputReportReasonPersonalDetails,
    InputReportReasonOther
)

# ==================== تنظیمات اولیه ====================
API_ID = 36773072
API_HASH = "83bcbcdc8eeb48202b28a3b442c6b5da"
BOT_TOKEN = "8237459517:AAHqu42neC_GssUKn2CUrn9pcXZb-oLZLjM"
OWNER_IDS = [8908470739, 8568930999]

MAX_CONCURRENT = 20
DATA_FILE = "data_BACKUP.json"
ADMIN_SESSIONS_DIR = "admin_sessions"
SHARED_SESSIONS_DIR = os.path.join(ADMIN_SESSIONS_DIR, "shared")
os.makedirs(SHARED_SESSIONS_DIR, exist_ok=True)

# ==================== تنظیمات لاگ ====================
logging.basicConfig(
    filename='bot.log',
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    encoding='utf-8'
)
logger = logging.getLogger(__name__)

# ==================== تنظیمات ریپورت ====================
REPORT_REASONS = {
    '1': ('🚫 Spam', InputReportReasonSpam(), 'This content is spam'),
    '2': ('❌ Fake', InputReportReasonFake(), 'This content is fake'),
    '3': ('🔪 Violence', InputReportReasonViolence(), 'This content contains violence'),
    '4': ('🔞 Pornography', InputReportReasonPornography(), 'This content contains pornography'),
    '5': ('👶 Child Abuse', InputReportReasonChildAbuse(), 'This content involves child abuse'),
    '6': ('©️ Copyright', InputReportReasonCopyright(), 'This content violates copyright'),
    '7': ('📋 Personal Details', InputReportReasonPersonalDetails(), 'This content exposes personal details'),
    '8': ('📝 Other', InputReportReasonOther(), 'Reported by bot - other reason'),
    '9': ('💸 Scam', InputReportReasonOther(), 'This channel/post/user is a scam')
}

# ==================== دیتای پیش‌فرض ====================
DEFAULT_DATA = {
    "admins": {},
    "users": [],
    "blocked": [],
    "force_channels": [],
    "admin_data": {},
    "global_smtp_status": "on",
    "send_today": 0,
    "send_week": 0,
    "today_date": "",
    "week_number": "",
    "bot_status": "on",
    "user_lang": {},
    "user_proxies": {},
    "shared_smtp": []
}

# ==================== توابع مدیریت دیتا ====================
def load_data():
    """بارگذاری دیتا از فایل JSON"""
    if not os.path.exists(DATA_FILE):
        data = DEFAULT_DATA.copy()
        save_data(data)
        return data
    
    try:
        with open(DATA_FILE, "r", encoding="utf-8") as f:
            data = json.load(f)
    except (json.JSONDecodeError, FileNotFoundError):
        data = DEFAULT_DATA.copy()
        save_data(data)
        return data
    
    # اطمینان از وجود کلیدهای مورد نیاز
    for key, value in DEFAULT_DATA.items():
        if key not in data:
            if isinstance(value, list):
                data[key] = []
            elif isinstance(value, dict):
                data[key] = {}
            else:
                data[key] = value
    
    # تبدیل تاریخ‌ها به آبجکت datetime
    if "admins" in data:
        for uid_str in list(data["admins"].keys()):
            info = data["admins"][uid_str]
            if isinstance(info.get("expires"), str):
                try:
                    info["expires"] = datetime.fromisoformat(info["expires"])
                except:
                    info["expires"] = datetime.now(pytz.timezone('Asia/Tehran'))
            if isinstance(info.get("activated"), str):
                try:
                    info["activated"] = datetime.fromisoformat(info["activated"])
                except:
                    info["activated"] = datetime.now(pytz.timezone('Asia/Tehran'))
    
    return data

def save_data(data):
    """ذخیره دیتا در فایل JSON"""
    data_to_save = data.copy()
    
    # تبدیل تاریخ‌ها به رشته
    if "admins" in data_to_save:
        admins_copy = {}
        for uid_str, info in data_to_save["admins"].items():
            info_copy = info.copy()
            if isinstance(info_copy.get("expires"), datetime):
                info_copy["expires"] = info_copy["expires"].isoformat()
            if isinstance(info_copy.get("activated"), datetime):
                info_copy["activated"] = info_copy["activated"].isoformat()
            admins_copy[uid_str] = info_copy
        data_to_save["admins"] = admins_copy
    
    try:
        with open(DATA_FILE, "w", encoding="utf-8") as f:
            json.dump(data_to_save, f, ensure_ascii=False, indent=4)
    except Exception as e:
        logger.error(f"Error saving data: {e}")

# ==================== توابع مدیریت کاربران ====================
def get_user_lang(user_id):
    data = load_data()
    return data.get("user_lang", {}).get(str(user_id), "fa")

def set_user_lang(user_id, lang):
    data = load_data()
    if "user_lang" not in data:
        data["user_lang"] = {}
    data["user_lang"][str(user_id)] = lang
    save_data(data)

def is_blocked(user_id):
    data = load_data()
    return str(user_id) in [str(x) for x in data.get("blocked", [])]

def get_admin_data(user_id):
    data = load_data()
    admin_data = data.get("admin_data", {})
    uid = str(user_id)
    if uid not in admin_data:
        admin_data[uid] = {"smtp": [], "active_senders": [], "recipients": []}
        save_data(data)
    return admin_data[uid]

def get_shared_smtp():
    data = load_data()
    return data.get("shared_smtp", [])

def save_shared_smtp(smtp_list):
    data = load_data()
    data["shared_smtp"] = smtp_list
    save_data(data)

def is_owner(user_id):
    return user_id in OWNER_IDS

def is_admin(user_id):
    data = load_data()
    admins = data.get("admins", {})
    if str(user_id) not in admins:
        return False
    try:
        tehran = pytz.timezone('Asia/Tehran')
        now = datetime.now(tehran)
        expires = admins[str(user_id)]["expires"]
        if isinstance(expires, str):
            expires = datetime.fromisoformat(expires)
        return expires > now
    except:
        return False

def get_admin_sessions_dir(admin_id):
    """دریافت پوشه سشن‌ها - همیشه اشتراکی"""
    return SHARED_SESSIONS_DIR

def get_user_sessions(user_id, force_refresh=False):
    """دریافت لیست سشن‌های کاربر"""
    cache_attr = f"session_cache_{user_id}"
    if not hasattr(get_user_sessions, cache_attr) or force_refresh:
        sessions = []
        if os.path.exists(SHARED_SESSIONS_DIR):
            for f in os.listdir(SHARED_SESSIONS_DIR):
                if f.endswith('.session'):
                    sessions.append(("shared", f))
        setattr(get_user_sessions, cache_attr, sessions)
    return getattr(get_user_sessions, cache_attr)

def clear_user_cache(user_id=None):
    """پاک کردن کش سشن‌ها"""
    if user_id:
        cache_attr = f"session_cache_{user_id}"
        if hasattr(get_user_sessions, cache_attr):
            delattr(get_user_sessions, cache_attr)
    else:
        for attr in list(get_user_sessions.__dict__.keys()):
            if attr.startswith("session_cache_"):
                delattr(get_user_sessions, attr)

# ==================== وضعیت کاربران ====================
USER_STATE = {}

# ==================== کلاس مدیریت پروکسی ====================
class ProxyManager:
    def __init__(self, user_id):
        self.user_id = user_id
        self.proxies = []
        self.account_proxies = {}
        self.failures = {}
        self.lock = asyncio.Lock()
        self._load_user_proxies()

    def _load_user_proxies(self):
        """بارگذاری پروکسی‌ها از دیتابیس"""
        data = load_data()
        user_proxies = data.get("user_proxies", {}).get(str(self.user_id), [])
        self.proxies = []
        for p in user_proxies:
            proxy_str = p.strip()
            if not proxy_str:
                continue
            if proxy_str.startswith("socks5://"):
                proxy_str = proxy_str[8:]
            if ":" in proxy_str:
                try:
                    ip, port = proxy_str.split(":")
                    self.proxies.append({
                        'proxy_type': 'socks5',
                        'addr': ip,
                        'port': int(port),
                        'rdns': True
                    })
                except:
                    continue

    def _save_user_proxies(self):
        """ذخیره پروکسی‌ها در دیتابیس"""
        data = load_data()
        if "user_proxies" not in data:
            data["user_proxies"] = {}
        simple_list = []
        for p in self.proxies:
            simple_list.append(f"{p['addr']}:{p['port']}")
        data["user_proxies"][str(self.user_id)] = simple_list
        save_data(data)

    def get_proxies_for_account(self, account_id):
        """دریافت ۳ پروکسی برای یک اکانت"""
        if account_id not in self.account_proxies:
            if len(self.proxies) < 3:
                return []
            start = random.randint(0, len(self.proxies) - 1)
            proxies = []
            for i in range(3):
                idx = (start + i) % len(self.proxies)
                proxies.append(self.proxies[idx].copy())
            self.account_proxies[account_id] = proxies
            for p in proxies:
                self.failures[id(p)] = 0
        return self.account_proxies[account_id]

    async def get_valid_proxy(self, account_id):
        """دریافت یک پروکسی معتبر"""
        proxies = self.get_proxies_for_account(account_id)
        if not proxies:
            return None
        for _ in range(len(proxies)):
            proxy = proxies.pop(0)
            if self.failures.get(id(proxy), 0) < 3:
                proxies.append(proxy)
                return proxy
            new_proxy = await self.replace_proxy(account_id, proxy)
            if new_proxy:
                proxies.append(new_proxy)
                return new_proxy
        return proxies[0] if proxies else None

    async def replace_proxy(self, account_id, old_proxy):
        """جایگزینی پروکسی خراب"""
        used_proxies = []
        for acc_proxies in self.account_proxies.values():
            used_proxies.extend([id(p) for p in acc_proxies])
        for p in self.proxies:
            if id(p) not in used_proxies:
                new_proxy = p.copy()
                proxies = self.account_proxies[account_id]
                for i, pp in enumerate(proxies):
                    if id(pp) == id(old_proxy):
                        proxies[i] = new_proxy
                        break
                self.failures[id(new_proxy)] = 0
                self.failures.pop(id(old_proxy), None)
                self._save_user_proxies()
                return new_proxy
        return None

    async def mark_failed(self, account_id, proxy):
        """علامت‌گذاری پروکسی به عنوان خراب"""
        if proxy is None:
            return
        pid = id(proxy)
        self.failures[pid] = self.failures.get(pid, 0) + 1
        if self.failures[pid] >= 3:
            for p in self.proxies:
                if id(p) == pid:
                    self.proxies.remove(p)
                    break
            await self.replace_proxy(account_id, proxy)
            self._save_user_proxies()

    async def add_proxies(self, proxy_text):
        """افزودن پروکسی‌های جدید"""
        added = 0
        for line in proxy_text.strip().split('\n'):
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            if line.startswith("socks5://"):
                line = line[8:]
            if ":" in line:
                try:
                    ip, port = line.split(":")
                    exists = False
                    for p in self.proxies:
                        if p['addr'] == ip and p['port'] == int(port):
                            exists = True
                            break
                    if not exists:
                        self.proxies.append({
                            'proxy_type': 'socks5',
                            'addr': ip,
                            'port': int(port),
                            'rdns': True
                        })
                        added += 1
                except:
                    continue
        if added > 0:
            self._save_user_proxies()
            self.account_proxies = {}
            self.failures = {}
        return added

    def get_proxy_count(self):
        return len(self.proxies)

    def get_proxy_list(self):
        return [f"{p['addr']}:{p['port']}" for p in self.proxies]

# ==================== توابع کمکی ====================
async def test_smtp_connection(email, app_password):
    """تست اتصال SMTP"""
    try:
        server = smtplib.SMTP("smtp.gmail.com", 587, timeout=15)
        server.ehlo()
        server.starttls()
        server.login(email, app_password)
        server.quit()
        return True
    except:
        return False

def send_email_sync(sender_email, password, to_email, subject, body):
    """ارسال ایمیل به صورت همگام"""
    try:
        msg = MIMEText(body, "plain", "utf-8")
        msg["From"] = sender_email
        msg["To"] = to_email
        msg["Subject"] = subject
        server = smtplib.SMTP("smtp.gmail.com", 587)
        server.starttls()
        server.login(sender_email, password)
        server.sendmail(sender_email, to_email, msg.as_string())
        server.quit()
        return True, None
    except Exception as e:
        return False, str(e)

async def check_session_status(session_tuple):
    """بررسی وضعیت سشن"""
    admin_id_str, filename = session_tuple
    path = os.path.join(SHARED_SESSIONS_DIR, filename)
    try:
        with open(path, 'r') as f:
            session_str = f.read().strip()
        if not session_str:
            return "❌ Empty"
        client = TelegramClient(StringSession(session_str), API_ID, API_HASH)
        await client.connect()
        if not await client.is_user_authorized():
            await client.disconnect()
            return "❌ Not authorized"
        me = await client.get_me()
        await client.disconnect()
        return f"✅ Active (ID: {me.id})"
    except FileNotFoundError:
        return "❌ File not found"
    except Exception as e:
        return f"⚠️ {str(e)[:30]}"

async def join_channel_with_approval(client, entity, session_file):
    """عضویت در کانال"""
    try:
        await client(JoinChannelRequest(entity))
        return {'success': True, 'message': "✅ Joined"}
    except errors.UserAlreadyParticipantError:
        return {'success': True, 'message': "✅ Already joined"}
    except errors.InviteRequestSentError:
        return {'success': True, 'message': "✅ Join request sent"}
    except errors.FloodWaitError as e:
        return {'success': False, 'message': f"❌ Flood wait: {e.seconds}s"}
    except errors.ChannelPrivateError:
        return {'success': False, 'message': "❌ Channel is private"}
    except errors.ChannelInvalidError:
        return {'success': False, 'message': "❌ Invalid channel"}
    except Exception as e:
        return {'success': False, 'message': f"❌ Error: {str(e)[:30]}"}

async def validate_phone_number(phone):
    """اعتبارسنجی شماره تلفن"""
    if not phone.startswith('+'):
        return False
    clean = phone.replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
    if len(clean) < 8 or len(clean) > 15:
        return False
    if not clean[1:].isdigit():
        return False
    return True

async def validate_post_link(link):
    """اعتبارسنجی لینک پست"""
    if not (link.startswith('https://t.me/') or link.startswith('t.me/')):
        return False
    clean = link.replace('https://t.me/', '').replace('t.me/', '')
    parts = clean.split('/')
    if len(parts) < 2:
        return False
    try:
        post_id = int(parts[-1])
        if post_id <= 0:
            return False
    except:
        return False
    return True

# ==================== کیبوردها ====================
# ==================== کیبوردها با دکمه‌های رنگی ====================

def main_menu_keyboard(user_id):
    lang = get_user_lang(user_id)
    if not (is_owner(user_id) or is_admin(user_id)):
        return None
    kb = [
        [
            Button.inline("📧 ایمیل ریپورتر" if lang == "fa" else "📧 Email Reporter", "menu_email", style="primary"),
            Button.inline("🚫 تلگرام ریپورتر" if lang == "fa" else "🚫 Telegram Reporter", "menu_telegram", style="primary")
        ],
        [
            Button.inline("🌐 تغییر زبان" if lang == "fa" else "🌐 Change Language", "change_lang", style="success"),
            Button.url("📞 پشتیبانی / Support", "https://t.me/OriginalKhodeWinner")
        ]
    ]
    if is_owner(user_id):
        kb.append([Button.inline("👑 پنل مالک" if lang == "fa" else "👑 Owner Panel", "owner_panel", style="danger")])
        kb.append([Button.inline("➕ افزودن ادمین" if lang == "fa" else "➕ Add Admin", "add_admin", style="success")])
    return kb

def email_menu_keyboard(user_id):
    lang = get_user_lang(user_id)
    kb = []
    if is_owner(user_id):
        kb.append([
            Button.inline("➕ افزودن SMTP" if lang == "fa" else "➕ ADD SMTP", "em_smtp_add", style="primary"),
            Button.inline("📋 لیست SMTP" if lang == "fa" else "📋 SMTP LIST", "em_smtp_list", style="primary")
        ])
        kb.append([
            Button.inline("🟢 فعال‌سازی ارسال‌کننده" if lang == "fa" else "🟢 ACTIVATE SENDER", "em_activate", style="success"),
            Button.inline("📧 ارسال تکی" if lang == "fa" else "📧 SEND SINGLE", "em_single_send", style="primary")
        ])
    else:
        kb.append([
            Button.inline("📧 ارسال تکی" if lang == "fa" else "📧 SEND SINGLE", "em_single_send", style="primary"),
            Button.inline("📨 ارسال گروهی" if lang == "fa" else "📨 BULK SEND", "em_bulk_send", style="success")
        ])
    kb.append([
        Button.inline("👥 لیست گیرنده‌ها" if lang == "fa" else "👥 RECIPIENTS LIST", "em_recips", style="primary"),
        Button.inline("➕ افزودن گیرنده" if lang == "fa" else "➕ ADD RECIPIENT", "em_add_recip", style="primary")
    ])
    kb.append([
        Button.inline("🗑 پاک‌کردن گیرنده‌ها" if lang == "fa" else "🗑 CLEAR RECIPIENTS", "em_clear_recip", style="danger"),
        Button.inline("📊 آمار زنده" if lang == "fa" else "📊 LIVE STATS", "em_stats", style="primary")
    ])
    kb.append([
        Button.inline("دریافت نمایندگی" if lang == "fa" else "AGENCY", "em_agency", style="success")
    ])
    kb.append([Button.inline("🔙 بازگشت به منوی اصلی" if lang == "fa" else "🔙 BACK TO MAIN MENU", "back_main", style="primary")])
    return kb

def telegram_menu_keyboard(user_id):
    lang = get_user_lang(user_id)
    is_own = is_owner(user_id)
    kb = []
    kb.append([
        Button.inline("🚫 ریپورت کانال/گروه" if lang == "fa" else "🚫 REPORT CHANNEL/GROUP", "tg_report", style="danger"),
        Button.inline("📝 ریپورت پست" if lang == "fa" else "📝 REPORT POST", "tg_report_post", style="danger")
    ])
    kb.append([
        Button.inline("👤 ریپورت پروفایل" if lang == "fa" else "👤 REPORT PROFILE", "tg_report_profile", style="danger"),
        Button.inline("🤖 ریپورت ربات" if lang == "fa" else "🤖 REPORT BOT", "tg_report_bot", style="danger")
    ])
    kb.append([
        Button.inline("👤 ریپورت اکانت" if lang == "fa" else "👤 REPORT ACCOUNT", "tg_report_account", style="danger"),
        Button.inline("📋 ریپورت دستی" if lang == "fa" else "📋 MANUAL REPORT", "tg_manual_report", style="primary")
    ])
    if is_own:
        kb.append([
            Button.inline("⚙️ مدیریت اکانت‌ها" if lang == "fa" else "⚙️ MANAGE ACCOUNTS", "tg_manage_acc", style="primary"),
            Button.inline("🔙 بازگشت به منوی اصلی" if lang == "fa" else "🔙 BACK TO MAIN MENU", "back_main", style="primary")
        ])
    else:
        kb.append([
            Button.inline("➕ افزودن اکانت" if lang == "fa" else "➕ ADD ACCOUNT", "tg_add_acc", style="success"),
            Button.inline("🔙 بازگشت به منوی اصلی" if lang == "fa" else "🔙 BACK TO MAIN MENU", "back_main", style="primary")
        ])
    return kb

def manage_accounts_keyboard(user_id):
    lang = get_user_lang(user_id)
    return [
        [
            Button.inline("➕ افزودن اکانت" if lang=="fa" else "➕ ADD ACCOUNT", "tg_add_acc", style="success"),
            Button.inline("🗑 حذف اکانت" if lang=="fa" else "🗑 DELETE ACCOUNT", "tg_del_acc", style="danger")
        ],
        [
            Button.inline("📋 لیست اکانت‌ها" if lang=="fa" else "📋 LIST ACCOUNTS", "tg_list_all", style="primary"),
            Button.inline("📋 لیست اشتراکی" if lang=="fa" else "📋 LIST SHARED", "tg_list_shared", style="primary")
        ],
        [Button.inline("🔙 بازگشت" if lang=="fa" else "🔙 BACK", "tg_back", style="primary")]
    ]

def owner_panel_keyboard(user_id):
    lang = get_user_lang(user_id)
    return [
        [
            Button.inline("📢 پیام همگانی" if lang == "fa" else "📢 Broadcast", "em_broadcast", style="primary"),
            Button.inline("👤 پیام به کاربر" if lang == "fa" else "👤 Message User", "em_msg_user", style="primary")
        ],
        [
            Button.inline("🚫 بلاک کاربر" if lang == "fa" else "🚫 Block User", "em_block", style="danger"),
            Button.inline("✅ آنبلاک کاربر" if lang == "fa" else "✅ Unblock User", "em_unblock", style="success")
        ],
        [
            Button.inline("📢 مدیریت کانال اجباری" if lang == "fa" else "📢 Manage Force Channel", "em_force_channel", style="primary")
        ],
        [Button.inline("🔙 بازگشت به منوی اصلی" if lang == "fa" else "🔙 Back to Main Menu", "back_main", style="primary")]
    ]

def reason_keyboard():
    buttons = []
    row = []
    for i in range(1, 10):
        reason_name = REPORT_REASONS[str(i)][0]
        row.append(Button.inline(reason_name, f"tg_reason_{i}", style="primary"))
        if len(row) == 2:
            buttons.append(row)
            row = []
    if row:
        buttons.append(row)
    # ===== گزینه چرخشی =====
    buttons.append([Button.inline("🔄 ریپورت چرخشی", "tg_reason_rotation", style="success")])
    buttons.append([Button.inline("🔙 بازگشت", "tg_back", style="primary")])
    return buttons

def admin_duration_keyboard(lang):
    return [
        [
            Button.inline("1 ساعت" if lang=="fa" else "1 hour", "adm_1h", style="primary"),
            Button.inline("1 روز" if lang=="fa" else "1 day", "adm_1d", style="primary")
        ],
        [
            Button.inline("1 هفته" if lang=="fa" else "1 week", "adm_1w", style="primary"),
            Button.inline("1 ماه" if lang=="fa" else "1 month", "adm_1m", style="primary")
        ],
        [
            Button.inline("3 ماه" if lang=="fa" else "3 months", "adm_3m", style="primary"),
            Button.inline("6 ماه" if lang=="fa" else "6 months", "adm_6m", style="primary")
        ],
        [
            Button.inline("1 سال" if lang=="fa" else "1 year", "adm_1y", style="success"),
            Button.inline("🔙 برگشت" if lang=="fa" else "🔙 Back", "back_main", style="primary")
        ]
    ]

def force_channel_keyboard(user_id):
    lang = get_user_lang(user_id)
    return [
        [
            Button.inline("➕ افزودن کانال" if lang == "fa" else "➕ ADD CHANNEL", "em_fc_add", style="primary"),
            Button.inline("➖ حذف کانال" if lang == "fa" else "➖ REMOVE CHANNEL", "em_fc_remove", style="danger")
        ],
        [
            Button.inline("📋 لیست کانال‌ها" if lang == "fa" else "📋 CHANNEL LIST", "em_fc_list", style="primary"),
            Button.inline("🔙 بازگشت" if lang == "fa" else "🔙 BACK", "em_back", style="primary")
        ]
    ]

# ==================== هندلر استارت ====================
async def start_handler(event):
    try:
        user_id = event.sender_id
        if is_blocked(user_id):
            await event.reply("🚫 شما بلاک هستید" if get_user_lang(user_id) == "fa" else "🚫 You are blocked")
            return
        
        data = load_data()
        if str(user_id) not in data["users"]:
            data["users"].append(user_id)
            save_data(data)
        
        lang = get_user_lang(user_id)
        if lang is None:
            buttons = [
                [Button.inline("فارسی", "lang_fa"), Button.inline("English", "lang_en")]
            ]
            await event.reply("🌍 Please choose your language:\nلطفاً زبان خود را انتخاب کنید:", buttons=buttons)
            return
        
        if not (is_owner(user_id) or is_admin(user_id)):
            await event.reply(
                "🦻 شما اشتراک فعالی ندارید. لطفاً برای دریافت یا تمدید اشتراک به @OriginalKhodeWinner مراجعه کنید ⚡"
                if lang == "fa" else
                "🦻 You do not have an active subscription. Please contact @OriginalKhodeWinner to get or renew your subscription ⚡"
            )
            return
        
        kb = main_menu_keyboard(user_id)
        if kb is None:
            await event.reply("❌ خطا در ساخت منو. لطفاً با پشتیبانی تماس بگیرید.")
            return
        
        await event.reply(
            "✅ به ربات Winner Reporter خوش آمدید" if lang == "fa" else "✅ Welcome to Winner Reporter",
            buttons=kb
        )
    except Exception as e:
        logger.error(f"Error in start_handler: {e}")
        try:
            await event.reply(f"❌ خطای داخلی: {str(e)[:100]}")
        except:
            pass

# ==================== کالبک هندلر اصلی ====================
async def callback_handler(event):
    try:
        data_str = event.data.decode('utf-8')
        user_id = event.sender_id
        lang = get_user_lang(user_id)
        
        if data_str in ["noop", "none"]:
            await event.answer()
            return
        
        # انتخاب زبان
        if data_str in ["lang_fa", "lang_en"]:
            lang_code = "fa" if data_str == "lang_fa" else "en"
            set_user_lang(user_id, lang_code)
            lang = lang_code
            if not (is_owner(user_id) or is_admin(user_id)):
                await event.edit(
                    "🦻 شما اشتراک فعالی ندارید. لطفاً برای دریافت یا تمدید اشتراک به @OriginalKhodeWinner مراجعه کنید ⚡"
                    if lang == "fa" else
                    "🦻 You do not have an active subscription. Please contact @OriginalKhodeWinner to get or renew your subscription ⚡"
                )
                return
            await event.edit(
                "✅ زبان ذخیره شد" if lang == "fa" else "✅ Language saved",
                buttons=main_menu_keyboard(user_id)
            )
            return
        
        # چک دسترسی
        if not (is_owner(user_id) or is_admin(user_id)):
            await event.answer(
                "🦻 شما اشتراک فعالی ندارید. لطفاً برای دریافت یا تمدید اشتراک به @OriginalKhodeWinner مراجعه کنید ⚡"
                if lang == "fa" else
                "🦻 You do not have an active subscription. Please contact @OriginalKhodeWinner to get or renew your subscription ⚡",
                alert=True
            )
            return
        
        # تغییر زبان از منو
        if data_str == "change_lang":
            buttons = [
                [Button.inline("فارسی", "lang_fa"), Button.inline("English", "lang_en")]
            ]
            await event.edit("🌍 انتخاب زبان / Choose language:", buttons=buttons)
            return
        
        # منوی ایمیل
        if data_str == "menu_email":
            await event.edit(
                "📧 ایمیل ریپورتر" if lang == "fa" else "📧 Email Reporter",
                buttons=email_menu_keyboard(user_id)
            )
            return
        
        # منوی تلگرام
        if data_str == "menu_telegram":
            await event.edit(
                "🚫 تلگرام ریپورتر" if lang == "fa" else "🚫 Telegram Reporter",
                buttons=telegram_menu_keyboard(user_id)
            )
            return
        
        # بازگشت به منوی اصلی
        if data_str == "back_main":
            await event.edit(
                "✅ منوی اصلی" if lang == "fa" else "✅ Main Menu",
                buttons=main_menu_keyboard(user_id)
            )
            return
        
        # پنل مالک
        if data_str == "owner_panel":
            if not is_owner(user_id):
                await event.answer(
                    "⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized",
                    alert=True
                )
                return
            await event.edit(
                "👑 پنل مالک" if lang == "fa" else "👑 Owner Panel",
                buttons=owner_panel_keyboard(user_id)
            )
            return
        
        # افزودن ادمین
        if data_str == "add_admin":
            if not is_owner(user_id):
                await event.answer(
                    "⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized",
                    alert=True
                )
                return
            USER_STATE[user_id] = {"action": "add_admin", "step": "waiting_user_id"}
            await event.edit(
                "🆔 آیدی عددی کاربر را برای افزودن به ادمین‌ها وارد کنید" if lang == "fa" else "🆔 Enter user ID to add as admin"
            )
            return
        
        # انتخاب مدت زمان ادمین
        if data_str.startswith("adm_"):
            state = USER_STATE.get(user_id, {})
            if state.get("action") != "add_admin" or state.get("step") != "waiting_duration":
                await event.answer(
                    "⏳ لطفاً ابتدا آیدی کاربر را وارد کنید" if lang == "fa" else "⏳ Please enter user ID first",
                    alert=True
                )
                return
            target_user = state.get("target_user")
            if not target_user:
                await event.answer("❌ خطا" if lang == "fa" else "❌ Error")
                return
            current_time = datetime.now(pytz.timezone('Asia/Tehran'))
            duration_map = {
                "adm_1h": timedelta(hours=1),
                "adm_1d": timedelta(days=1),
                "adm_1w": timedelta(weeks=1),
                "adm_1m": timedelta(days=30),
                "adm_3m": timedelta(days=90),
                "adm_6m": timedelta(days=180),
                "adm_1y": timedelta(days=365)
            }
            duration = duration_map.get(data_str)
            if not duration:
                await event.answer("مدت نامعتبر" if lang == "fa" else "Invalid duration")
                return
            expires = current_time + duration
            data_db = load_data()
            data_db.setdefault("admins", {})[str(target_user)] = {
                "expires": expires,
                "activated": current_time
            }
            data_db.setdefault("admin_data", {}).setdefault(str(target_user), {
                "smtp": [],
                "active_senders": [],
                "recipients": []
            })
            save_data(data_db)
            await event.edit(
                f"✅ ادمین برای کاربر {target_user} با موفقیت افزوده شد\n"
                f"تاریخ انقضا: {expires.strftime('%Y-%m-%d %H:%M:%S')}" if lang == "fa" else
                f"✅ Admin added for user {target_user}\n"
                f"Expires: {expires.strftime('%Y-%m-%d %H:%M:%S')}",
                buttons=[[Button.inline("🔙 بازگشت به منوی اصلی" if lang == "fa" else "🔙 BACK TO MAIN MENU", "back_main")]]
            )
            USER_STATE.pop(user_id, None)
            return
        
        # ایمیل کالبک
        if data_str.startswith("em_"):
            await email_callback(event, data_str, user_id, lang)
            return
        
        # تلگرام کالبک
        if data_str.startswith("tg_"):
            await telegram_callback(event, data_str, user_id, lang)
            return
        
        # دکمه ناشناخته
        await event.answer("❌ دکمه ناشناخته" if lang == "fa" else "❌ Unknown button", alert=True)
    
    except Exception as e:
        logger.error(f"Error in callback_handler: {e}")
        try:
            await event.answer("❌ خطای داخلی", alert=True)
        except:
            pass

# ==================== کالبک ایمیل ====================
async def email_callback(event, data, user_id, lang):
    data_db = load_data()
    admin_data = get_admin_data(user_id)
    
    # افزودن SMTP
    if data == "em_smtp_add":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "flow": "smtp", "step": "waiting_email"}
        await event.edit("📧 آدرس Gmail را وارد کنید" if lang == "fa" else "📧 Enter Gmail address")
        return
    
    # لیست SMTP
    if data == "em_smtp_list":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        smtp_list = get_shared_smtp()
        if not smtp_list:
            await event.edit("❌ SMTP ثبت نشده" if lang == "fa" else "❌ No SMTP found",
                           buttons=[[Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")]])
            return
        kb = []
        row = []
        for smtp in smtp_list:
            email = smtp.get("email", "")
            if email:
                row.append(Button.inline(email, f"em_smtp_view_{email}"))
                if len(row) == 2:
                    kb.append(row)
                    row = []
        if row:
            kb.append(row)
        kb.append([Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")])
        await event.edit("📋 لیست SMTP (اشتراکی)" if lang == "fa" else "📋 SMTP List (Shared)", buttons=kb)
        return
    
    # مشاهده SMTP
    if data.startswith("em_smtp_view_"):
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        email = data.replace("em_smtp_view_", "", 1)
        kb = [
            [Button.inline("🗑 حذف" if lang == "fa" else "DELETE", f"em_smtp_del_{email}")],
            [Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_smtp_list")]
        ]
        await event.edit(f"📧 {email}\n\nحذف شود؟" if lang == "fa" else f"📧 {email}\n\nDelete?", buttons=kb)
        return
    
    # حذف SMTP
    if data.startswith("em_smtp_del_"):
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        email = data.replace("em_smtp_del_", "", 1)
        smtp_list = get_shared_smtp()
        new_list = [s for s in smtp_list if s.get("email") != email]
        save_shared_smtp(new_list)
        if not new_list:
            await event.edit("✅ حذف شد\n📭 لیست خالی" if lang == "fa" else "✅ Deleted\nEmpty list",
                           buttons=[[Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")]])
            return
        kb = []
        row = []
        for s in new_list:
            em = s.get("email", "")
            row.append(Button.inline(em, f"em_smtp_view_{em}"))
            if len(row) == 2:
                kb.append(row)
                row = []
        if row:
            kb.append(row)
        kb.append([Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")])
        await event.edit("📋 لیست SMTP (اشتراکی)" if lang == "fa" else "📋 SMTP List (Shared)", buttons=kb)
        return
    
    # فعال‌سازی ارسال‌کننده
    if data == "em_activate":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        smtp_list = get_shared_smtp()
        active = admin_data.get("active_senders", [])
        kb = []
        for s in smtp_list:
            email = s.get("email", "")
            status = "🟢" if email in active else "🔴"
            kb.append([Button.inline(f"{status} {email}", f"em_toggle_{email}")])
        kb.append([Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")])
        await event.edit("🟢 انتخاب SMTP فعال" if lang == "fa" else "🟢 Select active SMTP", buttons=kb)
        return
    
    # تغییر وضعیت SMTP
    if data.startswith("em_toggle_"):
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        email = data.replace("em_toggle_", "", 1)
        active = admin_data.get("active_senders", [])
        if email in active:
            active.remove(email)
        else:
            active.append(email)
        save_data(data_db)
        kb = []
        for s in get_shared_smtp():
            em = s.get("email", "")
            status = "🟢" if em in active else "🔴"
            kb.append([Button.inline(f"{status} {em}", f"em_toggle_{em}")])
        kb.append([Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")])
        await event.edit("🟢 انتخاب SMTP فعال" if lang == "fa" else "🟢 Select active SMTP", buttons=kb)
        await event.answer("✅ وضعیت تغییر کرد" if lang == "fa" else "✅ Status changed")
        return
    
    # ارسال تکی
    if data == "em_single_send":
        USER_STATE[user_id] = {"section": "email", "flow": "single", "step": "to"}
        await event.edit("📧 گیرنده را وارد کنید" if lang == "fa" else "📧 Enter recipient")
        return
    
    # ارسال گروهی
    if data == "em_bulk_send":
        USER_STATE[user_id] = {"section": "email", "flow": "bulk", "step": "subject"}
        await event.edit("✏️ موضوع را وارد کنید" if lang == "fa" else "✏️ Enter subject")
        return
    
    # افزودن گیرنده
    if data == "em_add_recip":
        USER_STATE[user_id] = {"section": "email", "step": "add_recipient"}
        await event.edit("📧 ایمیل گیرنده را ارسال کنید" if lang == "fa" else "📧 Send recipient email")
        return
    
    # پاک کردن گیرنده‌ها
    if data == "em_clear_recip":
        admin_data["recipients"] = []
        save_data(data_db)
        await event.edit("🗑 پاک شد" if lang == "fa" else "🗑 Cleared")
        return
    
    # لیست گیرنده‌ها
    if data == "em_recips":
        recips = admin_data.get("recipients", [])
        text = "\n".join(recips) if recips else ("📭 لیست گیرنده‌ها خالی است" if lang == "fa" else "📭 Recipients list is empty")
        await event.edit(text, buttons=[[Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")]])
        return
    
    # آمار
    if data == "em_stats":
        today = data_db.get("send_today", 0)
        week = data_db.get("send_week", 0)
        await event.edit(f"📊 ارسال امروز: {today}\n📊 ارسال این هفته: {week}" if lang == "fa" else
                        f"📊 Today: {today}\n📊 This Week: {week}")
        return
    
    # نمایندگی
    if data == "em_agency":
        await event.answer("بخش نمایندگی غیرفعال است" if lang == "fa" else "Agency disabled", alert=True)
        return
    
    # پیام همگانی
    if data == "em_broadcast":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "step": "waiting_broadcast"}
        await event.edit("📨 متن همگانی را ارسال کنید" if lang == "fa" else "📨 Send broadcast message")
        return
    
    # پیام به کاربر
    if data == "em_msg_user":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "step": "waiting_msg_user_id"}
        await event.edit("🆔 آیدی کاربر را ارسال کنید" if lang == "fa" else "🆔 Send user ID")
        return
    
    # بلاک کاربر
    if data == "em_block":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "step": "waiting_block_id"}
        await event.edit("🚫 آیدی کاربر را برای بلاک وارد کنید" if lang == "fa" else "🚫 Enter user ID to block")
        return
    
    # آنبلاک کاربر
    if data == "em_unblock":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "step": "waiting_unblock_id"}
        await event.edit("✅ آیدی کاربر را برای آنبلاک وارد کنید" if lang == "fa" else "✅ Enter user ID to unblock")
        return
    
    # مدیریت کانال اجباری
    if data == "em_force_channel":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        await event.edit("📢 مدیریت کانال اجباری" if lang == "fa" else "📢 Manage Force Channel",
                        buttons=force_channel_keyboard(user_id))
        return
    
    # افزودن کانال اجباری
    if data == "em_fc_add":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "step": "waiting_fc_add"}
        await event.edit("📢 لینک یا یوزرنیم کانال را ارسال کنید" if lang == "fa" else "📢 Send channel username or link")
        return
    
    # حذف کانال اجباری
    if data == "em_fc_remove":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        USER_STATE[user_id] = {"section": "email", "step": "waiting_fc_remove"}
        await event.edit("📢 یوزرنیم کانال را برای حذف وارد کنید" if lang == "fa" else "📢 Enter channel username to remove")
        return
    
    # لیست کانال‌های اجباری
    if data == "em_fc_list":
        if not is_owner(user_id):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
            return
        data_db = load_data()
        channels = data_db.get("force_channels", [])
        if channels:
            text = "📢 کانال‌های اجباری:\n" + "\n".join(channels)
        else:
            text = "📭 کانال اجباری ثبت نشده" if lang == "fa" else "📭 No forced channels"
        await event.edit(text, buttons=[[Button.inline("🔙 بازگشت" if lang == "fa" else "BACK", "em_back")]])
        return
    
    # بازگشت به منوی ایمیل
    if data == "em_back":
        await event.edit("📧 ایمیل ریپورتر" if lang == "fa" else "📧 Email Reporter",
                        buttons=email_menu_keyboard(user_id))
        return
    
    # دکمه ناشناخته
    await event.answer("❌ دکمه ناشناخته" if lang == "fa" else "❌ Unknown button", alert=True)

# ==================== کالبک تلگرام ====================
async def telegram_callback(event, data, user_id, lang):
    try:
        if not (is_owner(user_id) or is_admin(user_id)):
            await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized access", alert=True)
            return
        
        # گزارش کانال/گروه
        if data == "tg_report":
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ هیچ اکانتی در دسترس نیست" if lang == "fa" else "❌ No accounts available", alert=True)
                return
            proxy_manager = ProxyManager(user_id)
            if proxy_manager.get_proxy_count() < 3:
                await event.edit(
                    "⚠️ شما حداقل ۳ پروکسی نیاز دارید.\n"
                    "لطفاً پروکسی‌های خود را به صورت خط به خط وارد کنید (فرمت: ip:port):" if lang == "fa" else
                    "⚠️ You need at least 3 proxies.\n"
                    "Please enter your proxies line by line (format: ip:port):",
                    buttons=[[Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "back_main")]]
                )
                USER_STATE[user_id] = {"section": "telegram", "type": "report", "step": "waiting_proxies", "sessions": sessions}
                return
            USER_STATE[user_id] = {"section": "telegram", "type": "report", "step": "count", "sessions": sessions, "proxy_manager": proxy_manager}
            await event.edit(f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else f"🔢 Number of accounts? (1-{len(sessions)})")
            return
        
        # گزارش پست
        if data == "tg_report_post":
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ هیچ اکانتی در دسترس نیست" if lang == "fa" else "❌ No accounts available", alert=True)
                return
            proxy_manager = ProxyManager(user_id)
            if proxy_manager.get_proxy_count() < 3:
                await event.edit(
                    "⚠️ شما حداقل ۳ پروکسی نیاز دارید.\n"
                    "لطفاً پروکسی‌های خود را به صورت خط به خط وارد کنید (فرمت: ip:port):" if lang == "fa" else
                    "⚠️ You need at least 3 proxies.\n"
                    "Please enter your proxies line by line (format: ip:port):",
                    buttons=[[Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "back_main")]]
                )
                USER_STATE[user_id] = {"section": "telegram", "type": "report_post", "step": "waiting_proxies", "sessions": sessions}
                return
            USER_STATE[user_id] = {"section": "telegram", "type": "report_post", "step": "count", "sessions": sessions, "proxy_manager": proxy_manager}
            await event.edit(f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else f"🔢 Number of accounts? (1-{len(sessions)})")
            return
        
        # گزارش پروفایل
        if data == "tg_report_profile":
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ هیچ اکانتی در دسترس نیست" if lang == "fa" else "❌ No accounts available", alert=True)
                return
            proxy_manager = ProxyManager(user_id)
            if proxy_manager.get_proxy_count() < 3:
                await event.edit(
                    "⚠️ شما حداقل ۳ پروکسی نیاز دارید.\n"
                    "لطفاً پروکسی‌های خود را به صورت خط به خط وارد کنید (فرمت: ip:port):" if lang == "fa" else
                    "⚠️ You need at least 3 proxies.\n"
                    "Please enter your proxies line by line (format: ip:port):",
                    buttons=[[Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "back_main")]]
                )
                USER_STATE[user_id] = {"section": "telegram", "type": "report_profile", "step": "waiting_proxies", "sessions": sessions}
                return
            USER_STATE[user_id] = {"section": "telegram", "type": "report_profile", "step": "count", "sessions": sessions, "proxy_manager": proxy_manager}
            await event.edit(f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else f"🔢 Number of accounts? (1-{len(sessions)})")
            return
        
        # گزارش ربات
        if data == "tg_report_bot":
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ هیچ اکانتی در دسترس نیست" if lang == "fa" else "❌ No accounts available", alert=True)
                return
            proxy_manager = ProxyManager(user_id)
            if proxy_manager.get_proxy_count() < 3:
                await event.edit(
                    "⚠️ شما حداقل ۳ پروکسی نیاز دارید.\n"
                    "لطفاً پروکسی‌های خود را به صورت خط به خط وارد کنید (فرمت: ip:port):" if lang == "fa" else
                    "⚠️ You need at least 3 proxies.\n"
                    "Please enter your proxies line by line (format: ip:port):",
                    buttons=[[Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "back_main")]]
                )
                USER_STATE[user_id] = {"section": "telegram", "type": "report_bot", "step": "waiting_proxies", "sessions": sessions}
                return
            USER_STATE[user_id] = {"section": "telegram", "type": "report_bot", "step": "count", "sessions": sessions, "proxy_manager": proxy_manager}
            await event.edit(f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else f"🔢 Number of accounts? (1-{len(sessions)})")
            return
        
        # گزارش اکانت
        if data == "tg_report_account":
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ هیچ اکانتی در دسترس نیست" if lang == "fa" else "❌ No accounts available", alert=True)
                return
            proxy_manager = ProxyManager(user_id)
            if proxy_manager.get_proxy_count() < 3:
                await event.edit(
                    "⚠️ شما حداقل ۳ پروکسی نیاز دارید.\n"
                    "لطفاً پروکسی‌های خود را به صورت خط به خط وارد کنید (فرمت: ip:port):" if lang == "fa" else
                    "⚠️ You need at least 3 proxies.\n"
                    "Please enter your proxies line by line (format: ip:port):",
                    buttons=[[Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "back_main")]]
                )
                USER_STATE[user_id] = {"section": "telegram", "type": "report_account", "step": "waiting_proxies", "sessions": sessions}
                return
            USER_STATE[user_id] = {"section": "telegram", "type": "report_account", "step": "count", "sessions": sessions, "proxy_manager": proxy_manager}
            await event.edit(f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else f"🔢 Number of accounts? (1-{len(sessions)})")
            return
        
        # گزارش دستی
        if data == "tg_manual_report":
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ هیچ اکانتی در دسترس نیست" if lang == "fa" else "❌ No accounts available", alert=True)
                return
            proxy_manager = ProxyManager(user_id)
            if proxy_manager.get_proxy_count() < 3:
                await event.edit(
                    "⚠️ شما حداقل ۳ پروکسی نیاز دارید.\n"
                    "لطفاً پروکسی‌های خود را به صورت خط به خط وارد کنید (فرمت: ip:port):" if lang == "fa" else
                    "⚠️ You need at least 3 proxies.\n"
                    "Please enter your proxies line by line (format: ip:port):",
                    buttons=[[Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "back_main")]]
                )
                USER_STATE[user_id] = {"section": "telegram", "type": "manual_report", "step": "waiting_proxies", "sessions": sessions}
                return
            USER_STATE[user_id] = {"section": "telegram", "type": "manual_report", "step": "count", "sessions": sessions, "proxy_manager": proxy_manager}
            await event.edit(f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else f"🔢 Number of accounts? (1-{len(sessions)})")
            return
        
        # مدیریت اکانت‌ها
        if data == "tg_manage_acc":
            if not is_owner(user_id):
                await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
                return
            await event.edit("⚙️ مدیریت اکانت‌ها" if lang == "fa" else "⚙️ Manage Accounts",
                            buttons=manage_accounts_keyboard(user_id))
            return
        
        # لیست اشتراکی
        if data == "tg_list_shared":
            if not is_owner(user_id):
                await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
                return
            sessions = get_user_sessions(user_id)
            if not sessions:
                await event.answer("❌ اکانتی وجود ندارد" if lang == "fa" else "❌ No accounts", alert=True)
                return
            kb = []
            if os.path.exists(SHARED_SESSIONS_DIR):
                for f in os.listdir(SHARED_SESSIONS_DIR):
                    if f.endswith('.session'):
                        phone = f.replace('.session', '')
                        status = await check_session_status(("shared", f))
                        btn_text = f"📱 +{phone} - {status}"
                        kb.append([
                            Button.inline(btn_text, "noop"),
                            Button.inline("🗑", f"tg_delacc_shared_{phone}")
                        ])
            if not kb:
                await event.edit("📭 هیچ اکانتی یافت نشد." if lang == "fa" else "📭 No accounts found.")
                return
            kb.append([Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "tg_back")])
            await event.edit("📋 لیست اکانت‌ها (اشتراکی)" if lang=="fa" else "📋 Accounts (Shared)", buttons=kb)
            return
        
        # لیست همه اکانت‌ها
        if data == "tg_list_all":
            if not is_owner(user_id):
                await event.answer("⛔ دسترسی غیرمجاز" if lang == "fa" else "⛔ Unauthorized", alert=True)
                return
            kb = []
            if os.path.exists(SHARED_SESSIONS_DIR):
                for f in os.listdir(SHARED_SESSIONS_DIR):
                    if f.endswith('.session'):
                        phone = f.replace('.session', '')
                        status = await check_session_status(("shared", f))
                        btn_text = f"📱 +{phone} - {status}"
                        kb.append([
                            Button.inline(btn_text, "noop"),
                            Button.inline("🗑", f"tg_delacc_shared_{phone}")
                        ])
            if not kb:
                await event.edit("📭 هیچ اکانتی یافت نشد." if lang == "fa" else "📭 No accounts found.")
                return
            kb.append([Button.inline("🔙 بازگشت" if lang=="fa" else "BACK", "tg_back")])
            await event.edit("📋 لیست همه اکانت‌ها" if lang=="fa" else "📋 All Accounts", buttons=kb)
            return
        
        # افزودن اکانت
        if data == "tg_add_acc":
            if is_owner(user_id):
                USER_STATE[user_id] = {"section": "telegram", "step": "select_admin"}
                await event.edit("🆔 آیدی عددی ادمین مقصد را وارد کنید (یا 0 برای خودتان)" if lang == "fa" else "🆔 Enter target admin ID (or 0 for yourself)")
            else:
                USER_STATE[user_id] = {"section": "telegram", "step": "phone", "target_admin": user_id}
                await event.edit("📱 شماره تلفن با + را وارد کنید" if lang == "fa" else "📱 Enter phone number with +")
            return
        
        # حذف اکانت
        if data == "tg_del_acc":
            if is_owner(user_id):
                USER_STATE[user_id] = {"section": "telegram", "step": "delete_select_admin"}
                await event.edit("🆔 آیدی عددی ادمین برای حذف اکانت را وارد کنید" if lang == "fa" else "🆔 Enter admin ID to delete account from")
            else:
                USER_STATE[user_id] = {"section": "telegram", "step": "delete_phone", "target_admin": user_id}
                await event.edit("📱 شماره تلفن برای حذف را وارد کنید" if lang == "fa" else "📱 Enter phone number to delete")
            return
        
        # حذف اکانت با دکمه
        if data.startswith("tg_delacc_"):
            parts = data[len("tg_delacc_"):].split("_", 1)
            if len(parts) != 2:
                await event.answer("Error")
                return
            admin_id_str, phone_clean = parts
            if not is_owner(user_id) and admin_id_str != str(user_id):
                await event.answer("⛔ Unauthorized", alert=True)
                return
            path = os.path.join(SHARED_SESSIONS_DIR, f"{phone_clean}.session")
            if os.path.exists(path):
                os.remove(path)
                clear_user_cache()
                await event.answer("✅ حذف شد" if lang=="fa" else "✅ Deleted", alert=True)
            else:
                await event.answer("❌ یافت نشد" if lang=="fa" else "❌ Not found", alert=True)
            await event.edit("🚫 تلگرام ریپورتر" if lang == "fa" else "🚫 Telegram Reporter",
                            buttons=telegram_menu_keyboard(user_id))
            return
        
        # بازگشت به منوی تلگرام
        if data == "tg_back":
            await event.edit("🚫 تلگرام ریپورتر" if lang == "fa" else "🚫 Telegram Reporter",
                            buttons=telegram_menu_keyboard(user_id))
            return
        
        # انتخاب دلیل ریپورت
        if data.startswith("tg_reason_"):
            reason_key = data.replace("tg_reason_", "", 1)
            state = USER_STATE.get(user_id, {})
            if not state:
                await event.answer("Session expired")
                return
            state["reason_key"] = reason_key
            if reason_key == "rotation":
                state["rotation"] = True
                state["step"] = "count_per_account"
                await event.edit("🔢 تعداد ریپورت هر اکانت؟ (1-50)" if lang == "fa" else "🔢 Reports per account? (1-50)")
            else:
                state["rotation"] = False
                if state.get("type") == "manual_report":
                    state["step"] = "custom_reason"
                    await event.edit("📝 متن گزارش سفارشی (حداقل 4 خط)" if lang == "fa" else "📝 Enter custom report message (min 4 lines)")
                else:
                    state["step"] = "count_per_account"
                    await event.edit("🔢 تعداد ریپورت هر اکانت؟ (1-50)" if lang == "fa" else "🔢 Reports per account? (1-50)")
            return
        
        await event.answer("Unknown")
    
    except Exception as e:
        logger.error(f"Error in telegram_callback: {e}")
        try:
            await event.answer("❌ خطای داخلی", alert=True)
        except:
            pass

# ==================== هندلر پیام‌ها ====================
async def message_handler(event):
    if event.text.startswith('/'):
        return
    
    text = event.text.strip()
    user_id = event.sender_id
    state = USER_STATE.get(user_id, {})
    lang = get_user_lang(user_id)
    
    if not state:
        return
    
    if not (is_owner(user_id) or is_admin(user_id)):
        USER_STATE.pop(user_id, None)
        return
    
    # افزودن ادمین
    if state.get("action") == "add_admin" and state.get("step") == "waiting_user_id":
        if not text.isdigit():
            await event.reply("❌ لطفاً یک آیدی عددی وارد کنید" if lang == "fa" else "❌ Please enter a numeric ID")
            return
        target_user = int(text)
        state["target_user"] = target_user
        state["step"] = "waiting_duration"
        await event.reply("⏰ مدت ادمین را انتخاب کنید:" if lang == "fa" else "⏰ Select admin duration:",
                         buttons=admin_duration_keyboard(lang))
        return
    
    section = state.get("section")
    if section == "email":
        await email_message_handler(event, state, text, user_id, lang)
    elif section == "telegram":
        await telegram_message_handler(event, state, text, user_id, lang)

# ==================== هندلر پیام‌های ایمیل ====================
async def email_message_handler(event, state, text, user_id, lang):
    data_db = load_data()
    admin_data = get_admin_data(user_id)
    flow = state.get("flow")
    step = state.get("step")
    
    # بخش SMTP
    if flow == "smtp":
        if step == "waiting_email":
            if "@" not in text or "." not in text:
                await event.reply("❌ ایمیل معتبر نیست" if lang == "fa" else "❌ Invalid email")
                return
            state["email"] = text
            state["step"] = "waiting_password"
            await event.reply("🔑 App Password را وارد کنید" if lang == "fa" else "🔑 Enter App Password")
            return
        if step == "waiting_password":
            email = state["email"]
            password = text.replace(" ", "")
            ok = await test_smtp_connection(email, password)
            if not ok:
                USER_STATE.pop(user_id, None)
                await event.reply("❌ ایمیل یا App Password اشتباه است" if lang == "fa" else "❌ Wrong email or app password")
                return
            smtp_list = get_shared_smtp()
            smtp_list.append({"email": email, "password": password})
            save_shared_smtp(smtp_list)
            USER_STATE.pop(user_id, None)
            await event.reply("✅ SMTP با موفقیت ذخیره شد" if lang == "fa" else "✅ SMTP saved successfully")
            return
    
    # ارسال تکی
    if flow == "single":
        if step == "to":
            if "@" not in text or "." not in text:
                await event.reply("❌ ایمیل معتبر نیست" if lang == "fa" else "❌ Invalid email")
                return
            state["to"] = text
            state["step"] = "subject"
            await event.reply("📝 موضوع را وارد کنید" if lang == "fa" else "📝 Enter subject")
            return
        if step == "subject":
            state["subject"] = text
            state["step"] = "body"
            await event.reply("📝 متن ایمیل را وارد کنید" if lang == "fa" else "📝 Enter email body")
            return
        if step == "body":
            to = state["to"]
            subject = state["subject"]
            body = text
            smtp_list = get_shared_smtp()
            if not smtp_list:
                USER_STATE.pop(user_id, None)
                await event.reply("❌ SMTP موجود نیست" if lang == "fa" else "❌ No SMTP available")
                return
            active = admin_data.get("active_senders", [])
            senders = [s for s in smtp_list if s["email"] in active] if active else smtp_list
            if not senders:
                senders = smtp_list
            success = 0
            failed = 0
            for sender in senders:
                ok, _ = send_email_sync(sender["email"], sender["password"], to, subject, body)
                if ok:
                    success += 1
                else:
                    failed += 1
                await asyncio.sleep(random.uniform(3, 5))
            await event.reply(
                f"✅ ارسال شد\n📧 گیرنده: {to}\n📨 تعداد فرستنده‌ها: {len(senders)}\n✅ موفق: {success}\n❌ ناموفق: {failed}"
                if lang == "fa" else
                f"✅ Sent\n📧 Recipient: {to}\n📨 Senders: {len(senders)}\n✅ Success: {success}\n❌ Failed: {failed}"
            )
            USER_STATE.pop(user_id, None)
            return
    
    # ارسال گروهی
    if flow == "bulk":
        if step == "subject":
            state["subject"] = text
            state["step"] = "body"
            await event.reply("📝 متن ایمیل را وارد کنید" if lang == "fa" else "📝 Enter email body")
            return
        if step == "body":
            subject = state["subject"]
            body = text
            recips = admin_data.get("recipients", [])
            if not recips:
                USER_STATE.pop(user_id, None)
                await event.reply("❌ گیرنده‌ای نیست" if lang == "fa" else "❌ No recipients")
                return
            smtp_list = get_shared_smtp()
            if not smtp_list:
                USER_STATE.pop(user_id, None)
                await event.reply("❌ SMTP ندارید" if lang == "fa" else "❌ No SMTP")
                return
            active = admin_data.get("active_senders", [])
            senders = [s for s in smtp_list if s["email"] in active] if active else smtp_list
            if not senders:
                senders = smtp_list
            success = 0
            failed = 0
            for recipient in recips:
                for sender in senders:
                    ok, _ = send_email_sync(sender["email"], sender["password"], recipient, subject, body)
                    if ok:
                        success += 1
                    else:
                        failed += 1
                    await asyncio.sleep(1)
            await event.reply(
                f"✅ تمام شد\n📨 کل: {len(recips)}\n✅ موفق: {success}\n❌ ناموفق: {failed}"
                if lang == "fa" else
                f"✅ Done\n📨 Total: {len(recips)}\n✅ Success: {success}\n❌ Failed: {failed}"
            )
            USER_STATE.pop(user_id, None)
            return
    
    # افزودن گیرنده
    if step == "add_recipient":
        emails = [x.strip() for x in text.splitlines() if x.strip()]
        added = 0
        dup = 0
        for email in emails:
            if email in admin_data["recipients"]:
                dup += 1
                continue
            admin_data["recipients"].append(email)
            added += 1
        save_data(data_db)
        await event.reply(f"✅ {added} گیرنده اضافه شد\n⚠️ تکراری: {dup}" if lang == "fa" else
                         f"✅ {added} added\n⚠️ duplicate: {dup}")
        USER_STATE.pop(user_id, None)
        return
    
    # پیام همگانی
    if step == "waiting_broadcast":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        if not text.strip():
            await event.reply("❌ متن خالی است" if lang == "fa" else "❌ Empty text")
            return
        data_db = load_data()
        users = data_db.get("users", [])
        sent = 0
        blocked = 0
        failed = 0
        total = len(users)
        if total == 0:
            await event.reply("❌ کاربری وجود ندارد" if lang == "fa" else "❌ No users")
            USER_STATE.pop(user_id, None)
            return
        msg = await event.reply("🚀 ارسال همگانی آغاز شد..." if lang == "fa" else "🚀 Broadcast started...")
        for i, uid in enumerate(users, 1):
            try:
                await event.client.send_message(int(uid), text)
                sent += 1
            except errors.UserIsBlockedError:
                blocked += 1
            except:
                failed += 1
            if i % 10 == 0 or i == total:
                percent = int(i * 100 / total)
                bar = "🟩" * (percent // 10) + "⬜" * (10 - percent // 10)
                try:
                    await msg.edit(
                        f"🚀 ارسال همگانی\n{bar} {percent}%\n👥 کل: {total}\n📤 موفق: {sent}\n🚫 بلاک: {blocked}\n❌ خطا: {failed}"
                        if lang == "fa" else
                        f"🚀 Broadcast\n{bar} {percent}%\n👥 Total: {total}\n📤 Sent: {sent}\n🚫 Blocked: {blocked}\n❌ Failed: {failed}"
                    )
                except:
                    pass
            await asyncio.sleep(0.05)
        await msg.edit(
            f"✅ ارسال همگانی پایان یافت\n🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩 100%\n👥 کل: {total}\n📤 موفق: {sent}\n🚫 بلاک: {blocked}\n❌ خطا: {failed}"
            if lang == "fa" else
            f"✅ Broadcast completed\n🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩 100%\n👥 Total: {total}\n📤 Sent: {sent}\n🚫 Blocked: {blocked}\n❌ Failed: {failed}"
        )
        USER_STATE.pop(user_id, None)
        return
    
    # پیام به کاربر
    if step == "waiting_msg_user_id":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        if not text.isdigit():
            await event.reply("❌ فقط آیدی عددی" if lang == "fa" else "❌ Numeric ID only")
            return
        state["target_user"] = int(text)
        state["step"] = "waiting_msg_user_text"
        await event.reply("✉️ متن پیام را ارسال کنید" if lang == "fa" else "✉️ Send message text")
        return
    
    if step == "waiting_msg_user_text":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        target = state.get("target_user")
        if not target:
            USER_STATE.pop(user_id, None)
            return
        try:
            await event.client.send_message(target, text)
            await event.reply("✅ پیام ارسال شد" if lang == "fa" else "✅ Message sent")
        except:
            await event.reply("❌ ارسال ناموفق" if lang == "fa" else "❌ Failed")
        USER_STATE.pop(user_id, None)
        return
    
    # بلاک کاربر
    if step == "waiting_block_id":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        if not text.isdigit():
            await event.reply("❌ فقط آیدی عددی" if lang == "fa" else "❌ Numeric ID only")
            return
        data_db = load_data()
        data_db.setdefault("blocked", [])
        target = int(text)
        if target not in data_db["blocked"]:
            data_db["blocked"].append(target)
            save_data(data_db)
        await event.reply("🚫 کاربر بلاک شد" if lang == "fa" else "🚫 User blocked")
        USER_STATE.pop(user_id, None)
        return
    
    # آنبلاک کاربر
    if step == "waiting_unblock_id":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        if not text.isdigit():
            await event.reply("❌ فقط آیدی عددی" if lang == "fa" else "❌ Numeric ID only")
            return
        data_db = load_data()
        data_db.setdefault("blocked", [])
        target = int(text)
        if target in data_db["blocked"]:
            data_db["blocked"].remove(target)
            save_data(data_db)
        await event.reply("✅ کاربر آنبلاک شد" if lang == "fa" else "✅ User unblocked")
        USER_STATE.pop(user_id, None)
        return
    
    # افزودن کانال اجباری
    if step == "waiting_fc_add":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        if not text.strip():
            await event.reply("❌ ورودی نامعتبر" if lang == "fa" else "❌ Invalid input")
            return
        channel = text.strip()
        if not channel.startswith("@"):
            channel = "@" + channel
        data_db = load_data()
        data_db.setdefault("force_channels", [])
        if channel not in data_db["force_channels"]:
            data_db["force_channels"].append(channel)
            save_data(data_db)
        await event.reply("✅ کانال اضافه شد" if lang == "fa" else "✅ Channel added")
        USER_STATE.pop(user_id, None)
        return
    
    # حذف کانال اجباری
    if step == "waiting_fc_remove":
        if not is_owner(user_id):
            USER_STATE.pop(user_id, None)
            return
        if not text.strip():
            await event.reply("❌ ورودی نامعتبر" if lang == "fa" else "❌ Invalid input")
            return
        channel = text.strip()
        if not channel.startswith("@"):
            channel = "@" + channel
        data_db = load_data()
        data_db.setdefault("force_channels", [])
        if channel in data_db["force_channels"]:
            data_db["force_channels"].remove(channel)
            save_data(data_db)
        await event.reply("✅ کانال حذف شد" if lang == "fa" else "✅ Channel removed")
        USER_STATE.pop(user_id, None)
        return

# ==================== هندلر پیام‌های تلگرام ====================
async def telegram_message_handler(event, state, text, user_id, lang):
    step = state.get("step")
    
    # ورود پروکسی
    if step == "waiting_proxies":
        proxy_manager = ProxyManager(user_id)
        added = await proxy_manager.add_proxies(text)
        if added < 3:
            await event.reply(
                f"⚠️ فقط {added} پروکسی معتبر اضافه شد. حداقل ۳ پروکسی نیاز دارید.\n"
                "لطفاً دوباره پروکسی‌های خود را خط به خط وارد کنید:" if lang == "fa" else
                f"⚠️ Only {added} valid proxies added. You need at least 3 proxies.\n"
                "Please enter your proxies line by line again:"
            )
            return
        await event.reply(
            f"✅ {added} پروکسی با موفقیت ذخیره شد." if lang == "fa" else
            f"✅ {added} proxies saved successfully."
        )
        state["step"] = "count"
        sessions = state.get("sessions", [])
        if sessions:
            await event.reply(
                f"🔢 تعداد اکانت؟ (1-{len(sessions)})" if lang == "fa" else
                f"🔢 Number of accounts? (1-{len(sessions)})"
            )
        else:
            USER_STATE.pop(user_id, None)
            await event.reply("❌ خطا، لطفاً دوباره از منو انتخاب کنید." if lang == "fa" else "❌ Error, please select again from menu.")
        return
    
    # انتخاب ادمین برای افزودن اکانت
    if step == "select_admin":
        if not text.strip().isdigit() and text != "0":
            await event.reply("❌ آیدی نامعتبر" if lang == "fa" else "❌ Invalid ID")
            return
        if text == "0":
            target_admin = user_id
        else:
            target_admin = int(text)
        if target_admin != user_id and not is_admin(target_admin) and not is_owner(target_admin):
            await event.reply("❌ ادمین یافت نشد" if lang == "fa" else "❌ Admin not found")
            return
        state["target_admin"] = target_admin
        state["step"] = "phone"
        await event.reply("📱 شماره تلفن با + را وارد کنید" if lang == "fa" else "📱 Enter phone number with +")
        return
    
    # انتخاب ادمین برای حذف اکانت
    if step == "delete_select_admin":
        if not text.strip().isdigit():
            await event.reply("❌ آیدی نامعتبر" if lang == "fa" else "❌ Invalid ID")
            return
        target_admin = int(text)
        if target_admin != user_id and not is_admin(target_admin) and not is_owner(target_admin):
            await event.reply("❌ ادمین یافت نشد" if lang == "fa" else "❌ Admin not found")
            return
        state["target_admin"] = target_admin
        state["step"] = "delete_phone"
        await event.reply("📱 شماره تلفن برای حذف را وارد کنید" if lang == "fa" else "📱 Enter phone number to delete")
        return
    
    # ورود شماره تلفن
    if step == "phone":
        if not await validate_phone_number(text):
            await event.reply("❌ شماره نامعتبر است" if lang == "fa" else "❌ Invalid phone number")
            return
        state["phone"] = text
        client = TelegramClient(StringSession(), API_ID, API_HASH)
        await client.connect()
        try:
            await client.send_code_request(text)
            state["client"] = client
            state["step"] = "code"
            await event.reply("✅ کد ارسال شد. کد را وارد کنید" if lang == "fa" else "✅ Code sent. Enter code")
        except Exception as e:
            await event.reply(f"❌ خطا: {str(e)[:100]}")
            await client.disconnect()
            USER_STATE.pop(user_id, None)
        return
    
    # ورود کد تایید
    if step == "code":
        if len(text) < 4:
            await event.reply("❌ کد نامعتبر" if lang == "fa" else "❌ Invalid code")
            return
        client = state.get("client")
        phone = state.get("phone")
        target_admin = state.get("target_admin", user_id)
        if not client or not phone:
            USER_STATE.pop(user_id, None)
            return
        try:
            await client.sign_in(phone, text)
            session_str = client.session.save()
            phone_clean = phone.replace('+', '').replace(' ', '')
            filename = f"{phone_clean}.session"
            path = os.path.join(SHARED_SESSIONS_DIR, filename)
            with open(path, "w", encoding='utf-8') as f:
                f.write(session_str)
            clear_user_cache()
            me = await client.get_me()
            profile = f"✅ اکانت اضافه شد\n👤 {me.first_name or ''} {me.last_name or ''}\n📱 {phone}\n🆔 {me.id}\n@{me.username or 'None'}"
            await event.reply(profile)
            await client.disconnect()
            USER_STATE.pop(user_id, None)
        except errors.SessionPasswordNeededError:
            state["step"] = "password"
            await event.reply("🔐 رمز دو مرحله‌ای را وارد کنید" if lang == "fa" else "🔐 Enter 2FA password")
        except errors.PhoneCodeInvalidError:
            await event.reply("❌ کد اشتباه است" if lang == "fa" else "❌ Invalid code")
        except errors.PhoneCodeExpiredError:
            await event.reply("❌ کد منقضی شده" if lang == "fa" else "❌ Code expired")
            await client.disconnect()
            USER_STATE.pop(user_id, None)
        except Exception as e:
            await event.reply(f"❌ خطا: {str(e)[:100]}")
            await client.disconnect()
            USER_STATE.pop(user_id, None)
        return
    
    # ورود رمز دو مرحله‌ای
    if step == "password":
        if not text:
            await event.reply("❌ رمز نامعتبر" if lang == "fa" else "❌ Invalid password")
            return
        client = state.get("client")
        phone = state.get("phone")
        if not client:
            USER_STATE.pop(user_id, None)
            return
        try:
            await client.sign_in(password=text)
            session_str = client.session.save()
            phone_clean = phone.replace('+', '').replace(' ', '')
            filename = f"{phone_clean}.session"
            path = os.path.join(SHARED_SESSIONS_DIR, filename)
            with open(path, "w", encoding='utf-8') as f:
                f.write(session_str)
            clear_user_cache()
            me = await client.get_me()
            profile = f"✅ اکانت اضافه شد\n👤 {me.first_name or ''} {me.last_name or ''}\n📱 {phone}\n🆔 {me.id}\n@{me.username or 'None'}"
            await event.reply(profile)
            await client.disconnect()
            USER_STATE.pop(user_id, None)
        except errors.PasswordHashInvalidError:
            await event.reply("❌ رمز اشتباه است" if lang == "fa" else "❌ Invalid password")
        except Exception as e:
            await event.reply(f"❌ خطا: {str(e)[:100]}")
            await client.disconnect()
            USER_STATE.pop(user_id, None)
        return
    
    # حذف شماره تلفن
    if step == "delete_phone":
        if not text.startswith('+'):
            await event.reply("❌ شماره باید با + شروع شود" if lang == "fa" else "❌ Number must start with +")
            return
        phone_clean = text.replace('+', '').replace(' ', '')
        deleted = False
        for f in os.listdir(SHARED_SESSIONS_DIR):
            if f == f"{phone_clean}.session":
                os.remove(os.path.join(SHARED_SESSIONS_DIR, f))
                deleted = True
        if deleted:
            clear_user_cache()
            await event.reply(f"✅ اکانت {text} حذف شد" if lang == "fa" else f"✅ Account {text} deleted")
        else:
            await event.reply(f"❌ اکانتی یافت نشد" if lang == "fa" else f"❌ No account found")
        USER_STATE.pop(user_id, None)
        return
    
    # تعداد اکانت‌ها
    if step == "count":
        try:
            count = int(text)
            sessions = state["sessions"]
            if count < 1 or count > len(sessions):
                await event.reply(f"❌ عدد بین 1 تا {len(sessions)}" if lang == "fa" else f"❌ Between 1 and {len(sessions)}")
                return
            state["count"] = count
            state["selected_sessions"] = sessions[:count]
            op_type = state.get("type")
            if op_type in ["report_post"]:
                state["step"] = "post_links"
                await event.reply("🔗 لینک پست‌ها را ارسال کنید (1 تا 6 لینک)" if lang == "fa" else "🔗 Enter post links (1-6)")
            else:
                state["step"] = "target"
                await event.reply("🔗 لینک/یوزرنیم هدف را وارد کنید" if lang == "fa" else "🔗 Enter target link/username")
        except ValueError:
            await event.reply("❌ عدد وارد کنید" if lang == "fa" else "❌ Enter a number")
        return
    
    # لینک پست‌ها
    if step == "post_links":
        post_links = [link.strip() for link in text.split('\n') if link.strip()]
        if not post_links or len(post_links) > 6:
            await event.reply("❌ بین 1 تا 6 لینک" if lang == "fa" else "❌ 1 to 6 links")
            return
        for link in post_links:
            if not await validate_post_link(link):
                await event.reply(f"❌ لینک نامعتبر: {link}" if lang == "fa" else f"❌ Invalid link: {link}")
                return
        state["post_links"] = post_links
        state["step"] = "select_reason"
        await event.reply("📝 دلیل ریپورت را انتخاب کنید:", buttons=reason_keyboard())
        return
    
    # هدف ریپورت
    if step == "target":
        target = text.strip()
        if not target:
            await event.reply("❌ خالی نباشد" if lang == "fa" else "❌ Not empty")
            return
        state["target"] = target
        if state.get("type") == "manual_report":
            state["step"] = "custom_reason"
            await event.reply("📝 متن گزارش سفارشی (حداقل 4 خط)" if lang == "fa" else "📝 Custom report message (min 4 lines)")
        else:
            state["step"] = "select_reason"
            await event.reply("📝 دلیل ریپورت را انتخاب کنید:", buttons=reason_keyboard())
        return
    
    # تعداد ریپورت هر اکانت
    if step == "count_per_account":
        try:
            cnt = int(text)
            if cnt < 1 or cnt > 50:
                await event.reply("❌ عدد بین 1 تا 50" if lang == "fa" else "❌ Between 1 and 50")
                return
            state["count_per_account"] = cnt
            state["step"] = "custom_reason"
            await event.reply("📝 متن دلخواه (یا /skip)" if lang == "fa" else "📝 Custom message (or /skip)")
        except ValueError:
            await event.reply("❌ عدد وارد کنید" if lang == "fa" else "❌ Enter a number")
        return
    
    # متن سفارشی
    if step == "custom_reason":
        if text == "/skip":
            reason_key = state.get("reason_key", "1")
            text = REPORT_REASONS[reason_key][2]
        state["custom_reason"] = text
        await execute_report_operation(event, state, user_id, lang)
        USER_STATE.pop(user_id, None)
        return

# ==================== اجرای عملیات ریپورت ====================
async def execute_report_operation(event, state, user_id, lang):
    sessions = state["selected_sessions"]
    op_type = state.get("type")
    reason_key = state.get("reason_key", "1")
    reason_name, reason_obj, default_msg = REPORT_REASONS[reason_key]
    custom_msg = state.get("custom_reason", default_msg)
    count_per_account = state.get("count_per_account", 1)
    proxy_manager = state.get("proxy_manager")
    rotation = state.get("rotation", False)
    reason_keys = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
    reason_index = 0
    
    total_success = 0
    total_fail = 0
    errors_list = []
    invalid_sessions = []  # لیست سشن‌های خراب برای حذف
    
    await event.reply("🚀 شروع عملیات ریپورت..." if lang == "fa" else "🚀 Starting report operation...")
    
    if op_type == "report_post":
        post_links = state.get("post_links", [])
        target_links = post_links
    else:
        target_links = [state.get("target", "")]
    
    semaphore = asyncio.Semaphore(MAX_CONCURRENT)
    
    async def limited(acc):
        nonlocal total_success, total_fail, reason_index
        admin_id_str, filename = acc
        path = os.path.join(SHARED_SESSIONS_DIR, filename)
        
        try:
            # ===== بررسی وجود فایل سشن =====
            if not os.path.exists(path):
                invalid_sessions.append(filename)
                return
            
            with open(path, 'r') as f:
                session_str = f.read().strip()
            
            if not session_str:
                invalid_sessions.append(filename)
                try:
                    os.remove(path)
                except:
                    pass
                return
            
            account_id = f"{admin_id_str}_{filename}"
            
            # ===== اتصال با پروکسی =====
            if proxy_manager:
                proxy = await proxy_manager.get_valid_proxy(account_id)
                if proxy:
                    client = TelegramClient(StringSession(session_str), API_ID, API_HASH, proxy=proxy)
                else:
                    client = TelegramClient(StringSession(session_str), API_ID, API_HASH)
            else:
                client = TelegramClient(StringSession(session_str), API_ID, API_HASH)
            
            try:
                await client.connect()
            except Exception as e:
                # ===== خطا در اتصال =====
                total_fail += 1
                errors_list.append(f"{filename}: Connection error - {str(e)[:30]}")
                invalid_sessions.append(filename)
                try:
                    os.remove(path)
                except:
                    pass
                return
            
            # ===== بررسی احراز هویت =====
            try:
                if not await client.is_user_authorized():
                    total_fail += 1
                    errors_list.append(f"{filename}: Not authorized")
                    invalid_sessions.append(filename)
                    try:
                        os.remove(path)
                    except:
                        pass
                    await client.disconnect()
                    return
            except Exception as e:
                total_fail += 1
                errors_list.append(f"{filename}: Auth error - {str(e)[:30]}")
                invalid_sessions.append(filename)
                try:
                    os.remove(path)
                except:
                    pass
                await client.disconnect()
                return
            
            # ===== دریافت اطلاعات اکانت برای لاگ =====
            try:
                me = await client.get_me()
                account_info = f"{me.first_name or ''} {me.last_name or ''} ({me.id})"
            except:
                account_info = filename
            
            print(f"✅ اکانت {account_info} متصل شد")
            
            for target in target_links:
                try:
                    # ===== دریافت entity هدف =====
                    if target.startswith("@"):
                        entity = await client.get_entity(target)
                    else:
                        clean = target.replace("https://t.me/", "").replace("t.me/", "")
                        if op_type == "report_post":
                            parts = clean.split("/")
                            if len(parts) >= 2:
                                channel = parts[0]
                                entity = await client.get_entity("@" + channel if not channel.startswith("@") else channel)
                            else:
                                continue
                        else:
                            entity = await client.get_entity(clean)
                    
                    # ===== عضویت در کانال (در صورت نیاز) =====
                    if op_type in ["report", "report_post"]:
                        try:
                            await join_channel_with_approval(client, entity, filename)
                        except Exception as e:
                            print(f"⚠️ عضویت ناموفق: {filename} - {str(e)[:30]}")
                    
                    # ===== حلقه ریپورت با چرخش و تایم رندوم =====
                    for i in range(count_per_account):
                        # ===== چرخش دلایل =====
                        if rotation:
                            current_reason_key = reason_keys[reason_index % len(reason_keys)]
                            reason_index += 1
                            r_name, r_obj, r_msg = REPORT_REASONS[current_reason_key]
                            custom_msg = r_msg
                            reason_obj = r_obj
                            reason_name = r_name
                        
                        try:
                            # ===== ارسال ریپورت =====
                            await client(ReportPeerRequest(peer=entity, reason=reason_obj, message=custom_msg))
                            total_success += 1
                            print(f"✅ ریپورت موفق: {filename} - شماره {i+1}/{count_per_account}")
                            
                        except errors.FloodWaitError as e:
                            total_fail += 1
                            wait_time = min(e.seconds, 60)
                            errors_list.append(f"{filename}: Flood wait {e.seconds}s")
                            print(f"⚠️ Flood wait: {filename} - {e.seconds}s")
                            
                            # ===== اگر فلود زیاد بود، اکانت را متوقف کن =====
                            if e.seconds > 60:
                                break
                            
                            # ===== منتظر بمان و ادامه بده =====
                            await asyncio.sleep(wait_time)
                            continue
                            
                        except errors.RPCError as e:
                            total_fail += 1
                            error_msg = str(e)
                            errors_list.append(f"{filename}: RPC - {error_msg[:30]}")
                            print(f"❌ RPC Error: {filename} - {error_msg[:30]}")
                            
                            # ===== سشن نامعتبر =====
                            if "SESSION_INVALID" in error_msg or "AUTH_KEY_INVALID" in error_msg or "SESSION_REVOKED" in error_msg:
                                invalid_sessions.append(filename)
                                try:
                                    os.remove(path)
                                    print(f"🗑️ سشن نامعتبر حذف شد: {filename}")
                                except:
                                    pass
                                return
                            break
                            
                        except errors.UserDeactivatedError:
                            total_fail += 1
                            errors_list.append(f"{filename}: User deactivated")
                            invalid_sessions.append(filename)
                            try:
                                os.remove(path)
                                print(f"🗑️ اکانت غیرفعال حذف شد: {filename}")
                            except:
                                pass
                            return
                            
                        except errors.UserDeactivatedBanError:
                            total_fail += 1
                            errors_list.append(f"{filename}: Account banned")
                            invalid_sessions.append(filename)
                            try:
                                os.remove(path)
                                print(f"🗑️ اکانت بن شده حذف شد: {filename}")
                            except:
                                pass
                            return
                            
                        except Exception as e:
                            total_fail += 1
                            error_msg = str(e)
                            errors_list.append(f"{filename}: {error_msg[:50]}")
                            print(f"❌ Error: {filename} - {error_msg[:30]}")
                            
                            # ===== خطای پروکسی =====
                            if proxy_manager and ("proxy" in error_msg.lower() or "connection" in error_msg.lower()):
                                await proxy_manager.mark_failed(account_id, proxy)
                            
                            # ===== خطای سشن =====
                            if "SESSION" in error_msg.upper():
                                invalid_sessions.append(filename)
                                try:
                                    os.remove(path)
                                    print(f"🗑️ سشن مشکل‌دار حذف شد: {filename}")
                                except:
                                    pass
                                return
                            break
                        
                        # ===== تاخیر رندوم بین 4 تا 8 ثانیه =====
                        if i < count_per_account - 1:
                            delay = random.uniform(4, 8)
                            await asyncio.sleep(delay)
                
                except errors.ChannelPrivateError:
                    total_fail += 1
                    errors_list.append(f"{filename}: Channel is private")
                    print(f"❌ کانال خصوصی: {filename}")
                    
                except errors.ChannelInvalidError:
                    total_fail += 1
                    errors_list.append(f"{filename}: Invalid channel")
                    print(f"❌ کانال نامعتبر: {filename}")
                    
                except errors.UsernameInvalidError:
                    total_fail += 1
                    errors_list.append(f"{filename}: Invalid username")
                    print(f"❌ یوزرنیم نامعتبر: {filename}")
                    
                except Exception as e:
                    total_fail += 1
                    error_msg = str(e)
                    errors_list.append(f"{filename}: {error_msg[:50]}")
                    print(f"❌ Error in target: {filename} - {error_msg[:30]}")
                    
                    if proxy_manager and ("proxy" in error_msg.lower() or "connection" in error_msg.lower()):
                        await proxy_manager.mark_failed(account_id, proxy)
            
            # ===== قطع اتصال =====
            try:
                await client.disconnect()
            except:
                pass
            
            # ===== تاخیر بین اکانت‌ها =====
            await asyncio.sleep(random.uniform(2, 5))
        
        except FileNotFoundError:
            invalid_sessions.append(filename)
            
        except Exception as e:
            total_fail += 1
            error_msg = str(e)
            errors_list.append(f"{filename}: {error_msg[:50]}")
            print(f"❌ Critical error: {filename} - {error_msg[:30]}")
            
            # ===== اگر خطای سشن بود، حذف کن =====
            if "SESSION" in error_msg.upper():
                invalid_sessions.append(filename)
                try:
                    os.remove(path)
                    print(f"🗑️ سشن خراب حذف شد: {filename}")
                except:
                    pass
    
    # ===== اجرای تسک‌ها =====
    tasks = []
    for admin_id_str, filename in sessions:
        tasks.append(limited((admin_id_str, filename)))
    await asyncio.gather(*tasks)
    
    # ===== حذف سشن‌های خراب =====
    if invalid_sessions:
        try:
            for filename in invalid_sessions:
                path = os.path.join(SHARED_SESSIONS_DIR, filename)
                if os.path.exists(path):
                    os.remove(path)
            clear_user_cache()
            print(f"🗑️ {len(invalid_sessions)} سشن خراب حذف شد")
        except Exception as e:
            print(f"⚠️ خطا در حذف سشن‌ها: {e}")
    
    # ===== نمایش نتیجه =====
    result = (
        f"📊 عملیات ریپورت پایان یافت\n\n"
        f"🎯 هدف: {state.get('target', 'Multiple posts')}\n"
        f"📝 دلیل: {reason_name}\n"
        f"👥 اکانت‌ها: {len(sessions)}\n"
        f"🔢 ریپورت/اکانت: {count_per_account}\n"
        f"✅ موفق: {total_success}\n"
        f"❌ ناموفق: {total_fail}"
        if lang == "fa" else
        f"📊 Report Operation Complete\n\n"
        f"🎯 Target: {state.get('target', 'Multiple posts')}\n"
        f"📝 Reason: {reason_name}\n"
        f"👥 Accounts: {len(sessions)}\n"
        f"🔢 Reports/Account: {count_per_account}\n"
        f"✅ Success: {total_success}\n"
        f"❌ Failed: {total_fail}"
    )
    
    if invalid_sessions:
        if lang == "fa":
            result += f"\n\n🗑️ {len(invalid_sessions)} سشن خراب حذف شد"
        else:
            result += f"\n\n🗑️ {len(invalid_sessions)} invalid sessions removed"
    
    if errors_list:
        if lang == "fa":
            result += f"\n\n⚠️ خطاها ({len(errors_list)} مورد):\n" + "\n".join(errors_list[:10])
        else:
            result += f"\n\n⚠️ Errors ({len(errors_list)}):\n" + "\n".join(errors_list[:10])
    
    await event.reply(result)

# ==================== اجرای ربات ====================
async def main():
    try:
        # روش صحیح: ایجاد کلاینت و سپس start کردن با await
        bot = TelegramClient(StringSession(), API_ID, API_HASH)
        await bot.start(bot_token=BOT_TOKEN)
        
        # ثبت هندلرها
        bot.add_event_handler(start_handler, events.NewMessage(pattern='/start'))
        bot.add_event_handler(callback_handler, events.CallbackQuery())
        bot.add_event_handler(message_handler, events.NewMessage(func=lambda e: not e.text.startswith('/')))
        
        print("✅ ربات با موفقیت راه‌اندازی شد!")
        print(f"📊 آمار: {len(get_user_sessions(0))} سشن در پوشه اشتراکی")
        print("🤖 منتظر پیام‌ها هستم...")
        
        await bot.run_until_disconnected()
    
    except Exception as e:
        logger.error(f"Error in main: {e}")
        print(f"❌ خطا: {e}")

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