// app/api/telegram/route.ts
import { NextRequest, NextResponse } from 'next/server';
import type { Update } from 'telegraf/types';
import { setupBotHandlers } from './lib/bot-handlers';
import {
    bot,
    getBotInitialized,
    setBotInitialized,
    getIsLaunching,
    setIsLaunching,
    setCoreServicesInitialized,
    initializeCoreServices,
    stopBot
} from './lib/config';
import { initNotifications } from '../events/notificationService';
import { transactionProcessor } from './services/transaction-processor';

async function initializeBot() {
    if (!process.env.PINECONE_API_KEY) {
        console.error("ERROR: PINECONE_API_KEY environment variable is not set.");
        return NextResponse.json({ ok: false, error: "PINECONE_API_KEY environment variable is not set." }, { status: 500 });
    }
    if (!process.env.OPENROUTER_API_KEY) {
        console.error("ERROR: OPENROUTER_API_KEY environment variable is not set.");
        return NextResponse.json({ ok: false, error: "OPENROUTER_API_KEY environment variable is not set." }, { status: 500 });
    }

    console.log("🏁 Initial BOT");
    await transactionProcessor.checkPendingTransactions();
    // Reset core services to ensure fresh initialization
    setCoreServicesInitialized(false);
    await initializeCoreServices();
    await setupBotHandlers();

    if (process.env.MODE === 'prod') {
        console.log('Starting bot in webhook mode');
        const webhookUrl = process.env.WEBHOOK_URL || '';
        if (!webhookUrl) {
            console.error("ERROR: WEBHOOK_URL is not set for prod mode.");
            return;
        }
        try {
            // Always delete existing webhook first in prod mode
            console.log('Deleting existing webhook before setting new one...');
            await bot.telegram.deleteWebhook({ drop_pending_updates: true });
            console.log('Webhook deleted.');

            // Set the new webhook
            await bot.telegram.setWebhook(webhookUrl);
            console.log(`Webhook set to: ${webhookUrl}`);
        } catch (error) {
            console.error("Error setting up webhook:", error);
        }
    } else {
        if (getIsLaunching()) {
            return;
        }
        setIsLaunching(true);
        console.log('Starting bot in polling mode');
        try {
            const webhookInfo = await bot.telegram.getWebhookInfo();
            if (webhookInfo.url) {
                console.log('Deleting existing webhook before polling...');
                await bot.telegram.deleteWebhook({ drop_pending_updates: true });
                console.log('Webhook deleted.');
            }
        } catch (error) {
            console.error("Error checking/deleting webhook for polling mode:", error);
        }
        bot.launch()
            .then(() => {
                console.log('Bot launched successfully in polling mode.');
                setIsLaunching(false);
            })
            .catch(err => {
                if (err.toString().includes('409')) {
                    console.error('Bot is already running. ✅');
                } else {
                    console.error(err);
                }
                setIsLaunching(false);
            });
        process.once('SIGINT', () => {
            console.log('SIGINT received, stopping bot...');
            bot.stop('SIGINT');
            process.exit(0);
        });
        process.once('SIGTERM', () => {
            console.log('SIGTERM received, stopping bot...');
            bot.stop('SIGTERM');
            process.exit(0);
        });
    }
    setBotInitialized(true);
}

export async function POST(req: NextRequest) {
    if (!bot?.telegram) {
        console.error("Bot not initialized or telegram object missing in POST.");
        return NextResponse.json(
            { ok: false, error: "Bot not ready" },
            { status: 503 }
        );
    }
    if (process.env.MODE === 'prod') {
        try {
            const update: Update = await req.json();
            if (typeof bot.handleUpdate === 'function') {
                await bot.handleUpdate(update);
            } else {
                console.error("bot.handleUpdate is not a function. Bot might not be fully initialized.");
                throw new Error("Bot not ready to handle updates.");
            }
            return NextResponse.json({ ok: true });
        } catch (error) {
            console.error('Error in webhook POST handler:', error);
            return NextResponse.json(
                { ok: false, error: (error instanceof Error ? error.message : String(error)) },
                { status: 500 }
            );
        }
    } else {
        return NextResponse.json({
            ok: false,
            message: 'Webhook POST not active in development/polling mode'
        }, { status: 405 });
    }
}

export async function GET() {


    try {

        initNotifications();

        // Stop the bot if it's already running
        if (getBotInitialized()) {
            console.log("Bot is already initialized. Stopping for restart...");
            await stopBot();
        }

        // Reset initialization flags to force restart
        setBotInitialized(false);
        setIsLaunching(false);
        setCoreServicesInitialized(false);

        // Initialize the bot again
        await initializeBot().catch(err => {
            console.error('CRITICAL: Failed to initialize bot on restart:', err);
            throw err;
        });

        if (!bot?.telegram) {
            console.error("Bot not initialized or telegram object missing after restart.");
            return NextResponse.json(
                { ok: false, error: "Bot failed to restart properly" },
                { status: 503 }
            );
        }

        if (process.env.MODE === 'prod') {
            const webhookUrl = process.env.WEBHOOK_URL || '';
            if (!webhookUrl) {
                console.error("WEBHOOK_URL not set for GET request in prod mode.");
                return NextResponse.json(
                    { ok: false, error: "Webhook URL not configured" },
                    { status: 500 }
                );
            }

            const webhookInfo = await bot.telegram.getWebhookInfo();
            return NextResponse.json({
                ok: true,
                message: 'Bot restarted successfully with webhook',
                url: webhookInfo.url
            });
        } else {
            return NextResponse.json({
                ok: true,
                message: 'Bot restarted successfully in polling mode'
            });
        }
    } catch (error) {
        console.error('Error in restart handler:', error);
        return NextResponse.json(
            { ok: false, error: (error instanceof Error ? error.message : String(error)) },
            { status: 500 }
        );
    }
}