bot.py

# bot.py
from telegram import BotCommand, Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    CallbackQueryHandler,
    MessageHandler,
    filters,
    ContextTypes,
    ConversationHandler,
)
import os
import asyncio
from dotenv import load_dotenv
from src.helpers.translates import Translates

load_dotenv()
translate = Translates()

TOKEN = os.getenv("API_TOKEN", "---")
TARGET_GROUP_ID = os.getenv("GROUP_MESSAGE_ID", "----")

# States
CHOOSE_TEST, WAITING_FOR_UPLOAD = range(2)
user_data_store = {}


commands_fa = [
    BotCommand("start", translate.translates["start"]),
    BotCommand("finish", translate.translates["finish"]),
]


async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("Test 1", callback_data="test1")],
        [InlineKeyboardButton("Test 2", callback_data="test2")],
    ]
    await update.message.reply_text(
        "sdfsdfsd", reply_markup=InlineKeyboardMarkup(keyboard)
    )
    return CHOOSE_TEST


async def test_choice(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()
    test_selected = query.data
    user_data_store[query.from_user.id] = {"test": test_selected}

    await query.message.reply_text(
        f"You selected {test_selected.upper()}. Follow the instructions below:\n\n"
        "1. Do the test as required.\n"
        "2. Click 'Finish' when done.",
        reply_markup=InlineKeyboardMarkup(
            [[InlineKeyboardButton("Finish", callback_data="finish")]]
        ),
    )
    return WAITING_FOR_UPLOAD


async def finish_test(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    if query:
        await query.answer()
        if query.message:
            await query.message.reply_text(
                "Upload your result (text + screenshot/video):"
            )
            return WAITING_FOR_UPLOAD


async def handle_upload(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    user_info = user_data_store.get(user_id, {})
    username = update.effective_user.username or "Unknown"
    test = user_info.get("test", "unknown_test")

    caption = f"👤 User: @{username}\n🆔 ID: {user_id}\n🧪 Test: {test}\n"
    if update.message.caption:
        caption += f"📝 Notes: {update.message.caption}"

    if update.message.photo:
        await context.bot.send_photo(
            chat_id=TARGET_GROUP_ID,
            photo=update.message.photo[-1].file_id,
            caption=caption,
        )
    elif update.message.video:
        await context.bot.send_video(
            chat_id=TARGET_GROUP_ID, video=update.message.video.file_id, caption=caption
        )
    elif update.message.text:
        caption += f"\n📄 Text: {update.message.text}"
        await context.bot.send_message(chat_id=TARGET_GROUP_ID, text=caption)
    else:
        await update.message.reply_text(
            "Unsupported format. Please send a photo, video, or text."
        )
        return WAITING_FOR_UPLOAD

    await update.message.reply_text("✅ Your result has been submitted. Thank you!")
    return ConversationHandler.END


async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("Operation cancelled.")
    return ConversationHandler.END


if __name__ == "__main__":
    app = ApplicationBuilder().token(TOKEN).build()

    conv = ConversationHandler(
        entry_points=[CommandHandler("start", start)],
        states={
            CHOOSE_TEST: [CallbackQueryHandler(test_choice, pattern="^test1$|^test2$")],
            WAITING_FOR_UPLOAD: [
                CallbackQueryHandler(finish_test, pattern="^finish$"),
                MessageHandler(filters.ALL, handle_upload),
            ],
        },
        fallbacks=[CommandHandler("cancel", cancel)],
    )

    app.add_handler(conv)
    app.run_polling()