from aiogram import Router, F, Bot
from aiogram.filters import CommandStart, StateFilter, Command
from aiogram.filters.command import CommandObject
from aiogram.types import Message, CallbackQuery, ReactionTypeEmoji, InputRichMessage, ChatJoinRequest
from aiogram.fsm.context import FSMContext
from states.forms import Registration, ChatSession, UserVerification, SupportSession, AsyncChat, DisputeChat
import re

from utils import texts
from utils.logger import get_logger
from keyboards import inline, reply
from database import db
from config import ADMIN_IDS

logger = get_logger(__name__)

def contains_forbidden_info(text: str) -> bool:
    if not text:
        return False
    from utils.ai_moderation import moderate_text
    is_clean, _ = moderate_text(text)
    return not is_clean

router = Router()

async def check_and_clear_chat_session(state: FSMContext, bot: Bot):
    current_state = await state.get_state()
    if current_state == ChatSession.in_chat.state:
        data = await state.get_data()
        target_id = data.get("target_id")
        if target_id:
            from aiogram.fsm.storage.base import StorageKey
            bot_id = bot.id
            target_key = StorageKey(bot_id=bot_id, chat_id=target_id, user_id=target_id)
            await state.storage.set_state(target_key, None)
            await state.storage.set_data(target_key, {})
            
            try:
                target_user = await db.get_user(target_id)
                target_is_admin = target_id in ADMIN_IDS
                target_kb = reply.client_main_menu(is_admin=target_is_admin) if target_user['role'] == 'client' else reply.freelancer_main_menu(is_admin=target_is_admin)
                await bot.send_message(
                    target_id,
                    "❌ <b>گفتگو توسط طرف مقابل قطع شد.</b>\nبه منوی اصلی بازگشتید.",
                    reply_markup=target_kb,
                    parse_mode="HTML"
                )
            except Exception:
                pass

@router.message(F.text == texts.BTN_END_CHAT, StateFilter("*"))
async def end_chat_handler(message: Message, state: FSMContext, bot: Bot, db_user):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    await message.answer("❌ <b>گفتگو خاتمه یافت.</b>", parse_mode="HTML")
    await send_main_menu(message, db_user)

@router.message(F.text == texts.BTN_BACK, StateFilter("*"))
async def cancel_any_fsm(message: Message, state: FSMContext, bot: Bot, db_user):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    await send_main_menu(message, db_user)

@router.message(F.text == texts.BTN_POST_PROJECT, StateFilter("*"))
async def global_post_project(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.client import start_project_creation
    await start_project_creation(message, state, db_user, bot)

@router.message(F.text == texts.BTN_MY_PROJECTS, StateFilter("*"))
async def global_my_projects(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.client import my_projects
    await my_projects(message, db_user)

@router.message(F.text == texts.BTN_FIND_PROJECTS, StateFilter("*"))
async def global_find_projects(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.freelancer import find_projects
    await find_projects(message, state)

@router.message(F.text == texts.BTN_MY_BIDS, StateFilter("*"))
async def global_my_bids(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.freelancer import my_bids
    await my_bids(message)

@router.message(F.text == texts.BTN_WALLET, StateFilter("*"))
async def global_wallet(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.client import refresh_wallet_ui
    await refresh_wallet_ui(message, message.from_user.id)

@router.message(F.text == texts.BTN_VIP, StateFilter("*"))
async def global_vip(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.client import show_vip
    await show_vip(message, db_user)

@router.message(F.text == texts.BTN_PROFILE, StateFilter("*"))
async def global_profile(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.freelancer import show_profile
    await show_profile(message, db_user)

@router.message(F.text == texts.BTN_ADMIN, StateFilter("*"))
async def global_admin(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    from handlers.admin import admin_panel
    await admin_panel(message)

@router.message(F.text == texts.BTN_SWITCH_TO_FREELANCER, StateFilter("*"))
async def switch_to_freelancer_handler(message: Message, state: FSMContext, bot: Bot, db_user):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    try: await message.react([ReactionTypeEmoji(emoji="🔄")])
    except: pass
    await db.set_user_role(message.from_user.id, "freelancer")
    updated_user = await db.get_user(message.from_user.id)
    await message.answer("🔄 نقش شما با موفقیت به <b>فریلنسر</b> تغییر یافت.", parse_mode="HTML")
    await send_main_menu(message, updated_user)

@router.message(F.text == texts.BTN_SWITCH_TO_CLIENT, StateFilter("*"))
async def switch_to_client_handler(message: Message, state: FSMContext, bot: Bot, db_user):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    try: await message.react([ReactionTypeEmoji(emoji="🔄")])
    except: pass
    await db.set_user_role(message.from_user.id, "client")
    updated_user = await db.get_user(message.from_user.id)
    await message.answer("🔄 نقش شما با موفقیت به <b>کارفرما</b> تغییر یافت.", parse_mode="HTML")
    await send_main_menu(message, updated_user)

@router.message(F.text == "👥 زیرمجموعه‌گیری", StateFilter("*"))
async def referral_menu_handler(message: Message, state: FSMContext, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    try: await message.react([ReactionTypeEmoji(emoji="👥")])
    except: pass
    stats = await db.get_referral_stats(message.from_user.id)
    bot_info = await message.bot.get_me()
    ref_link = f"https://t.me/{bot_info.username}?start=ref_{message.from_user.id}"
    invite_connects = await db.get_setting_int("invite_connects", 5)
    
    html_content = (
        f"<h1>👥 سیستم کسب درآمد و زیرمجموعه‌گیری</h1>"
        "<hr/>"
        "<h3>🚀 با دعوت از دوستان خود به ایکس‌لنسر، کانکت (بید) رایگان هدیه بگیرید!</h3>"
        f"<p>به ازای هر کاربری که با لینک دعوت شما عضو ربات شود، تعداد <b>{invite_connects} کانکت (بید)</b> به صورت آنی به موجودی شما افزوده می‌شود.</p>"
        "<br/>"
        "<table bordered striped>"
        f"  <tr><th>📊 تعداد کل دعوت‌شده‌ها</th><td><b>{stats['count']}</b> نفر</td></tr>"
        f"  <tr><th>🎁 کل کانکت‌های هدیه دریافتی</th><td><b>{stats['count'] * invite_connects}</b> کانکت</td></tr>"
        "</table>"
        "<br/>"
        "<h3>🔗 لینک دعوت اختصاصی شما:</h3>"
        f"<code>{ref_link}</code>"
        "<br/>"
        "<p><i>(لینک بالا را کپی کرده و برای دوستان خود بفرستید)</i></p>"
    )
    rich_msg = InputRichMessage(html=html_content)
    await bot.send_rich_message(chat_id=message.chat.id, rich_message=rich_msg)

@router.message(F.text == texts.BTN_SUPPORT, StateFilter("*"))
async def start_support(message: Message, state: FSMContext, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    try: await message.react([ReactionTypeEmoji(emoji="📞")])
    except: pass
    
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    builder = InlineKeyboardBuilder()
    builder.button(text="📖 راهنمای استفاده و سوالات متداول", callback_data="support_faq")
    builder.button(text="🎫 ثبت تیکت پشتیبانی", callback_data="support_submit_ticket")
    builder.adjust(1)
    
    html_menu = (
        "<h1>📞 مرکز پشتیبانی و راهنمایی ایکس‌لنسر</h1>"
        "<hr/>"
        "<p>به بخش پشتیبانی خوش آمدید. لطفاً یکی از گزینه‌های زیر را انتخاب کنید:</p>"
        "<br/>"
        "<blockquote>💡 پیشنهاد می‌کنیم قبل از ثبت تیکت، بخش <b>راهنما و سوالات متداول</b> را مطالعه کنید. اکثر سوالات کارفرمایان و فریلنسرها در آنجا پاسخ داده شده است.</blockquote>"
    )
    rich_msg = InputRichMessage(html=html_menu)
    await bot.send_rich_message(chat_id=message.chat.id, rich_message=rich_msg, reply_markup=builder.as_markup())

async def forward_message_with_quote(bot: Bot, message: Message, target_id: int, prefix_text: str = None):
    quoted_text = ""
    if message.quote:
        quoted_text = message.quote.text
    elif message.reply_to_message:
        quoted_text = message.reply_to_message.text or message.reply_to_message.caption or "پیوست رسانه‌ای"
        
    if quoted_text:
        if len(quoted_text) > 150:
            quoted_text = quoted_text[:147] + "..."
        quote_html = f"<blockquote expandable><b>نقل‌قول:</b>\n{quoted_text}</blockquote>\n\n"
        if prefix_text:
            quote_html = prefix_text + "\n" + quote_html
            
        msg_text = message.html_text or ""
        
        try:
            if message.text:
                await bot.send_message(target_id, quote_html + msg_text, parse_mode="HTML")
            elif message.photo:
                await bot.send_photo(target_id, message.photo[-1].file_id, caption=quote_html + msg_text, parse_mode="HTML")
            elif message.document:
                await bot.send_document(target_id, message.document.file_id, caption=quote_html + msg_text, parse_mode="HTML")
            elif message.video:
                await bot.send_video(target_id, message.video.file_id, caption=quote_html + msg_text, parse_mode="HTML")
            elif message.voice:
                await bot.send_voice(target_id, message.voice.file_id, caption=quote_html + msg_text, parse_mode="HTML")
            elif message.audio:
                await bot.send_audio(target_id, message.audio.file_id, caption=quote_html + msg_text, parse_mode="HTML")
            else:
                if prefix_text:
                    await bot.send_message(target_id, prefix_text, parse_mode="HTML")
                await message.copy_to(chat_id=target_id)
        except Exception as e:
            raise e
    else:
        if prefix_text:
            await bot.send_message(target_id, prefix_text, parse_mode="HTML")
        await message.copy_to(chat_id=target_id)

@router.message(ChatSession.in_chat)
async def chat_message_forwarder(message: Message, state: FSMContext, bot: Bot):
    data = await state.get_data()
    target_id = data.get("target_id")
    is_fulltime = data.get("is_fulltime", False)
    
    if not target_id:
        await state.clear()
        db_user = await db.get_user(message.from_user.id)
        await message.answer("❌ خطا: گفتگوی فعال یافت نشد. به منوی اصلی بازگشتید.")
        await send_main_menu(message, db_user)
        return

    content_text = message.text or message.caption or ""
    if not is_fulltime and contains_forbidden_info(content_text):
        try:
            await message.delete()
        except:
            pass
        await message.answer(texts.CHAT_BLOCKED_MSG, parse_mode="HTML")
        return

    try:
        await forward_message_with_quote(bot, message, target_id)
    except Exception as e:
        await message.answer("❌ ارسال پیام با خطا مواجه شد. ممکن است طرف مقابل ربات را بلاک کرده باشد.")

@router.callback_query(F.data.startswith("user_enter_dispute_chat_"))
async def user_enter_dispute_chat(callback: CallbackQuery, state: FSMContext, bot: Bot):
    project_id = int(callback.data.split("_")[-1])
    project = await db.get_project(project_id)
    if not project:
        return await callback.answer("پروژه یافت نشد.", show_alert=True)
        
    # Ensure project status is disputed
    if project['status'] != 'disputed':
        return await callback.answer("این پروژه در وضعیت شکایت/داوری نیست.", show_alert=True)
        
    user_id = callback.from_user.id
    # Ensure user is client or chosen freelancer
    if user_id != project['client_id'] and user_id != project['chosen_freelancer_id']:
        return await callback.answer("شما دسترسی به این چت داوری را ندارید.", show_alert=True)
        
    # Set FSM state
    await state.set_state(DisputeChat.in_chat)
    await state.update_data(project_id=project_id)
    
    # Ensure dispute chat record exists
    await db.create_dispute_chat(project_id, project['client_id'], project['chosen_freelancer_id'])
    
    welcome_text = (
        f"⚖️ <b>شما وارد چت داوری پروژه #{project_id} شدید.</b>\n\n"
        f"پیام‌های متنی و رسانه‌ای شما به صورت خودکار برای سایر اعضا (طرف مقابل پروژه و داور ادمین) ارسال می‌شود.\n"
        f"مدارک و توضیحات خود را در این بخش ارسال کنید.\n"
        f"برای خروج از چت از دکمه زیر استفاده کنید:"
    )
    
    from keyboards.reply import dispute_chat_keyboard
    await callback.message.answer(
        welcome_text,
        reply_markup=dispute_chat_keyboard(),
        parse_mode="HTML"
    )
    await callback.answer("وارد چت داوری شدید.")

@router.message(DisputeChat.in_chat)
async def dispute_message_forwarder(message: Message, state: FSMContext, bot: Bot):
    # If the user wants to leave
    if message.text == "خروج از چت داوری ⚖️":
        await state.clear()
        user_id = message.from_user.id
        db_user = await db.get_user(user_id)
        await message.answer("⚖️ شما از چت داوری خارج شدید.")
        if db_user:
            await send_main_menu(message, db_user)
        return

    data = await state.get_data()
    project_id = data.get("project_id")
    if not project_id:
        await state.clear()
        user_id = message.from_user.id
        db_user = await db.get_user(user_id)
        await message.answer("❌ خطا: گفتگوی فعال یافت نشد. به منوی اصلی بازگشتید.")
        if db_user:
            await send_main_menu(message, db_user)
        return

    # Fetch chat info
    chat_info = await db.get_dispute_chat(project_id)
    if not chat_info:
        await message.answer("❌ خطا: اطلاعات چت داوری یافت نشد.")
        return

    client_id = chat_info['client_id']
    freelancer_id = chat_info['freelancer_id']
    admin_id = chat_info['admin_id']

    sender_id = message.from_user.id

    # Determine sender label
    if sender_id == client_id:
        label = "👔 <b>کارفرما:</b>"
        recipients = [r for r in [freelancer_id, admin_id] if r and r != sender_id]
    elif sender_id == freelancer_id:
        label = "💻 <b>فریلنسر:</b>"
        recipients = [r for r in [client_id, admin_id] if r and r != sender_id]
    elif sender_id in ADMIN_IDS or sender_id == admin_id:
        label = "🛡️ <b>داور (ادمین):</b>"
        recipients = [r for r in [client_id, freelancer_id] if r and r != sender_id]
    else:
        # Fallback just in case
        label = "👤 <b>کاربر ناشناس:</b>"
        recipients = [r for r in [client_id, freelancer_id, admin_id] if r and r != sender_id]

    # Forward to all recipients
    for recipient in recipients:
        try:
            await forward_message_with_quote(bot, message, recipient, prefix_text=label)
        except Exception as e:
            # We can log or notify sender, but continue to other recipients
            pass

# ── Invoice Helper ──────────────────────────────────────────────────

async def send_invoice_to_parties(
    bot: Bot,
    project_id: int,
    project_title: str,
    client_id: int,
    client_name: str,
    freelancer_id: int,
    freelancer_name: str,
    amount: int,
    commission: int,
    payout: int,
    commission_pct: int,
    is_refund: bool = False,
    milestone_title: str = None,
    milestone_id: int = None,
):
    """Generate and send Farsi invoice PDF to both parties."""
    from utils.pdf_invoice import generate_farsi_invoice_pdf
    from aiogram.types import FSInputFile
    
    filepath = await generate_farsi_invoice_pdf(
        project_id=project_id,
        project_title=project_title,
        client_id=client_id,
        client_name=client_name,
        freelancer_id=freelancer_id,
        freelancer_name=freelancer_name,
        amount=amount,
        commission=commission,
        payout=payout,
        commission_pct=commission_pct,
        is_refund=is_refund,
        milestone_title=milestone_title,
        milestone_id=milestone_id,
    )
    
    if not filepath:
        return
    
    caption = (
        f"📄 <b>{'رسید رسمی استرداد وجه' if is_refund else 'فاکتور رسمی تسویه‌حساب'} پرداخت امن</b>\n\n"
        f"📌 پروژه: <b>{project_title}</b>\n"
        f"🆔 شناسه پروژه: <code>#{project_id}</code>\n"
        f"💰 مبلغ کل: <b>{amount:,} تومان</b>\n\n"
        f"فاکتور رسمی پرداخت امن پروژه شما صادر شد."
    )
    
    try:
        doc = FSInputFile(filepath)
        await bot.send_document(client_id, doc, caption=caption, parse_mode="HTML")
    except Exception:
        pass
    
    if freelancer_id and freelancer_id != 0:
        try:
            doc = FSInputFile(filepath)
            await bot.send_document(freelancer_id, doc, caption=caption, parse_mode="HTML")
        except Exception:
            pass
    
    # Clean up file after sending
    import os
    try:
        os.remove(filepath)
    except Exception:
        pass

# ── Jury Vote Handler ──────────────────────────────────────────────

@router.callback_query(F.data.startswith("jury_vote_"))
async def jury_vote_handler(callback: CallbackQuery, bot: Bot, state: FSMContext):
    # Parse: jury_vote_{pid}_{release|refund}
    parts = callback.data.split("_")
    vote_type = parts[-1]  # release or refund
    pid = int(parts[-2])
    juror_id = callback.from_user.id
    
    # Validate vote type
    if vote_type not in ('release', 'refund'):
        return await callback.answer("❌ رأی نامعتبر.", show_alert=True)
    
    # Check eligibility: juror should not be client or freelancer of this project
    project = await db.get_project(pid)
    if not project:
        return await callback.answer("پروژه یافت نشد.", show_alert=True)
    
    if juror_id == project['client_id'] or juror_id == project['chosen_freelancer_id']:
        return await callback.answer("⚠️ شما طرف این پروژه هستید و مجاز به رأی‌دهی نیستید.", show_alert=True)
    
    # Cast vote
    result = await db.cast_jury_vote(pid, juror_id, vote_type)
    
    if result['status'] == 'already_voted':
        return await callback.answer("⚠️ شما قبلاً در این پرونده رأی داده‌اید.", show_alert=True)
    
    if result['status'] == 'voted':
        # Vote registered but quorum not met yet
        await callback.message.edit_text(
            (callback.message.text or callback.message.caption or "پرونده داوری") + f"\n\n✅ <b>رأی شما ثبت شد.</b> ({result['total_votes']}/{db.JURY_QUORUM} رأی)",
            parse_mode="HTML"
        )
        await callback.answer("✅ رأی شما با موفقیت ثبت شد!")
        return
    
    if result['status'] == 'resolved':
        if result['result'] is None:
            # Case was already resolved before this vote
            return await callback.answer("⚠️ این پرونده قبلاً حل‌وفصل شده است.", show_alert=True)
        
        # Quorum reached! Execute resolution
        verdict = result['result']
        
        import aiosqlite
        from config import DB_PATH, COMMISSION_FREE, COMMISSION_VIP
        
        # Fetch escrow info
        amount = 0
        freelancer_id = project['chosen_freelancer_id']
        client_id = project['client_id']
        try:
            async with aiosqlite.connect(DB_PATH) as conn:
                conn.row_factory = aiosqlite.Row
                async with conn.execute('SELECT amount FROM escrow WHERE project_id = ? AND status = "held"', (pid,)) as cursor:
                    row = await cursor.fetchone()
                    amount = row['amount'] if row else 0
        except Exception:
            pass
        
        # Execute verdict
        if verdict == 'release':
            commission_rate = await db.get_user_commission_rate(freelancer_id)
            commission_pct = int(commission_rate * 100)
            commission = int(amount * commission_rate)
            payout = amount - commission
            
            try:
                await db.complete_project(
                    project_id=pid,
                    freelancer_id=freelancer_id,
                    amount=amount,
                    commission_rate=commission_rate,
                    client_id=client_id,
                )
            except Exception:
                pass
        else:  # refund
            commission_pct = 0
            commission = 0
            payout = 0
            await db.refund_project(pid)
        
        # Send invoice to both parties
        client_user = await db.get_user(client_id)
        freelancer_user = await db.get_user(freelancer_id)
        client_name = (client_user['full_name'] or client_user['username'] or str(client_id)) if client_user else str(client_id)
        freelancer_name = (freelancer_user['full_name'] or freelancer_user['username'] or str(freelancer_id)) if freelancer_user else str(freelancer_id)
        
        await send_invoice_to_parties(
            bot=bot,
            project_id=pid,
            project_title=project['title'],
            client_id=client_id,
            client_name=client_name,
            freelancer_id=freelancer_id,
            freelancer_name=freelancer_name,
            amount=amount,
            commission=commission,
            payout=payout,
            commission_pct=commission_pct,
            is_refund=(verdict == 'refund'),
        )
        
        # Reward jurors who voted with the majority
        JURY_REWARD_BALANCE = 5000  # 5,000 Tomans
        JURY_REWARD_CONNECTS = 5
        votes = await db.get_jury_votes_for_case(pid)
        for v in votes:
            if v['vote'] == verdict:
                await db.update_balance(
                    v['juror_id'], JURY_REWARD_BALANCE, 'jury_reward',
                    f'پاداش داوری پروژه #{pid}'
                )
                await db.update_connects(
                    v['juror_id'], JURY_REWARD_CONNECTS, 'jury_reward',
                    f'پاداش کانکت داوری پروژه #{pid}'
                )
        
        # Clear dispute chat states for all participants
        from handlers.admin import clear_dispute_chat_states
        await clear_dispute_chat_states(bot, state.storage, pid, client_id, freelancer_id)
        
        # Notify parties
        verdict_fa = "آزادسازی وجه به فریلنسر ✅" if verdict == 'release' else "استرداد وجه به کارفرما ↩️"
        verdict_text = (
            f"⚖️🗳 <b>رأی نهایی هیئت داوران ایکس‌لنسر</b>\n\n"
            f"📌 پروژه #{pid}: <b>{project['title']}</b>\n"
            f"🗳 نتیجه: <b>{verdict_fa}</b>\n"
            f"💰 مبلغ: <b>{amount:,} تومان</b>\n\n"
            f"📄 فاکتور رسمی تسویه‌حساب به صورت PDF ارسال شد."
        )
        
        try:
            await bot.send_message(client_id, verdict_text, parse_mode="HTML")
        except Exception:
            pass
        try:
            await bot.send_message(freelancer_id, verdict_text, parse_mode="HTML")
        except Exception:
            pass
        
        # Notify admins
        recipients = await db.get_admin_recipients('disputes')
        for admin_id in recipients:
            try:
                jury_case = await db.get_jury_case(pid)
                await bot.send_message(
                    admin_id,
                    f"🗳 <b>نتیجه داوری هیئت‌منصفه — پروژه #{pid}</b>\n\n"
                    f"📌 پروژه: {project['title']}\n"
                    f"🔢 آرا: 🔓 آزادسازی: {jury_case['votes_release']} | ↩️ استرداد: {jury_case['votes_refund']}\n"
                    f"✅ رأی نهایی: <b>{verdict_fa}</b>",
                    parse_mode="HTML"
                )
            except Exception:
                pass
        
        # Update juror's message
        await callback.message.edit_text(
            (callback.message.text or callback.message.caption or "پرونده داوری") + f"\n\n✅ <b>رأی شما ثبت و پرونده حل شد!</b>\nنتیجه: {verdict_fa}\n🎁 پاداش ۵,۰۰۰ تومان + ۵ کانکت واریز شد.",
            parse_mode="HTML"
        )
        await callback.answer("✅ پرونده حل شد! پاداش واریز گردید.")
        return

@router.message(CommandStart())
async def cmd_start(message: Message, db_user, state: FSMContext, is_new_user: bool = False):
    await state.clear()
    try: await message.react([ReactionTypeEmoji(emoji="👋")])
    except: pass
    
    args = message.text.split()
    # Handle deep link start parameter
    if len(args) > 1:
        param = args[1]
        if param.startswith("project_"):
            try:
                project_id = int(param.split("_")[1])
                project = await db.get_project(project_id)
                if project:
                    bid_count = len(await db.get_bids_for_project(project_id))
                    client_stats = await db.get_client_rating_stats(project['client_id'])
                    if client_stats and client_stats['total_projects'] > 0:
                        client_rating_str = f"⭐️ {client_stats['avg_rating']:.1f} ({client_stats['total_projects']} همکاری)"
                    else:
                        client_rating_str = "جدید (بدون امتیاز)"
                        
                    card = texts.project_card(project)
                    card += f"\n👔 <b>اعتبار کارفرما:</b> {client_rating_str}"
                    card += f"\n👥 <b>تعداد پیشنهادها:</b> {bid_count}"
                    
                    role = db_user['role'] if db_user else 'freelancer'
                    if role == 'freelancer':
                        await message.answer(card, reply_markup=inline.project_action_keyboard(project_id), parse_mode="HTML")
                    else:
                        await message.answer(card, parse_mode="HTML")
                    return
            except Exception:
                pass
                
    # Referral link logic for new users
    if is_new_user:
        args = message.text.split()
        referrer_id = None
        if len(args) > 1 and args[1].startswith("ref_"):
            try:
                referrer_id = int(args[1].split("_")[1])
            except:
                pass
                
        if referrer_id and referrer_id != message.from_user.id:
            ref_user = await db.get_user(referrer_id)
            if ref_user:
                success = await db.save_referral(message.from_user.id, referrer_id)
                if success:
                    invite_connects = await db.get_setting_int("invite_connects", 5)
                    await db.update_connects(referrer_id, invite_connects, "referral", f"دعوت از کاربر ({message.from_user.full_name or message.from_user.id})")
                    try:
                        await message.bot.send_message(
                            referrer_id,
                            f"🎉 <b>پاداش زیرمجموعه‌گیری!</b>\n\n"
                            f"کاربر «{message.from_user.full_name}» با دعوت شما عضو شد و <b>{invite_connects} کانکت (بید)</b> هدیه به موجودی شما افزوده گردید.",
                            parse_mode="HTML"
                        )
                    except:
                        pass

    is_admin_user = message.from_user.id in __import__('config').ADMIN_IDS
    if not db_user or not db_user['role']:
        if is_admin_user:
            # Admins bypass registration
            await db.set_user_role(message.from_user.id, 'client')
            db_user = await db.get_user(message.from_user.id)
            return await send_main_menu(message, db_user)
            
        banner_file_id = await db.get_setting("welcome_banner_file_id", "")
        sent = False
        if banner_file_id:
            try:
                await message.answer_photo(
                    photo=banner_file_id,
                    caption=texts.ONBOARDING_1,
                    reply_markup=inline.onboarding_step_1(),
                    parse_mode="HTML"
                )
                sent = True
            except Exception:
                pass
        
        if not sent:
            import os
            from aiogram.types import FSInputFile
            banner_path = "assets/welcome_banner.png"
            if os.path.exists(banner_path):
                try:
                    photo_file = FSInputFile(banner_path)
                    sent_msg = await message.answer_photo(
                        photo=photo_file,
                        caption=texts.ONBOARDING_1,
                        reply_markup=inline.onboarding_step_1(),
                        parse_mode="HTML"
                    )
                    if sent_msg.photo:
                        new_file_id = sent_msg.photo[-1].file_id
                        await db.update_setting("welcome_banner_file_id", new_file_id)
                    sent = True
                except Exception:
                    pass
            
        if not sent:
            await message.answer(texts.ONBOARDING_1, reply_markup=inline.onboarding_step_1())
    else:
        await send_main_menu(message, db_user)

@router.callback_query(F.data.startswith("role_"))
async def process_role_selection(callback: CallbackQuery, state: FSMContext, db_user):
    role = callback.data.split("_")[1]
    await db.set_user_role(callback.from_user.id, role)
    try:
        await callback.message.delete()
    except Exception:
        pass
        
    await state.set_state(Registration.waiting_for_name)
    await callback.message.answer(
        "📝 <b>مرحله ۱ از ۲: نام و نام خانوادگی</b>\n\n"
        "لطفاً نام و نام خانوادگی واقعی خود را جهت نمایش در پروفایل وارد کنید:",
        parse_mode="HTML"
    )
    await callback.answer()

@router.message(Registration.waiting_for_name)
async def process_registration_name(message: Message, state: FSMContext):
    if len(message.text) < 3:
        return await message.answer("❌ نام وارد شده بسیار کوتاه است. لطفاً نام کامل خود را وارد کنید.")
        
    await db.update_user_full_name(message.from_user.id, message.text)
    
    await state.set_state(Registration.waiting_for_rules)
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    rules_kb = InlineKeyboardBuilder()
    rules_kb.button(text="✅ قوانین را می‌پذیرم", callback_data="accept_rules")
    rules_kb.adjust(1)
    
    await message.answer(
        "⚖️ <b>مرحله ۲ از ۲: پذیرش قوانین</b>\n\n"
        "۱. احترام به طرفین در چت‌ها الزامی است.\n"
        "۲. انجام هرگونه تراکنش مالی خارج از پلتفرم ممنوع است.\n"
        "۳. پلتفرم هیچ‌گونه مسئولیتی در قبال توافقات خارج از ربات ندارد.\n\n"
        "آیا با قوانین پلتفرم ایکس‌لنسر موافق هستید؟",
        reply_markup=rules_kb.as_markup(),
        parse_mode="HTML"
    )

@router.callback_query(Registration.waiting_for_rules, F.data == "accept_rules")
async def process_registration_rules(callback: CallbackQuery, state: FSMContext):
    await state.clear()
    try:
        await callback.message.delete()
    except:
        pass
        
    updated_user = await db.get_user(callback.from_user.id)
    await callback.message.answer("🎉 <b>ثبت‌نام شما با موفقیت تکمیل شد!</b>\nبه ایکس‌لنسر خوش آمدید.", parse_mode="HTML")
    await send_main_menu(callback.message, updated_user)
    await callback.answer()




@router.message(SupportSession.waiting_for_message)
async def process_support_message(message: Message, state: FSMContext, bot: Bot):
    if message.text == texts.BTN_BACK:
        await state.clear()
        # Fallthrough to back_handler
        return
        
    query_text = message.text or message.caption or "رسانه/فایل ارسال شده است."
    try: await message.react([ReactionTypeEmoji(emoji="📨")])
    except: pass
    ticket_id = await db.create_support_ticket(message.from_user.id, query_text)
    await state.clear()
    
    confirm_text = (
        "✅ <b>پیام شما با موفقیت به عنوان تیکت ثبت شد!</b>\n\n"
        f"🎫 شناسه تیکت: <code>#SP-{ticket_id}</code>\n"
        "پشتیبان‌های ما پس از بررسی پاسخ تیکت را برای شما ارسال خواهند کرد."
    )
    
    is_admin = message.from_user.id in __import__('config').ADMIN_IDS
    await message.answer(confirm_text, reply_markup=reply.client_main_menu(is_admin=is_admin), parse_mode="HTML", message_effect_id="5107584321108051014")
    
    recipients = await db.get_admin_recipients('support')
    for admin_id in recipients:
        try:
            await bot.send_message(
                admin_id,
                f"📞 <b>تیکت پشتیبانی جدید (#SP-{ticket_id})</b>\n\n"
                f"👤 فرستنده: {message.from_user.full_name} (ID: `{message.from_user.id}`)\n"
                f"شناسه کاربری: @{message.from_user.username or 'ندارد'}\n\n"
                f"متن پیام:\n<code>{query_text}</code>",
                parse_mode="HTML",
                reply_markup=inline.admin_ticket_action_keyboard(ticket_id)
            )
            if message.content_type != 'text':
                await message.copy_to(admin_id)
        except: pass

# Back button is handled by the global StateFilter("*") handler at the top

async def send_main_menu(message: Message, db_user):
    if not db_user:
        return
    user_id = db_user['user_id']
    is_admin = user_id in ADMIN_IDS
    role = db_user['role'] or 'freelancer'
    balance = db_user['balance'] or 0
    vip_level = await db.check_vip_level(user_id)
    vip_names = {0: "👤 کاربر عادی", 1: "🥉 برنزی", 2: "🥈 نقره‌ای", 3: "🥇 طلایی"}
    vip_str = vip_names.get(vip_level, "👤 کاربر عادی")
    full_name = db_user['full_name'] or db_user['username'] or "کاربر"

    ref_stats = await db.get_referral_stats(user_id)
    referrals_count = ref_stats.get('count', 0)
    referrals_reward = ref_stats.get('earnings', 0)

    if role == 'client':
        project_stats = await db.get_client_project_status_stats(user_id)
        open_projects = project_stats.get('open', 0)
        in_progress_projects = project_stats.get('in_progress', 0) + project_stats.get('delivered', 0)
        completed_projects = project_stats.get('completed', 0)
        
        html_dashboard = (
            "<h1>👔 داشبورد اختصاصی کارفرما | ایکس‌لنسر</h1>"
            "<hr/>"
            "<p>به داشبورد کارفرمایی خوش آمدید. در این بخش می‌توانید سفارش‌های ثبت شده را مدیریت کنید.</p>"
            "<br/>"
            "<table bordered striped>"
            "  <thead>"
            "    <tr>"
            "      <th colspan=\"2\">👤 مشخصات کاربری</th>"
            "    </tr>"
            "  </thead>"
            "  <tbody>"
            "    <tr>"
            "      <td>👤 نام شما</td>"
            f"      <td><code>{full_name}</code></td>"
            "    </tr>"
            "    <tr>"
            "      <td>✨ سطح کاربری</td>"
            f"      <td>{vip_str}</td>"
            "    </tr>"
            "    <tr>"
            "      <td> Purse 👛 موجودی کیف پول</td>"
            f"      <td><code>{balance:,} تومان</code></td>"
            "    </tr>"
            "  </tbody>"
            "</table>"
            "<br/>"
            "<table bordered striped>"
            "  <thead>"
            "    <tr>"
            "      <th colspan=\"3\">📊 آمار پروژه‌های شما</th>"
            "    </tr>"
            "    <tr>"
            "      <th>🟢 باز</th>"
            "      <th>🔵 در حال انجام</th>"
            "      <th>✅ تکمیل شده</th>"
            "    </tr>"
            "  </thead>"
            "  <tbody>"
            "    <tr>"
            f"      <td><b>{open_projects}</b></td>"
            f"      <td><b>{in_progress_projects}</b></td>"
            f"      <td><b>{completed_projects}</b></td>"
            "    </tr>"
            "  </tbody>"
            "</table>"
            "<br/>"
            "<table bordered striped>"
            "  <thead>"
            "    <tr>"
            "      <th colspan=\"2\">👥 سیستم دعوت دوستان</th>"
            "    </tr>"
            "  </thead>"
            "  <tbody>"
            "    <tr>"
            "      <td>🔗 تعداد دعوت‌شدگان</td>"
            f"      <td>{referrals_count} نفر</td>"
            "    </tr>"
            "    <tr>"
            "      <td>🎁 درآمد کسب‌شده</td>"
            f"      <td><code>{referrals_reward:,} تومان</code></td>"
            "    </tr>"
            "  </tbody>"
            "</table>"
            "<br/>"
            "<p>🚀 <i>از دکمه‌های زیر جهت ثبت سفارش و مدیریت استفاده کنید:</i></p>"
        )
        kb = reply.client_main_menu(is_admin=is_admin)
    else:
        connects = db_user['connects'] if 'connects' in dict(db_user) else 5
        bids_count = await db.count_freelancer_bids(user_id)
        
        # Query completed projects and ratings
        import aiosqlite
        from database.db import DB_PATH
        completed_projects = 0
        avg_rating = 0.0
        try:
            async with aiosqlite.connect(DB_PATH) as conn:
                conn.row_factory = aiosqlite.Row
                async with conn.execute(
                    '''SELECT COUNT(*) as total_projects, 
                              COALESCE(AVG(rating_to_freelancer), 0) as avg_rating 
                       FROM projects 
                       WHERE chosen_freelancer_id = ? AND status = 'completed' AND rating_to_freelancer IS NOT NULL''',
                    (user_id,)
                ) as cursor:
                    stats = await cursor.fetchone()
                    if stats:
                        completed_projects = stats['total_projects']
                        avg_rating = round(stats['avg_rating'], 1)
        except Exception:
            pass
            
        html_dashboard = (
            "<h1>💻 داشبورد اختصاصی فریلنسر | ایکس‌لنسر</h1>"
            "<hr/>"
            "<p>به داشبورد فریلنسری خوش آمدید. از بخش زیر می‌توانید پروژه‌ها را جستجو کرده و پیشنهاد ارسال کنید.</p>"
            "<br/>"
            "<table bordered striped>"
            "  <thead>"
            "    <tr>"
            "      <th colspan=\"2\">👤 مشخصات کاربری</th>"
            "    </tr>"
            "  </thead>"
            "  <tbody>"
            "    <tr>"
            "      <td>👤 نام شما</td>"
            f"      <td><code>{full_name}</code></td>"
            "    </tr>"
            "    <tr>"
            "      <td>✨ سطح کاربری</td>"
            f"      <td>{vip_str}</td>"
            "    </tr>"
            "    <tr>"
            "      <td> Purse 👛 موجودی کیف پول</td>"
            f"      <td><code>{balance:,} تومان</code></td>"
            "    </tr>"
            "    <tr>"
            "      <td>🪙 اعتبار کانکت (بید)</td>"
            f"      <td><b>{connects}</b> عدد</td>"
            "    </tr>"
            "  </tbody>"
            "</table>"
            "<br/>"
            "<table bordered striped>"
            "  <thead>"
            "    <tr>"
            "      <th colspan=\"3\">📊 خلاصه عملکرد کاری</th>"
            "    </tr>"
            "    <tr>"
            "      <th>📨 پیشنهادات</th>"
            "      <th>✅ موفق</th>"
            "      <th>⭐️ امتیاز میانگین</th>"
            "    </tr>"
            "  </thead>"
            "  <tbody>"
            "    <tr>"
            f"      <td><b>{bids_count}</b></td>"
            f"      <td><b>{completed_projects}</b></td>"
            f"      <td><b>{avg_rating} از ۵</b></td>"
            "    </tr>"
            "  </tbody>"
            "</table>"
            "<br/>"
            "<table bordered striped>"
            "  <thead>"
            "    <tr>"
            "      <th colspan=\"2\">👥 سیستم دعوت دوستان</th>"
            "    </tr>"
            "  </thead>"
            "  <tbody>"
            "    <tr>"
            "      <td>🔗 تعداد دعوت‌شدگان</td>"
            f"      <td>{referrals_count} نفر</td>"
            "    </tr>"
            "  </tbody>"
            "</table>"
            "<br/>"
            "<p>🚀 <i>از دکمه‌های زیر جهت یافتن پروژه و ارسال پیشنهاد استفاده کنید:</i></p>"
        )
        kb = reply.freelancer_main_menu(is_admin=is_admin)

    rich_msg = InputRichMessage(html=html_dashboard)
    await message.bot.send_rich_message(chat_id=message.chat.id, rich_message=rich_msg, reply_markup=kb)


@router.message(AsyncChat.waiting_for_message)
async def process_async_chat_message(message: Message, state: FSMContext, bot: Bot, db_user):
    data = await state.get_data()
    target_id = data.get("target_id")
    is_fulltime = data.get("is_fulltime", False)
    project_title = data.get("project_title", "")
    role = data.get("role", "freelancer")
    project_id = data.get("project_id")
    
    await state.clear()
    is_admin = message.from_user.id in __import__('config').ADMIN_IDS
    kb = reply.client_main_menu(is_admin=is_admin) if role == 'client' else reply.freelancer_main_menu(is_admin=is_admin)
    
    if message.text == texts.BTN_BACK:
        return await message.answer("عملیات لغو شد.", reply_markup=kb)
        
    content_text = message.text or message.caption or ""
    
    if not is_fulltime and contains_forbidden_info(content_text):
        try:
            await message.delete()
        except: pass
        await message.answer(texts.CHAT_BLOCKED_MSG, reply_markup=kb, parse_mode="HTML")
        return
        
    try: await message.react([ReactionTypeEmoji(emoji="📨")])
    except: pass
    
    # Extract message details for database log
    msg_type = 'text'
    file_id = None
    if message.voice:
        msg_type = 'voice'
        file_id = message.voice.file_id
    elif message.photo:
        msg_type = 'photo'
        file_id = message.photo[-1].file_id
    elif message.document:
        msg_type = 'document'
        file_id = message.document.file_id
        
    # Save message in database
    if project_id:
        try:
            await db.save_chat_message(project_id, message.from_user.id, target_id, msg_type, content_text, file_id)
        except Exception as e:
            logger.error(f"Error saving chat message to db: {e}")
            
    # Send success to sender
    await message.answer("✅ <b>پیام شما با موفقیت ارسال شد.</b>", reply_markup=kb, parse_mode="HTML")
    
    # Create reply inline button for recipient
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    builder = InlineKeyboardBuilder()
    reply_role = "client" if role == "freelancer" else "freelancer"
    builder.button(text="💬 پاسخ", callback_data=f"async_reply_{message.from_user.id}_{reply_role}_{1 if is_fulltime else 0}_{project_id or 'none'}")
    
    sender_role_fa = "فریلنسر" if role == "freelancer" else "کارفرما"
    header = f"📨 <b>پیام جدید از طرف {sender_role_fa} (پروژه: {project_title})</b>\n\n"
    
    try:
        if message.text:
            await bot.send_message(target_id, header + message.text, reply_markup=builder.as_markup(), parse_mode="HTML")
        elif message.voice:
            await bot.send_voice(target_id, message.voice.file_id, caption=header, reply_markup=builder.as_markup(), parse_mode="HTML")
        elif message.photo:
            await bot.send_photo(target_id, message.photo[-1].file_id, caption=header + (message.caption or ""), reply_markup=builder.as_markup(), parse_mode="HTML")
        elif message.document:
            await bot.send_document(target_id, message.document.file_id, caption=header + (message.caption or ""), reply_markup=builder.as_markup(), parse_mode="HTML")
    except:
        pass

@router.callback_query(F.data.startswith("async_reply_"))
async def async_reply_handler(callback: CallbackQuery, state: FSMContext):
    parts = callback.data.split("_")
    target_id = int(parts[2])
    role = parts[3]
    is_fulltime = parts[4] == "1"
    
    project_id = None
    if len(parts) > 5 and parts[5] != "none":
        try:
            project_id = int(parts[5])
        except:
            pass
            
    chat_data = {
        "target_id": target_id, 
        "role": role, 
        "project_id": project_id,
        "project_title": "پاسخ مستقیم", 
        "is_fulltime": is_fulltime
    }
    await state.set_state(AsyncChat.waiting_for_message)
    await state.set_data(chat_data)
    
    warning = ""
    if not is_fulltime:
        warning = "\n\n⚠️ <b>توجه:</b> ارسال هرگونه اطلاعات تماس اکیداً ممنوع است."
        
    await callback.message.answer(f"💬 <b>ارسال پاسخ</b>\nلطفاً پیام خود را تایپ کنید:{warning}", reply_markup=reply.cancel_menu(), parse_mode="HTML")
    await callback.answer()

@router.callback_query(F.data == "start_support_ticket")
async def start_support_callback(callback: CallbackQuery, state: FSMContext, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    builder = InlineKeyboardBuilder()
    builder.button(text="📖 راهنمای استفاده و سوالات متداول", callback_data="support_faq")
    builder.button(text="🎫 ثبت تیکت پشتیبانی", callback_data="support_submit_ticket")
    builder.adjust(1)
    
    html_menu = (
        "<h1>📞 مرکز پشتیبانی و راهنمایی ایکس‌لنسر</h1>"
        "<hr/>"
        "<p>به بخش پشتیبانی خوش آمدید. لطفاً یکی از گزینه‌های زیر را انتخاب کنید:</p>"
        "<br/>"
        "<blockquote>💡 پیشنهاد می‌کنیم قبل از ثبت تیکت، بخش <b>راهنما و سوالات متداول</b> را مطالعه کنید. اکثر سوالات کارفرمایان و فریلنسرها در آنجا پاسخ داده شده است.</blockquote>"
    )
    rich_msg = InputRichMessage(html=html_menu)
    
    try:
        await callback.message.edit_text(text=None, rich_message=rich_msg, reply_markup=builder.as_markup())
    except Exception:
        await bot.send_rich_message(chat_id=callback.message.chat.id, rich_message=rich_msg, reply_markup=builder.as_markup())
    await callback.answer()

@router.callback_query(F.data == "support_faq")
async def support_faq_handler(callback: CallbackQuery, bot: Bot):
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت", callback_data="start_support_ticket")
    builder.adjust(1)
    
    faq_html = (
        "<h1>📖 راهنمای کامل و سوالات متداول (FAQ)</h1>"
        "<hr/>"
        "<p>برای مشاهده پاسخ هر سوال، روی آن ضربه بزنید:</p>"
        "<br/>"
        "<details>"
        "  <summary>🔑 سیستم پرداخت امن (Escrow) چیست و چه مزیتی دارد؟</summary>"
        "  <p>پرداخت امن (اسکرو) سازوکاری است که امنیت مالی کارفرما و فریلنسر را ۱۰۰٪ تضمین می‌کند. در این روش، کارفرما پیش از شروع کار، مبلغ پروژه را در صندوق امن ربات بلوکه می‌کند. فریلنسر با خیال راحت از وجود وجه کار خود را آغاز کرده و پس از ارائه خروجی کار و تأیید کارفرما، مبلغ به صورت خودکار به کیف پول فریلنسر آزاد می‌شود.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>⚖️ سیستم داوری و حل اختلاف چگونه کار می‌کند؟</summary>"
        "  <p>اگر اختلافی در حین پروژه پیش بیاید، هر یک از طرفین می‌توانند پروژه را به داوری ارجاع دهند. ابتدا داور (ادمین) تلاش می‌کند در چت سه‌نفره اختلاف را مستقیماً حل کند. در صورت لزوم، پرونده به هیئت منصفه (سایر کاربران واجد شرایط) ارجاع می‌شود و بر اساس آرای ثبت‌شده، کل مبلغ یا بخشی از آن به کارفرما عودت و مابقی به فریلنسر آزاد می‌شود.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>⚡ کانکت (Connect) چیست و چگونه می‌توان آن را تهیه کرد؟</summary>"
        "  <p>کانکت، اعتبار مورد نیاز فریلنسرها برای ارسال پیشنهاد (بید) روی پروژه‌هاست. هر پیشنهاد معادل تعدادی کانکت است. روش‌های کسب کانکت:<br/>"
        "۱. هدیه ثبت‌نام اولیه در ربات.<br/>"
        "۲. خرید بسته‌های کانکت از طریق درگاه پرداخت کیف پول.<br/>"
        "۳. سیستم زیرمجموعه‌گیری (با دعوت هر دوست، کانکت رایگان دریافت می‌کنید).<br/>"
        "۴. دریافت کانکت‌های هدیه روزانه برای اعضای ویژه VIP.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>💼 نحوه ثبت پروژه جدید و جیگ (خدمات) چیست؟</summary>"
        "  <p><b>کارفرمایان:</b> با رفتن به منوی اصلی و کلیک روی «ثبت پروژه جدید»، عنوان، بودجه و توضیحات را وارد کنید تا پروژه برای فریلنسرها منتشر شود.<br/>"
        "<b>فریلنسرها:</b> از منوی فریلنسری و بخش «خدمات من»، می‌توانید خدمات خود (جیگ) را با قیمت مشخص ثبت کنید تا کارفرمایان بتوانند مستقیماً آن را بخرند.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>💰 کارمزد (کمیسیون) پلتفرم ایکس‌لنسر چقدر است؟</summary>"
        "  <p>ایکس‌لنسر کمترین میزان کارمزد را در بین پلتفرم‌های فریلنسینگ دارد:<br/>"
        "• برای کاربران عادی: ۱۰٪ از مبلغ پروژه‌های آزاد شده.<br/>"
        "• برای اعضای ویژه VIP: کارمزد به نصف (فقط ۵٪) کاهش می‌یابد!</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>💵 برداشت وجه از کیف پول و تسویه حساب چطور انجام می‌شود؟</summary>"
        "  <p>با مراجعه به بخش کیف پول و کلیک روی دکمه «برداشت وجه»، می‌توانید مبلغ دلخواه خود را (حداقل ۱۰,۰۰۰ تومان) وارد کنید. مبالغ تسویه حساب پس از تأیید ادمین، حداکثر ظرف مدت ۲۴ ساعت کاری از طریق پایا/کارت‌به‌کارت به حساب شما واریز می‌گردد.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>🌟 مزایای عضویت ویژه VIP چیست؟</summary>"
        "  <p>اعضای VIP پلتفرم از مزایای متمایز زیر برخوردار می‌شوند:<br/>"
        "۱. کاهش کارمزد پروژه‌ها از ۱۰٪ به ۵٪.<br/>"
        "۲. اولویت نمایش در بالای لیست پیشنهادها برای کارفرما.<br/>"
        "۳. دریافت کانکت‌های رایگان روزانه جهت بید زدن.<br/>"
        "۴. دریافت نشان متمایز VIP در پروفایل عمومی جهت جذب اعتماد کارفرمایان.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>🚫 قوانین مهم و رفتارهای ممنوعه در پلتفرم چیست؟</summary>"
        "  <p>ایکس‌لنسر برای حفظ امنیت کاربران، قوانین سخت‌گیرانه‌ای دارد:<br/>"
        "۱. به اشتراک‌گذاری اطلاعات تماس مستقیم (مانند شماره تلفن، آیدی تلگرام، اینستاگرام، واتساپ، روبیکا و...) در پیام‌های عمومی، بیدها، بیو و توضیحات ممنوع است و سیستم هوشمند محتوا را مسدود می‌کند.<br/>"
        "۲. هرگونه توافق مالی خارج از سیستم پرداخت امن ربات ممنوع بوده و پلتفرم هیچ مسئولیتی در قبال کلاهبرداری‌های خارج از ربات نمی‌پذیرد و حساب خاطی مسدود خواهد شد.</p>"
        "</details>"
        "<br/>"
        "<details>"
        "  <summary>📤 فرآیند تحویل کار و آزاد کردن وجه پروژه به چه صورت است؟</summary>"
        "  <p>فریلنسر پس از اتمام کار، از طریق بخش مدیریت پروژه روی دکمه «ارسال فایل نهایی / تحویل کار» کلیک کرده و فایل یا توضیحات تحویل را ثبت می‌کند. پس از آن، کارفرما فرصت دارد کار را بررسی کرده و در صورت صحت، دکمه «آزادسازی وجه» را بزند تا هزینه به حساب فریلنسر منتقل شود.</p>"
        "</details>"
    )
    rich_msg = InputRichMessage(html=faq_html)
    try:
        await callback.message.edit_text(text=None, rich_message=rich_msg, reply_markup=builder.as_markup())
    except Exception:
        await bot.send_rich_message(chat_id=callback.message.chat.id, rich_message=rich_msg, reply_markup=builder.as_markup())
    await callback.answer()

@router.callback_query(F.data == "support_submit_ticket")
async def support_submit_ticket_handler(callback: CallbackQuery, state: FSMContext, bot: Bot):
    await state.set_state(SupportSession.waiting_for_message)
    try: await callback.message.react([ReactionTypeEmoji(emoji="📞")])
    except: pass
    await callback.message.answer(texts.SUPPORT_PROMPT, reply_markup=reply.cancel_menu(), parse_mode="HTML")
    await callback.answer()

async def check_channel_membership(bot, user_id: int) -> bool:
    from database import db
    join_mandatory = await db.get_setting('join_mandatory', '0')
    if join_mandatory != '1':
        return True
    channel_id = await db.get_setting('channel_id')
    if not channel_id:
        return True
    try:
        if (channel_id.startswith('-') and channel_id[1:].isdigit()) or channel_id.isdigit():
            chat_id = int(channel_id)
        else:
            chat_id = channel_id
        member = await bot.get_chat_member(chat_id=chat_id, user_id=user_id)
        return member.status in ['member', 'administrator', 'creator']
    except Exception as e:
        logger.error(f"Error checking channel membership for user {user_id}: {e}")
        return False

async def get_channel_invite_link(bot, channel_id: str) -> str:
    if not channel_id:
        return "https://t.me"
    if channel_id.startswith('@'):
        return f"https://t.me/{channel_id.replace('@', '')}"
    if channel_id.startswith('https://') or channel_id.startswith('http://'):
        return channel_id
    
    # Try fetching chat info from Telegram to get invite link or username dynamically
    try:
        if (channel_id.startswith('-') and channel_id[1:].isdigit()) or channel_id.isdigit():
            chat_id = int(channel_id)
        else:
            chat_id = channel_id
        chat = await bot.get_chat(chat_id)
        if chat.invite_link:
            return chat.invite_link
        if chat.username:
            return f"https://t.me/{chat.username}"
    except Exception as e:
        logger.error(f"Error getting channel invite link: {e}")
        
    return "https://t.me"

# ── User Verification Flow (FSM) ──────────────────────────────────────────

@router.callback_query(F.data == "profile_start_verification")
async def start_verification_handler(callback: CallbackQuery, state: FSMContext):
    await state.set_state(UserVerification.waiting_for_phone)
    await callback.message.answer(
        "📱 <b>مرحله ۱ از ۳: تأیید شماره موبایل</b>\n\n"
        "برای احراز هویت، لطفاً روی دکمه زیر کلیک کنید تا شماره موبایل شما ارسال شود.",
        reply_markup=reply.request_phone_keyboard(),
        parse_mode="HTML"
    )
    await callback.answer()

@router.message(UserVerification.waiting_for_phone)
async def process_phone(message: Message, state: FSMContext):
    if message.text == texts.BTN_BACK:
        await state.clear()
        db_user = await db.get_user(message.from_user.id)
        await send_main_menu(message, db_user)
        return
        
    phone = ""
    if message.contact:
        phone = message.contact.phone_number
    else:
        phone = message.text.strip()
        # Basic Iranian phone validation
        if not re.match(r'^(\+98|0)?9\d{9}$', phone):
            return await message.answer("❌ شماره موبایل وارد شده معتبر نیست. لطفاً از دکمه زیر استفاده کنید یا شماره را دقیق وارد کنید:")
            
    try: await message.react([ReactionTypeEmoji(emoji="📱")])
    except: pass
    await state.update_data(phone=phone)
    await state.set_state(UserVerification.waiting_for_name)
    await message.answer(
        "👤 <b>مرحله ۲ از ۳: نام و نام خانوادگی</b>\n\n"
        "لطفاً نام و نام خانوادگی خود را دقیقاً مطابق با کارت ملی وارد کنید:",
        reply_markup=reply.cancel_menu(),
        parse_mode="HTML"
    )

@router.message(UserVerification.waiting_for_name)
async def process_name(message: Message, state: FSMContext):
    if message.text == texts.BTN_BACK:
        await state.clear()
        db_user = await db.get_user(message.from_user.id)
        await send_main_menu(message, db_user)
        return
        
    name = message.text.strip()
    if len(name) < 3:
        return await message.answer("❌ نام وارد شده خیلی کوتاه است. نام کامل را بنویسید:")
        
    try: await message.react([ReactionTypeEmoji(emoji="👤")])
    except: pass
    await state.update_data(name=name)
    await state.set_state(UserVerification.waiting_for_national_code)
    await message.answer(
        "🪪 <b>مرحله ۳ از ۳: کد ملی</b>\n\n"
        "لطفاً کد ملی ۱۰ رقمی خود را بدون خط تیره وارد کنید:",
        reply_markup=reply.cancel_menu(),
        parse_mode="HTML"
    )

@router.message(UserVerification.waiting_for_national_code)
async def process_national_code(message: Message, state: FSMContext, bot: Bot):
    if message.text == texts.BTN_BACK:
        await state.clear()
        db_user = await db.get_user(message.from_user.id)
        await send_main_menu(message, db_user)
        return
        
    code = message.text.strip().replace(" ", "").replace("-", "")
    
    # Mathematical checksum check for Iranian national code
    def is_valid_national_code(c: str) -> bool:
        if not c.isdigit() or len(c) != 10:
            return False
        if len(set(c)) == 1:
            return False
        total = sum(int(c[i]) * (10 - i) for i in range(9))
        rem = total % 11
        check = int(c[9])
        return check == rem if rem < 2 else check == 11 - rem

    if not is_valid_national_code(code):
        return await message.answer("❌ کد ملی وارد شده از نظر ریاضی معتبر نیست. لطفاً کد ملی ۱۰ رقمی صحیح خود را وارد کنید:")
        
    try: await message.react([ReactionTypeEmoji(emoji="👍")])
    except: pass
        
    data = await state.get_data()
    phone = data['phone']
    name = data['name']
    
    await state.clear()
    
    # Update name in DB
    import aiosqlite
    async with aiosqlite.connect(db.DB_PATH) as conn:
        await conn.execute("UPDATE users SET full_name = ? WHERE user_id = ?", (name, message.from_user.id))
        await conn.commit()
        
    # Submit verification
    await db.submit_verification(message.from_user.id, phone, code)
    
    db_user = await db.get_user(message.from_user.id)
    is_admin = message.from_user.id in ADMIN_IDS
    kb = reply.client_main_menu(is_admin=is_admin) if db_user['role'] == 'client' else reply.freelancer_main_menu(is_admin=is_admin)
    
    await message.answer(
        "✅ <b>درخواست احراز هویت شما با موفقیت ثبت شد.</b>\n\n"
        "مدارک شما به زودی توسط مدیریت بررسی خواهد شد.",
        reply_markup=kb,
        parse_mode="HTML",
        message_effect_id="5107584321108051014" # Thumbs Up!
    )
    
    # Alert Admins
    recipients = await db.get_admin_recipients('verifications')
    for admin_id in recipients:
        try:
            from aiogram.utils.keyboard import InlineKeyboardBuilder
            builder = InlineKeyboardBuilder()
            builder.button(text="👁 بررسی درخواست", callback_data=f"admin_view_verify_{message.from_user.id}")
            await bot.send_message(
                admin_id,
                f"🔐 <b>درخواست احراز هویت جدید:</b>\n\n"
                f"👤 کاربر: {name} (ID: `{message.from_user.id}`)\n"
                f"📱 تلفن: `{phone}`\n"
                f"🪪 کد ملی: `{code}`",
                reply_markup=builder.as_markup(),
                parse_mode="HTML"
            )
        except:
            pass

@router.callback_query(F.data == "onboarding_2")
async def process_onboarding_2(callback: CallbackQuery):
    from aiogram.exceptions import TelegramBadRequest
    try:
        if callback.message.photo:
            await callback.message.edit_caption(
                caption=texts.ONBOARDING_2,
                reply_markup=inline.onboarding_step_2(),
                parse_mode="HTML"
            )
        else:
            await callback.message.edit_text(
                text=texts.ONBOARDING_2,
                reply_markup=inline.onboarding_step_2(),
                parse_mode="HTML"
            )
    except TelegramBadRequest as e:
        if "message is not modified" in str(e):
            await callback.answer()
        else:
            raise

@router.callback_query(F.data == "onboarding_done")
async def process_onboarding_done(callback: CallbackQuery):
    caption_text = "🎯 <b>لطفاً نقش خود را در پلتفرم انتخاب کنید:</b>\n\nشما می‌توانید به عنوان کارفرما پروژه ثبت کنید یا به عنوان فریلنسر پیشنهاد ارسال کنید."
    from aiogram.exceptions import TelegramBadRequest
    try:
        if callback.message.photo:
            await callback.message.edit_caption(
                caption=caption_text,
                reply_markup=inline.role_selection_keyboard(),
                parse_mode="HTML"
            )
        else:
            await callback.message.edit_text(
                text=caption_text,
                reply_markup=inline.role_selection_keyboard(),
                parse_mode="HTML"
            )
    except TelegramBadRequest as e:
        if "message is not modified" in str(e):
            await callback.answer()
        else:
            raise

@router.callback_query(F.data == "cancel_fsm")
async def process_cancel_fsm_inline(callback: CallbackQuery, state: FSMContext, bot: Bot, db_user):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    await callback.message.delete()
    await send_main_menu(callback.message, db_user)


@router.message(F.text == "🏆 برترین‌ها", StateFilter("*"))
async def show_leaderboard(message: Message, state: FSMContext, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    try: await message.react([ReactionTypeEmoji(emoji="🏆")])
    except: pass
    
    weekly_leaders = await db.get_weekly_freelancer_leaderboard(limit=5)
    overall_leaders = await db.get_freelancer_leaderboard(limit=5)
    
    html_content = (
        "<h1>🏆 لیدربورد برترین‌های ایکس‌لنسر</h1>"
        "<hr/>"
        "<h3>🗓 برترین فریلنسرهای هفته (۷ روز اخیر)</h3>"
        "<table bordered striped>"
        "  <tr><th>رتبه / نام فریلنسر</th><th>پروژه‌ها</th><th>نوع حساب</th></tr>"
    )
    
    medals = {0: "🥇", 1: "🥈", 2: "🥉"}
    if not weekly_leaders:
        html_content += "  <tr><td colspan='3' align='center'><i>داده‌ای ثبت نشده است. اولین نفری باشید که پروژه تکمیل می‌کند! 🚀</i></td></tr>"
    else:
        for idx, row in enumerate(weekly_leaders):
            medal = medals.get(idx, f"{idx+1}.")
            vip_star = "💎 VIP" if row['is_vip'] else "عادی"
            name = row['full_name'] or "کاربر ناشناس"
            html_content += f"  <tr><td>{medal} {name}</td><td>{row['completed_count']}</td><td>{vip_star}</td></tr>"
            
    html_content += (
        "</table>"
        "<br/>"
        "<h3>🌟 برترین‌های کل دوره</h3>"
        "<table bordered striped>"
        "  <tr><th>رتبه / نام فریلنسر</th><th>پروژه‌ها</th><th>نوع حساب</th></tr>"
    )
    
    if not overall_leaders:
        html_content += "  <tr><td colspan='3' align='center'><i>داده‌ای ثبت نشده است.</i></td></tr>"
    else:
        for idx, row in enumerate(overall_leaders):
            medal = medals.get(idx, f"{idx+1}.")
            vip_star = "💎 VIP" if row['is_vip'] else "عادی"
            name = row['full_name'] or "کاربر ناشناس"
            html_content += f"  <tr><td>{medal} {name}</td><td>{row['completed_count']}</td><td>{vip_star}</td></tr>"
            
    html_content += (
        "</table>"
        "<br/>"
        "<p>💡 <i>رتبه‌بندی هفتگی بر اساس پروژه‌های تکمیل شده در ۷ روز گذشته و رتبه‌بندی کل دوره بر اساس کل پروژه‌های موفق انجام می‌شود.</i></p>"
    )
    
    rich_msg = InputRichMessage(html=html_content)
    await bot.send_rich_message(chat_id=message.chat.id, rich_message=rich_msg)


@router.message(Command("promo"))
async def cmd_promo(message: Message, command: CommandObject):
    if not command.args:
        return await message.answer("🎁 لطفاً کد هدیه را بعد از دستور وارد کنید. مثال:\n`/promo GIFT2023`", parse_mode="Markdown")
        
    code = command.args.strip().upper()
    success, msg = await db.use_promo_code(message.from_user.id, code)
    if success:
        await message.answer(f"✅ {msg}")
    else:
        await message.answer(f"❌ {msg}")


@router.message(Command("alerts"))
async def cmd_alerts(message: Message, command: CommandObject):
    if not command.args:
        alerts = await db.get_user_alerts(message.from_user.id)
        if not alerts:
            return await message.answer("🔕 شما هیچ هشدار شغلی فعالی ندارید.\n\nبرای ایجاد هشدار جدید، از دستور زیر استفاده کنید:\n`/alerts کلمه_کلیدی`\nمثال: `/alerts پایتون`", parse_mode="Markdown")
            
        text = "🔔 <b>هشدارهای شغلی شما:</b>\n\n"
        for a in alerts:
            text += f"▪️ <code>{a['keyword']}</code> (حذف: /delalert_{a['alert_id']})\n"
        return await message.answer(text, parse_mode="HTML")
        
    keyword = command.args.strip()
    await db.add_job_alert(message.from_user.id, keyword)
    await message.answer(f"✅ هشدار شغلی برای کلمه «<b>{keyword}</b>» با موفقیت ثبت شد!\nهرگاه پروژه‌ای با این کلمه ثبت شود، به شما اطلاع می‌دهیم.", parse_mode="HTML")

@router.message(F.text.startswith("/delalert_"))
async def cmd_delalert(message: Message):
    try:
        alert_id = int(message.text.split("_")[1])
        await db.delete_job_alert(alert_id, message.from_user.id)
        await message.answer("🗑 هشدار شغلی با موفقیت حذف شد.")
    except:
        pass


@router.message(F.text == texts.BTN_REFRESH, StateFilter("*"))
async def global_refresh(message: Message, state: FSMContext, db_user, bot: Bot):
    await check_and_clear_chat_session(state, bot)
    await state.clear()
    await send_main_menu(message, db_user)


from aiogram.types import PreCheckoutQuery, LabeledPrice

@router.callback_query(F.data == "buy_vip_stars")
async def buy_vip_stars(callback: CallbackQuery, bot: Bot):
    await bot.send_invoice(
        chat_id=callback.from_user.id,
        title="اشتراک ویژه (VIP)",
        description="یک ماه اشتراک ویژه در ربات برای فریلنسری حرفه‌ای",
        payload="vip_subscription_1_month",
        provider_token="", # Empty for Telegram Stars
        currency="XTR",
        prices=[LabeledPrice(label="VIP 1 Month", amount=100)],
    )
    await callback.answer()

@router.pre_checkout_query()
async def process_pre_checkout(pre_checkout_query: PreCheckoutQuery, bot: Bot):
    await bot.answer_pre_checkout_query(pre_checkout_query.id, ok=True)

@router.message(F.successful_payment)
async def process_successful_payment(message: Message, bot: Bot):
    payload = message.successful_payment.invoice_payload
    if payload == "vip_subscription_1_month":
        await db.update_vip_status(message.from_user.id, 30)
        await message.answer("🎉 <b>تبریک!</b> اشتراک ویژه شما با موفقیت از طریق Stars فعال شد.", message_effect_id="5104841245755180586", parse_mode="HTML")


# ── Chat Join Request (Bot API 10.1 Auto-Approve) ────────────────────────
@router.chat_join_request()
async def handle_chat_join_request(join_request: ChatJoinRequest, bot: Bot):
    try:
        # Auto-approve the request using Bot API 10.1 answer_query or standard approve
        if hasattr(join_request, "query_id") and join_request.query_id:
            await join_request.answer_query(approve=True)
        else:
            await join_request.approve()
            
        # Notify the user
        await bot.send_message(
            chat_id=join_request.from_user.id,
            text=f"✅ <b>درخواست عضویت شما در کانال با موفقیت تایید شد!</b>\n\nاکنون می‌توانید از تمامی خدمات ربات استفاده کنید.",
            parse_mode="HTML"
        )
    except Exception as e:
        import logging
        logging.getLogger(__name__).error(f"Error approving join request: {e}")
