// app/api/telegram/lib/shop-handler.ts
import { bot, memory } from './config';
import {  Markup } from 'telegraf';
import { TransactionNetwork } from '@/lib/generated/prisma';
import { eventBus, EVENTS } from '../../events/eventBus';
import { transactionProcessor } from '../services/transaction-processor';

import { prisma } from '@/lib/prisma';
// تعریف enum برای مدیریت وضعیت کاربر در فروشگاه
export enum BotState {
    INITIAL = 'INITIAL',
    SELECT_FIRM = 'SELECT_FIRM',
    SELECT_PLAN = 'SELECT_PLAN',
    CONFIRM_PURCHASE = 'CONFIRM_PURCHASE',
    CHARGE_WALLET = 'CHARGE_WALLET',
    SELECT_NETWORK = 'SELECT_NETWORK',
    ENTER_TRANSACTION_HASH = 'ENTER_TRANSACTION_HASH',
}

export async function setupShopHandler() {
    bot.command('shop', async (ctx) => {
        if (!ctx.from) return;

        try {
            // دریافت یا ایجاد کاربر
            const user = await memory.getOrCreateUser(ctx.from);

            // بررسی وضعیت فعلی کاربر
            let botState = await prisma.userBotState.findFirst({
                where: { telegramUserId: user.id }
            });

            // اگر وضعیتی وجود نداشت، ایجاد می‌کنیم
            if (!botState) {
                botState = await prisma.userBotState.create({
                    data: {
                        telegramUserId: user.id,
                        state: BotState.INITIAL,
                        additionalData: {}
                    }
                });
            } else {
                // به روزرسانی وضعیت به حالت اولیه
                await prisma.userBotState.update({
                    where: { id: botState.id },
                    data: {
                        state: BotState.INITIAL,
                        selectedProductId: null,
                        selectedNetwork: null,
                        additionalData: {}
                    }
                });
            }

            // نمایش منوی اصلی فروشگاه
            await showShopMainMenu(ctx, user);
        } catch (error) {
            console.error('Error in shop command:', error);
            await ctx.reply('خطایی رخ داد. لطفاً بعداً دوباره تلاش کنید.');
        }
    });

}

async function showShopMainMenu(ctx: any, user: any) {
    try {
        const telegramUser = await prisma.telegramUser.findUnique({
            where: { id: user.id }
        });

        if (!telegramUser) {
            return await ctx.reply('اطلاعات کاربری شما یافت نشد. لطفاً با پشتیبانی تماس بگیرید.');
        }

        const balance = telegramUser.balance;

        const inlineKeyboard = Markup.inlineKeyboard([
            [Markup.button.callback('🛒 سفارش پاس پراپ چلنج ', 'shop_view_products')],
            [Markup.button.callback('💰 شارژ حساب', 'shop_charge_wallet')],
            [Markup.button.callback('📋 پراپ چلنج های خریداری شده', 'shop_purchased_products')],
            [Markup.button.callback('📊 تاریخچه تراکنش‌ها', 'shop_transactions')],
            [Markup.button.callback('🔙 بازگشت به چت پشتیبانی', 'shop_exit')]
        ]);

        await ctx.reply(
            `🏪 *به فروشگاه خوش آمدید*\n\n` +
            `💵 موجودی فعلی: *${balance}* تتر\n\n` +
            `لطفاً یکی از گزینه‌های زیر را انتخاب کنید:`,
            {
                parse_mode: 'Markdown',
                ...inlineKeyboard
            }
        );
    } catch (error) {
        console.error('Error in showShopMainMenu:', error);
        await ctx.reply('خطایی در نمایش منوی فروشگاه رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// پردازش کال‌بک‌های مربوط به فروشگاه
export async function handleShopCallbacks(ctx: any, data: string, user: any) {
    try {
        await ctx.answerCbQuery();

        const telegramUser = await prisma.telegramUser.findUnique({
            where: { id: user.id }
        });

        if (!telegramUser) {
            return await ctx.reply('اطلاعات کاربری شما یافت نشد. لطفاً با پشتیبانی تماس بگیرید.');
        }

        switch (data) {
            case 'shop_view_products':
                await showFirmsList(ctx, user);
                break;
            case 'shop_charge_wallet':
                await showChargeWalletOptions(ctx, user);
                break;
            case 'shop_purchased_products':
                await showPurchasedProducts(ctx, user);
                break;
            case 'shop_transactions':
                await showTransactionHistory(ctx, user);
                break;
            case 'shop_exit':
                await exitShop(ctx, user);
                break;
            default:
                if (data.startsWith('shop_firm_')) {
                    const firmName = data.split('shop_firm_')[1];
                    await selectFirm(ctx, user, firmName);
                } else if (data.startsWith('shop_plan_')) {
                    const productId = parseInt(data.split('shop_plan_')[1]);
                    await selectPlan(ctx, user, productId);
                } else if (data.startsWith('shop_buy_')) {
                    const productId = parseInt(data.split('shop_buy_')[1]);
                    await purchaseProduct(ctx, user, productId);
                } else if (data.startsWith('shop_network_')) {
                    // انتخاب شبکه
                    const networkName = data.split('shop_network_')[1] as TransactionNetwork;
                    await showNetworkWallet(ctx, user, networkName);
                } else if (data === 'shop_back_to_main') {
                    await showShopMainMenu(ctx, user);
                } else if (data === 'shop_back_to_firms') {
                    await showFirmsList(ctx, user);
                } else if (data === 'shop_start_transaction') {
                    await startTransactionProcess(ctx, user);
                }
                break;
                if (data.startsWith('shop_firm_')) {
                    // انتخاب شرکت
                    const firmName = data.split('shop_firm_')[1];
                    await selectFirm(ctx, user, firmName);
                } else if (data.startsWith('shop_plan_')) {
                    // انتخاب طرح
                    const productId = parseInt(data.split('shop_plan_')[1]);
                    await selectPlan(ctx, user, productId);
                } else if (data.startsWith('shop_buy_')) {
                    // خرید محصول
                    const productId = parseInt(data.split('shop_buy_')[1]);
                    await purchaseProduct(ctx, user, productId);
                } else if (data === 'shop_back_to_main') {
                    // بازگشت به منوی اصلی فروشگاه
                    await showShopMainMenu(ctx, user);
                } else if (data === 'shop_back_to_firms') {
                    // بازگشت به لیست شرکت‌ها
                    await showFirmsList(ctx, user);
                } else if (data === 'shop_start_transaction') {
                    // شروع فرآیند ثبت تراکنش
                    await startTransactionProcess(ctx, user);
                }
                break;
        }
    } catch (error) {
        console.error('Error in handleShopCallbacks:', error);
        await ctx.reply('خطایی در پردازش درخواست رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// نمایش لیست شرکت‌ها
async function showFirmsList(ctx: any, user: any) {
    try {
        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                state: BotState.SELECT_FIRM,
                selectedProductId: null,
                selectedNetwork: null
            }
        });

        // دریافت لیست منحصر به فرد شرکت‌ها
        const firms = await prisma.product.findMany({
            select: {
                firm: true
            },
            distinct: ['firm']
        });

        if (firms.length === 0) {
            return await ctx.reply(
                '⚠️ در حال حاضر محصولی در فروشگاه موجود نیست.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        const buttons = firms.map(firm => {
            return [Markup.button.callback(`${firm.firm}`, `shop_firm_${firm.firm}`)];
        });

        buttons.push([Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]);

        await ctx.reply(
            '🏢 *لیست شرکت‌ها*\n\n' +
            'لطفاً شرکت مورد نظر خود را انتخاب کنید:',
            {
                parse_mode: 'Markdown',
                ...Markup.inlineKeyboard(buttons)
            }
        );
    } catch (error) {
        console.error('Error in showFirmsList:', error);
        await ctx.reply('خطایی در نمایش لیست شرکت‌ها رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// انتخاب شرکت و نمایش طرح‌های آن
async function selectFirm(ctx: any, user: any, firmName: string) {
    try {
        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                state: BotState.SELECT_PLAN,
                additionalData: { selectedFirm: firmName }
            }
        });

        // دریافت پراپ چلنج های شرکت انتخاب شده
        const products = await prisma.product.findMany({
            where: {
                firm: firmName
            }
        });

        if (products.length === 0) {
            return await ctx.reply(
                `⚠️ در حال حاضر محصولی برای شرکت ${firmName} موجود نیست.`,
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به لیست شرکت‌ها', 'shop_back_to_firms')]
                ])
            );
        }

        // بررسی پراپ چلنج های خریداری شده توسط کاربر
        const purchasedProducts = await prisma.userProduct.findMany({
            where: {
                userId: user.id,
                challengeStatus: 'PENDING',
                product: {
                    firm: firmName
                }
            },
            select: {
                productId: true
            }
        });

        const purchasedProductIds = purchasedProducts.map(p => p.productId);

        // ایجاد دکمه‌های پراپ چلنج های
        const buttons = products.map(product => {
            const isPurchased = purchasedProductIds.includes(product.id);
            const buttonText = isPurchased
                ? `✅ ${product.plan} - ${product.price} تتر (خریداری شده)`
                : `${product.plan} - ${product.price} تتر`;

            return [Markup.button.callback(
                buttonText,
                isPurchased ? 'shop_already_purchased' : `shop_plan_${product.id}`
            )];
        });

        buttons.push([Markup.button.callback('🔙 بازگشت به لیست شرکت‌ها', 'shop_back_to_firms')]);

        await ctx.reply(
            `🏢 *پراپ چلنج های شرکت ${firmName}*\n\n` +
            'لطفاً طرح مورد نظر خود را انتخاب کنید:',
            {
                parse_mode: 'Markdown',
                ...Markup.inlineKeyboard(buttons)
            }
        );
    } catch (error) {
        console.error('Error in selectFirm:', error);
        await ctx.reply('خطایی در نمایش پراپ چلنج های رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// انتخاب طرح و نمایش جزئیات آن
async function selectPlan(ctx: any, user: any, productId: number) {
    try {
        // دریافت اطلاعات محصول
        const product = await prisma.product.findUnique({
            where: { id: productId }
        });

        if (!product) {
            return await ctx.reply(
                '⚠️ محصول مورد نظر یافت نشد.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // دریافت اطلاعات کاربر برای چک کردن موجودی
        const telegramUser = await prisma.telegramUser.findUnique({
            where: { id: user.id }
        });

        if (!telegramUser) {
            return await ctx.reply('اطلاعات کاربری شما یافت نشد. لطفاً با پشتیبانی تماس بگیرید.');
        }

        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                selectedProductId: productId
            }
        });

        const balance = telegramUser.balance;
        const hasEnoughBalance = balance >= product.price;

        let messageText = `📋 *جزئیات محصول*\n\n`;
        messageText += `🏢 *شرکت:* ${product.firm}\n`;
        messageText += `📝 *طرح:* ${product.plan}\n`;
        messageText += `💰 *قیمت:* ${product.price} تتر\n`;

        if (product.description) {
            messageText += `\n📄 *توضیحات:*\n${product.description}\n`;
        }

        messageText += `\n💵 *موجودی شما:* ${balance.toFixed(2)} تتر\n`;

        if (!hasEnoughBalance) {
            const missingAmount = product.price - balance;
            messageText += `\n⚠️ *موجودی شما کافی نیست*\n`;
            messageText += `برای خرید این محصول به ${missingAmount.toFixed(2)} تتر دیگر نیاز دارید.`;
        }

        const buttons = [];

        if (hasEnoughBalance) {
            buttons.push([Markup.button.callback('🛒 خرید محصول', `shop_buy_${productId}`)]);
        } else {
            buttons.push([Markup.button.callback('💰 شارژ حساب', 'shop_charge_wallet')]);
        }

        buttons.push([Markup.button.callback('🔙 بازگشت به لیست طرح‌ها', 'shop_back_to_firms')]);
        buttons.push([Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]);

        await ctx.reply(messageText, {
            parse_mode: 'Markdown',
            ...Markup.inlineKeyboard(buttons)
        });
    } catch (error) {
        console.error('Error in selectPlan:', error);
        await ctx.reply('خطایی در نمایش جزئیات محصول رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// خرید محصول
async function purchaseProduct(ctx: any, user: any, productId: number) {
    try {
        const product = await prisma.product.findUnique({
            where: { id: productId }
        });
        if (!product) {
            return await ctx.reply(
                '⚠️ محصول مورد نظر یافت نشد.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }
        const telegramUser = await prisma.telegramUser.findUnique({
            where: { id: user.id }
        });
        if (!telegramUser) {
            return await ctx.reply('اطلاعات کاربری شما یافت نشد. لطفاً با پشتیبانی تماس بگیرید.');
        }
        const balance = telegramUser.balance;
        if (balance < product.price) {
            const missingAmount = product.price - balance;
            return await ctx.reply(
                `⚠️ *موجودی شما کافی نیست*\n\n` +
                `برای خرید این محصول به ${missingAmount.toFixed(2)} تتر دیگر نیاز دارید.`,
                {
                    parse_mode: 'Markdown',
                    ...Markup.inlineKeyboard([
                        [Markup.button.callback('💰 شارژ حساب', 'shop_charge_wallet')],
                        [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                    ])
                }
            );
        }
        const existingPurchase = await prisma.userProduct.findFirst({
            where: {
                userId: user.id,
                productId: productId,
                challengeStatus: 'PENDING'
            }
        });
        if (existingPurchase) {
            return await ctx.reply(
                '⚠️ شما قبلاً این محصول را خریداری کرده‌اید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }


        // Modify your code like this:
        const createdUserProduct = await prisma.$transaction(async (tx) => {
            await tx.telegramUser.update({
                where: { id: user.id },
                data: {
                    balance: {
                        decrement: product.price
                    }
                }
            });

            // Return this value from the transaction
            return await tx.userProduct.create({
                data: {
                    userId: user.id,
                    productId: productId,
                    challengeStatus: 'PENDING'
                }
            });
        });
        eventBus.emit(EVENTS.PRODUCT_BOUGHT, createdUserProduct);


        await ctx.reply(
            `🎉 *تبریک! خرید شما با موفقیت انجام شد*\n\n` +
            `🏢 *شرکت:* ${product.firm}\n` +
            `📝 *طرح:* ${product.plan}\n` +
            `💰 *قیمت:* ${product.price} تتر\n\n` +
            `اکنون می‌توانید از این محصول استفاده کنید.`,
            {
                parse_mode: 'Markdown',
                ...Markup.inlineKeyboard([
                    [Markup.button.callback('📋 مشاهده پراپ چلنج های خریداری شده', 'shop_purchased_products')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            }
        );
    } catch (error) {
        console.error('Error in purchaseProduct:', error);
        await ctx.reply('خطایی در فرآیند خرید رخ داد. لطفاً با پشتیبانی تماس بگیرید.');
    }
}

// نمایش پراپ چلنج های خریداری شده
async function showPurchasedProducts(ctx: any, user: any) {
    try {
        // دریافت پراپ چلنج های خریداری شده توسط کاربر
        const purchases = await prisma.userProduct.findMany({
            where: {
                userId: user.id,
                challengeStatus: 'PENDING'
            },
            include: {
                product: true
            },
            orderBy: {
                createdAt: 'desc'
            }
        });

        if (purchases.length === 0) {
            return await ctx.reply(
                '⚠️ شما هنوز محصولی خریداری نکرده‌اید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🛒 مشاهده پراپ چلنج های', 'shop_view_products')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        let messageText = `📋 *پراپ چلنج های خریداری شده*\n\n`;

        purchases.forEach((purchase, index) => {
            messageText += `${index + 1}. *${purchase.product.firm} - ${purchase.product.plan}*\n`;
            messageText += `   💰 قیمت: ${purchase.product.price} تتر\n`;
            messageText += `   🕒 تاریخ خرید: ${purchase.createdAt.toLocaleDateString('fa-IR')}\n\n`;
        });

        await ctx.reply(messageText, {
            parse_mode: 'Markdown',
            ...Markup.inlineKeyboard([
                [Markup.button.callback('🛒 خرید محصول جدید', 'shop_view_products')],
                [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
            ])
        });
    } catch (error) {
        console.error('Error in showPurchasedProducts:', error);
        await ctx.reply('خطایی در نمایش پراپ چلنج های خریداری شده رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// نمایش تاریخچه تراکنش‌ها
async function showTransactionHistory(ctx: any, user: any) {
    try {
        // دریافت تراکنش‌های کاربر
        const transactions = await prisma.userTransaction.findMany({
            where: {
                telegramUserId: user.id
            },
            orderBy: {
                createdAt: 'desc'
            }
        });

        if (transactions.length === 0) {
            return await ctx.reply(
                '⚠️ تاریخچه تراکنش‌های شما خالی است.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('💰 شارژ حساب', 'shop_charge_wallet')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        let messageText = `📊 *تاریخچه تراکنش‌ها*\n\n`;

        transactions.forEach((transaction, index) => {
            messageText += `${index + 1}. *${transaction.value} تتر*\n`;
            messageText += `   🔄 وضعیت: ${getStatusText(transaction.status)}\n`;
            messageText += `   🌐 شبکه: ${transaction.network}\n`;
            messageText += `   🕒 تاریخ: ${transaction.createdAt.toLocaleDateString('fa-IR')}\n\n`;
        });

        await ctx.reply(messageText, {
            parse_mode: 'Markdown',
            ...Markup.inlineKeyboard([
                [Markup.button.callback('💰 شارژ حساب جدید', 'shop_charge_wallet')],
                [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
            ])
        });
    } catch (error) {
        console.error('Error in showTransactionHistory:', error);
        await ctx.reply('خطایی در نمایش تاریخچه تراکنش‌ها رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// نمایش wallet address بر اساس شبکه انتخاب شده
async function showNetworkWallet(ctx: any, user: any, networkName:  TransactionNetwork) {
    try {
        // دریافت آدرس‌های کیف پول برای شبکه انتخاب شده
        const wallets = await prisma.wallet.findMany({
            where: {
                network: networkName
            },
            orderBy: {
                id: 'asc'
            }
        });

        if (wallets.length === 0) {
            return await ctx.reply(
                `⚠️ آدرس کیف پولی برای شبکه ${networkName} یافت نشد.`,
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به انتخاب شبکه', 'shop_charge_wallet')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // به‌روزرسانی وضعیت کاربر با ذخیره شبکه انتخاب شده
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                selectedNetwork: networkName,
                additionalData: { selectedNetwork: networkName }
            }
        });

        let messageText = `💰 *شارژ حساب - شبکه ${networkName}*\n\n`;
        messageText += `برای شارژ حساب خود، لطفاً مبلغ مورد نظر را به آدرس زیر واریز کنید:\n\n`;

        wallets.forEach((wallet) => {
            messageText += `*${wallet.name}*\n`;
            messageText += `\`${wallet.address}\`\n\n`;

            if (wallet.description) {
                messageText += `${wallet.description}\n\n`;
            }
        });

        messageText += `⚠️ *توجه مهم:*\n`;
        messageText += `- لطفاً فقط از شبکه ${networkName} استفاده کنید\n`;
        messageText += `- پس از واریز، دکمه «ثبت تراکنش» را بزنید\n`;
        messageText += `- حساب شما پس از بررسی و تأیید تراکنش شارژ خواهد شد`;

        await ctx.reply(messageText, {
            parse_mode: 'Markdown',
            ...Markup.inlineKeyboard([
                [Markup.button.callback('📝 ثبت تراکنش', 'shop_start_transaction')],
                [Markup.button.callback('🔙 بازگشت به انتخاب شبکه', 'shop_charge_wallet')],
                [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
            ])
        });
    } catch (error) {
        console.error('Error in showNetworkWallet:', error);
        await ctx.reply('خطایی در نمایش اطلاعات کیف پول رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// نمایش گزینه‌های شارژ کیف پول
async function showChargeWalletOptions(ctx: any, user: any) {
    try {
        // دریافت شبکه‌های موجود
        const networks = await prisma.wallet.findMany({
            select: {
                network: true
            },
            distinct: ['network']
        });

        if (networks.length === 0) {
            return await ctx.reply(
                '⚠️ در حال حاضر امکان شارژ حساب وجود ندارد. لطفاً با پشتیبانی تماس بگیرید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                state: BotState.SELECT_NETWORK
            }
        });

        let messageText = `💰 *انتخاب شبکه برای شارژ حساب*\n\n`;
        messageText += `لطفاً شبکه مورد نظر خود را انتخاب کنید:`;

        // ایجاد دکمه‌های شبکه
        const buttons = networks.map(network => {
            return [Markup.button.callback(`${network.network}`, `shop_network_${network.network}`)];
        });

        buttons.push([Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]);

        await ctx.reply(messageText, {
            parse_mode: 'Markdown',
            ...Markup.inlineKeyboard(buttons)
        });
    } catch (error) {
        console.error('Error in showChargeWalletOptions:', error);
        await ctx.reply('خطایی در نمایش گزینه‌های شارژ حساب رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// شروع فرآیند ثبت تراکنش (ادامه)
async function startTransactionProcess(ctx: any, user: any) {
    try {
        // دریافت وضعیت فعلی کاربر
        const userState = await prisma.userBotState.findFirst({
            where: { telegramUserId: user.id }
        });

        if (!userState || !userState.selectedNetwork) {
            return await ctx.reply(
                '⚠️ لطفاً ابتدا شبکه را انتخاب کنید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('💰 انتخاب شبکه', 'shop_charge_wallet')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                state: BotState.ENTER_TRANSACTION_HASH
            }
        });

        await ctx.reply(
            `📝 *ثبت تراکنش - شبکه ${userState.selectedNetwork}*\n\n` +
            'لطفاً هش (Transaction Hash) تراکنش خود را وارد کنید:\n\n' +
            '⚠️ *توجه:* پس از ثبت تراکنش، حساب شما در انتظار بررسی و تأیید قرار خواهد گرفت.',
            {
                parse_mode: 'Markdown',
                ...Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 انصراف', 'shop_back_to_main')]
                ])
            }
        );
    } catch (error) {
        console.error('Error in startTransactionProcess:', error);
        await ctx.reply('خطایی در شروع فرآیند ثبت تراکنش رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}



export async function handleTransactionHashInput(ctx: any, user: any, userState: any) {
    try {
        const transactionHash = ctx.message.text.trim();

        // بررسی فرمت اولیه هش
        if (transactionHash.length < 30) {
            return await ctx.reply(
                '⚠️ هش تراکنش وارد شده معتبر نیست. لطفاً مجدداً تلاش کنید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // بررسی اینکه آیا این هش قبلاً استفاده شده است
        const existingTransaction = await prisma.userTransaction.findUnique({
            where: {
                transactionHash: transactionHash
            }
        });

        if (existingTransaction) {
            return await ctx.reply(
                '⚠️ این هش تراکنش قبلاً ثبت شده است. لطفاً هش دیگری وارد کنید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // دریافت شبکه انتخاب شده از state
        const selectedNetwork = userState.selectedNetwork || userState.additionalData?.selectedNetwork;
        
        if (!selectedNetwork) {
            return await ctx.reply(
                '⚠️ شبکه انتخاب شده یافت نشد. لطفاً مجدداً فرآیند شارژ حساب را آغاز کنید.',
                Markup.inlineKeyboard([
                    [Markup.button.callback('💰 شارژ حساب', 'shop_charge_wallet')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            );
        }

        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                state: BotState.INITIAL,
                selectedNetwork: null,
                additionalData: {}
            }
        });

        // ثبت تراکنش در وضعیت PENDING
        const createdTransaction = await prisma.userTransaction.create({
            data: {
                telegramUserId: user.id,
                transactionHash: transactionHash,
                network: selectedNetwork as any,
                value: 0,
                status: 'PENDING'
            }
        });

        // شروع پردازش تراکنش
        await transactionProcessor.startProcessing(createdTransaction.id);

        // نمایش پیام تأیید ثبت
        await ctx.reply(
            `✅ *تراکنش شما با موفقیت ثبت شد*\n\n` +
            `🔗 *هش تراکنش:* \`${transactionHash}\`\n` +
            `🌐 *شبکه:* ${selectedNetwork}\n` +
            `🔄 *وضعیت:* در حال بررسی\n\n` +
            `⏳ تراکنش شما در حال بررسی است و به محض تأیید، به شما اطلاع داده خواهد شد.\n` +
            `🔍 این فرآیند ممکن است چند دقیقه طول بکشد.\n\n` +
            `📱 برای پیگیری وضعیت تراکنش، از بخش «تاریخچه تراکنش‌ها» استفاده کنید.`,
            {
                parse_mode: 'Markdown',
                ...Markup.inlineKeyboard([
                    [Markup.button.callback('📊 تاریخچه تراکنش‌ها', 'shop_transactions')],
                    [Markup.button.callback('🔙 بازگشت به منوی فروشگاه', 'shop_back_to_main')]
                ])
            }
        );

    } catch (error) {
        console.error('Error in handleTransactionHashInput:', error);
        await ctx.reply('خطایی در ثبت تراکنش رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}




// خروج از فروشگاه
async function exitShop(ctx: any, user: any) {
    try {
        // به‌روزرسانی وضعیت کاربر
        await prisma.userBotState.updateMany({
            where: { telegramUserId: user.id },
            data: {
                state: BotState.INITIAL,
                selectedProductId: null,
                selectedNetwork: null,
                additionalData: {}
            }
        });

        await ctx.reply('شما از بخش فروشگاه خارج شدید. برای ورود مجدد میتونین از /shop استفاده کنین.');
    } catch (error) {
        console.error('Error in exitShop:', error);
        await ctx.reply('خطایی در خروج از فروشگاه رخ داد. لطفاً بعداً دوباره تلاش کنید.');
    }
}

// تبدیل وضعیت تراکنش به متن فارسی
function getStatusText(status: string): string {
    switch (status) {
        case 'PENDING':
            return '🕒 در انتظار تأیید';
        case 'SUCCESS': // اصلاح نام
            return '✅ تأیید شده';
        case 'FAILED':
            return '❌ رد شده';
        default:
            return status;
    }
}