/**
 * ربات تلگرام مدیریت برنامه‌های روزانه
 * فایل اصلی ربات - نسخه حرفه‌ای 💕
 */
const { Telegraf } = require('telegraf');
const { TOKEN } = require('./config');
const {
    startCommand,
    helpCommand,
    todayCommand,
    reportCommand,
    statsCommand,
    debugRemindersCommand,
    suggestCommand,
    motivateCommand,
    setLazyCommand,
    setScenario1Command,
    setScenario2YesCommand,
    setScenario2NoCommand,
    buttonCallback,
    handleMessage,
    handleSticker
} = require('./handlers');
const { startReminderSystem } = require('./reminders');
const { migrateTasksData } = require('./database');
const { Logger, requestLogger, errorHandler, rateLimiter, validateUser } = require('./middleware');

// تنظیمات اتصال - افزایش timeout و retry
const botOptions = {
    telegram: {
        // افزایش timeout برای جلوگیری از خطا
        timeout: 60000, // 60 ثانیه
        // Retry خودکار
        retryAfter: 1000,
        // Keep-alive
        agent: undefined
    }
};

// ساخت ربات با تنظیمات
const bot = new Telegraf(TOKEN, botOptions);

// تنظیم webhook برای سرور (اختیاری)
const PORT = process.env.PORT || 7618;
const WEBHOOK_URL = process.env.WEBHOOK_URL;

Logger.info('🌐 پورت:', PORT);
Logger.info('🔗 Webhook URL:', WEBHOOK_URL || 'ندارد');
Logger.info('🏭 محیط:', process.env.NODE_ENV || 'development');

// اضافه کردن middleware های حرفه‌ای
bot.use(validateUser());
bot.use(requestLogger());
bot.use(rateLimiter({ maxRequests: 30, windowMs: 60000 })); // 30 درخواست در دقیقه
bot.use(errorHandler());

// مهاجرت داده‌ها در شروع
Logger.info('🔄 بررسی و مهاجرت داده‌ها...');
migrateTasksData();

// اضافه کردن هندلرها
Logger.info('📝 تنظیم هندلرها...');
bot.command('start', startCommand);
bot.command('help', helpCommand);
bot.command('today', todayCommand);
bot.command('report', reportCommand);
bot.command('stats', statsCommand);
bot.command('debug', debugRemindersCommand);
bot.command('suggest', suggestCommand);
bot.command('motivate', motivateCommand);
bot.command('set_lazy', setLazyCommand);
bot.command('set_scenario1', setScenario1Command);
bot.command('set_scenario2_yes', setScenario2YesCommand);
bot.command('set_scenario2_no', setScenario2NoCommand);
bot.hears(/گزارش/i, reportCommand);

// استفاده از action برای callback query (بهتر از on)
bot.action(/.*/, async (ctx) => {
    Logger.debug('🎯 CALLBACK QUERY RECEIVED:', ctx.callbackQuery.data);
    await buttonCallback(ctx);
});

bot.on('sticker', handleSticker);
bot.on('text', handleMessage);
Logger.success('✅ هندلرها تنظیم شدند');

// شروع سیستم یادآوری
startReminderSystem(bot);
Logger.success('✅ سیستم یادآوری فعال است');

// شروع سیستم پشتیبان‌گیری خودکار
const { startAutoBackup } = require('./backup');
startAutoBackup();
Logger.success('✅ سیستم پشتیبان‌گیری فعال است');

// لاگ خطاها با retry پیشرفته
bot.catch(async (err, ctx) => {
    Logger.error(`خطا برای ${ctx.updateType}`, err);

    // Retry برای خطاهای موقت
    if (err.code === 'ETIMEDOUT' || err.code === 'ECONNRESET' || err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED') {
        Logger.warning('⏳ خطای اتصال موقت، در حال تلاش مجدد...');

        // تلاش مجدد خودکار با exponential backoff
        const retryDelays = [2000, 5000, 10000]; // 2s, 5s, 10s
        for (let i = 0; i < retryDelays.length; i++) {
            setTimeout(() => {
                if (ctx && ctx.reply) {
                    ctx.reply(`متأسفم، یه مشکل کوچیک پیش اومد ولی الان درست شد! 💕 (${i + 1}/${retryDelays.length})`).catch(() => {});
                }
            }, retryDelays[i]);
        }
    } else if (err.code === 429) {
        // Rate limit exceeded
        Logger.warning('🚦 Rate limit exceeded، در حال انتظار...');
        const retryAfter = err.response?.retry_after || 30;
        setTimeout(() => {
            if (ctx && ctx.reply) {
                ctx.reply('یه کم صبر کن عزیزم، زیاد سریع پیام فرستادی! 😅').catch(() => {});
            }
        }, retryAfter * 1000);
    } else if (err.code === 403) {
        // Bot was blocked
        Logger.warning('🚫 ربات توسط کاربر بلاک شده');
    } else {
        // سایر خطاها
        Logger.error('💥 خطای نامشخص', err);
        if (ctx && ctx.reply) {
            ctx.reply('اووه، یه خطایی رخ داد! 😟 ولی نگران نباش، مشکل رو برطرف می‌کنم 💕').catch(() => {});
        }
    }
});

// تابع reconnect خودکار
let reconnectAttempts = 0;
const maxReconnectAttempts = Infinity; // بدون محدودیت

async function startBot() {
    try {
        Logger.info('🚀 در حال شروع ربات...');

        // تست اتصال اولیه
        try {
            const botInfo = await bot.telegram.getMe();
            Logger.success(`🤖 ربات یافت شد: @${botInfo.username}`);
        } catch (err) {
            Logger.error('❌ خطا در اتصال به ربات', err);
            throw err;
        }

        if (WEBHOOK_URL) {
            // حالت webhook برای سرور
            Logger.info('🔗 راه‌اندازی webhook...');

            // تنظیم webhook
            await bot.telegram.setWebhook(WEBHOOK_URL, {
                drop_pending_updates: true
            });
            Logger.success('✅ Webhook تنظیم شد');

            // راه‌اندازی express server برای webhook
            const express = require('express');
            const app = express();

            app.use(express.json());
            app.use(bot.webhookCallback('/bot'));

            app.listen(PORT, () => {
                Logger.success(`🌐 سرور webhook روی پورت ${PORT} اجرا شد`);
                Logger.info(`🔗 Webhook URL: ${WEBHOOK_URL}`);
            });

        } else {
            // حالت polling برای توسعه
            Logger.info('📡 راه‌اندازی polling...');

            // پاک کردن webhook اگر وجود داشته باشه
            try {
                await bot.telegram.deleteWebhook({ drop_pending_updates: true });
                Logger.info('🧹 Webhook پاک شد');
            } catch (e) {
                Logger.info('ℹ️ Webhook وجود نداشت');
            }

            await bot.launch({
                dropPendingUpdates: true,
                allowedUpdates: ['message', 'callback_query', 'sticker']
            });
            Logger.success('✅ Polling راه‌اندازی شد');
        }

        Logger.success('🤖 ربات شروع شد... 💕');
        reconnectAttempts = 0;

    } catch (error) {
        Logger.error('❌ خطا در شروع ربات', error);

        if (error.response && error.response.error_code === 409) {
            Logger.warning('⚠️ یک instance دیگه از ربات در حال اجراست!');
            Logger.warning('💡 لطفاً instance قبلی رو متوقف کنید یا چند ثانیه صبر کنید...');
        }

        reconnectAttempts++;
        if (reconnectAttempts < maxReconnectAttempts) {
            const delay = Math.min(5000 * reconnectAttempts, 30000);
            Logger.info(`🔄 تلاش مجدد بعد از ${delay / 1000} ثانیه...`);
            setTimeout(startBot, delay);
        }
    }
}

// هندل کردن خطاهای اتصال - استفاده از catch در bot.launch

// شروع ربات
startBot();

// Graceful stop
process.once('SIGINT', async () => {
    Logger.info('🛑 در حال توقف ربات...');
    await bot.stop('SIGINT');
    process.exit(0);
});

process.once('SIGTERM', async () => {
    Logger.info('🛑 در حال توقف ربات...');
    await bot.stop('SIGTERM');
    process.exit(0);
});

// جلوگیری از crash شدن برنامه
process.on('uncaughtException', (error) => {
    Logger.error('❌ خطای غیرمنتظره', error);
    // به جای crash، لاگ کن و ادامه بده
});

process.on('unhandledRejection', (reason, promise) => {
    Logger.error('❌ Promise رد شده', reason);
    // به جای crash، لاگ کن و ادامه بده
});

// Keep-alive: هر 5 دقیقه یکبار چک کن که ربات زنده است
setInterval(async () => {
    try {
        await bot.telegram.getMe();
        Logger.debug('✅ ربات فعال است');
    } catch (error) {
        Logger.warning('⚠️ مشکل در اتصال، در حال تلاش مجدد...', error.message);
        // تلاش برای reconnect
        startBot();
    }
}, 5 * 60 * 1000); // هر 5 دقیقه

