/**
 * هندلرهای دستورات و پیام‌های ربات
 */
const path = require('path');
const { addTask, getUserTasks, markTaskDone, markTaskAware, getTodayTasksStats, getOverdueTasks } = require('./database');
const {
    setLazySticker,
    setScenario1Sticker,
    setScenario2YesSticker,
    setScenario2NoSticker
} = require('./stickerManager');
const {
    getHelpMessage,
    formatTaskMessage,
    formatTodayTasks,
    getCompletionMessage,
    getThankYouResponse,
    getPositiveResponse,
    getComplimentResponse,
    getGreetingResponse,
    getHowAreYouResponse,
    getAboutMessage,
    getRandomScenario,
    getRandomSuccessSticker,
    getLazySticker,
    formatDailyReport
} = require('./messages');
const { getTaskKeyboard, getMainKeyboard } = require('./keyboards');

// تابع کمکی برای ارسال استیکر از مسیر
async function sendStickerByPath(ctx, stickerPath) {
    if (!stickerPath) {
        console.error('❌ مسیر استیکر خالی است');
        return;
    }

    try {
        const fullPath = path.resolve(__dirname, stickerPath);
        const fs = require('fs');
        
        // چک کردن وجود فایل
        if (!fs.existsSync(fullPath)) {
            console.error(`❌ فایل استیکر پیدا نشد: ${fullPath}`);
            console.error(`🔍 مسیر کامل: ${fullPath}`);
            console.error(`🔍 مسیر نسبی: ${stickerPath}`);
            return;
        }

        console.log(`📤 ارسال استیکر: ${fullPath}`);
        const stickerBuffer = fs.readFileSync(fullPath);

        if (stickerPath.endsWith('.webm')) {
            await ctx.replyWithAnimation({ source: stickerBuffer });
        } else if (stickerPath.endsWith('.webp')) {
            await ctx.replyWithSticker({ source: stickerBuffer });
        } else {
            await ctx.replyWithPhoto({ source: stickerBuffer });
        }
        
        console.log(`✅ استیکر ارسال شد: ${stickerPath}`);
    } catch (error) {
        console.error('❌ خطا در ارسال استیکر:', error);
        console.error('🔍 جزئیات خطا:', error.message);
        console.error('🔍 مسیر استیکر:', stickerPath);
        // دیگر سعی نمی‌کنیم به عنوان file_id بفرستیم چون اشتباهه
    }
}

function detectMessageType(text) {
    const textLower = text.toLowerCase().trim();
    
    // کلمات سلام
    const greetingKeywords = [
        'سلام', 'سلامت', 'درود', 'صبح بخیر', 'ظهر بخیر', 'عصر بخیر', 'شب بخیر',
        'hi', 'hello', 'hey', 'good morning', 'good afternoon', 'good evening', 'good night'
    ];
    
    // کلمات "خوبی" و احوال‌پرسی
    const howAreYouKeywords = [
        'خوبی', 'چطوری', 'چطوره', 'چطور', 'حالت چطوره', 'حال چطوره',
        'how are you', 'how are u', 'how r u', 'whats up', 'sup'
    ];
    
    // کلمات تشکر
    const thanksKeywords = [
        'ممنون', 'ممنونم', 'مرسی', 'مچکرم', 'تشکر', 'تشکرم',
        'thank', 'thanks', 'thank you', 'thx', 'tnx',
        'خواهش', 'خواهش می‌کنم', 'قربونت', 'قربان', 'فدات'
    ];
    
    // سوالات درباره ربات
    const aboutKeywords = [
        'تو کی هستی', 'تو چی هستی', 'تو کیهستی', 'تو کیه', 'کی هستی',
        'چی هستی', 'کیهستی', 'معرفی کن', 'خودت رو معرفی کن',
        'who are you', 'what are you', 'introduce yourself'
    ];
    
    // کلمات مثبت و دوستانه (بدون آره/نه چون برای سناریوها استفاده می‌شن)
    const positiveKeywords = [
        'عالی', 'عالیه', 'خوب', 'خوبه', 'عالی بود', 'خوب بود',
        'قشنگ', 'قشنگه', 'زیبا', 'زیباست', 'دوست دارم', 'دوستت دارم',
        'great', 'good', 'nice', 'awesome', 'amazing', 'wonderful',
        'خوشم اومد', 'خوشم میاد', 'خوشحالم', 'خوشحال شدم',
        'عالیه', 'خوبه', 'قشنگه', 'زیباست'
    ];

    // کلمات تعریف و تمجید
    const complimentKeywords = [
        'بهترین', 'بهترینی', 'عالی', 'عالیه', 'قشنگ', 'زیبا',
        'دوست‌داشتنی', 'بانمک', 'عزیز', 'گل', 'پرنسس',
        'best', 'beautiful', 'cute', 'lovely', 'sweet', 'amazing',
        'تو بهترینی', 'تو عالی', 'تو قشنگی', 'تو زیبایی'
    ];

    // کلمات گزارش
    const reportKeywords = [
        'گزارش', 'گزارش بده', 'گزارش روز', 'گزارش روزانه',
        'report', 'daily report', 'show report'
    ];
    
    // چک کردن سلام
    for (const keyword of greetingKeywords) {
        if (textLower.includes(keyword)) {
            return 'greeting';
        }
    }
    
    // چک کردن "خوبی"
    for (const keyword of howAreYouKeywords) {
        if (textLower.includes(keyword)) {
            return 'how_are_you';
        }
    }
    
    // چک کردن سوالات درباره ربات
    for (const keyword of aboutKeywords) {
        if (textLower.includes(keyword)) {
            return 'about';
        }
    }
    
    // چک کردن تشکر
    for (const keyword of thanksKeywords) {
        if (textLower.includes(keyword)) {
            return 'thanks';
        }
    }
    
    // چک کردن تعریف
    for (const keyword of complimentKeywords) {
        if (textLower.includes(keyword)) {
            return 'compliment';
        }
    }

    // چک کردن پیام مثبت
    for (const keyword of positiveKeywords) {
        if (textLower.includes(keyword)) {
            return 'positive';
        }
    }

    // چک کردن گزارش
    for (const keyword of reportKeywords) {
        if (textLower.includes(keyword)) {
            return 'report';
        }
    }
    
    return null;
}

// تبدیل اعداد فارسی به انگلیسی
function persianToEnglish(str) {
    const persianDigits = ['۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹'];
    const englishDigits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
    
    let result = str;
    for (let i = 0; i < persianDigits.length; i++) {
        result = result.replace(new RegExp(persianDigits[i], 'g'), englishDigits[i]);
    }
    return result;
}

function parseTimeAndTask(text) {
    text = text.trim();
    
    // تبدیل اعداد فارسی به انگلیسی
    text = persianToEnglish(text);

    // حذف "ساعت" از ابتدا یا وسط متن (اختیاری)
    text = text.replace(/^ساعت\s*/i, '').replace(/\s*ساعت\s*/i, ' ');

    // جستجوی الگوی زمان دقیق (HH:MM یا H:MM)
    // الگوهای مختلف: 23:00, 2:30, ۲۳:۰۰ (فارسی)
    const timePatterns = [
        /(\d{1,2}):(\d{2})/,           // 23:00 یا 2:30
        /(\d{1,2})\s*:\s*(\d{2})/,     // با فاصله: 23 : 00
        /(\d{1,2})\s+(\d{2})/          // بدون دو نقطه: 23 00
    ];

    let match = null;
    let usedPattern = null;

    for (const pattern of timePatterns) {
        match = text.match(pattern);
        if (match) {
            usedPattern = pattern;
            break;
        }
    }

    if (!match) {
        return [null, null];
    }

    const hour = parseInt(match[1]);
    const minute = parseInt(match[2]);

    // اعتبارسنجی زمان
    if (!(hour >= 0 && hour < 24 && minute >= 0 && minute < 60)) {
        return [null, null];
    }

    // فرمت کردن زمان به HH:MM
    const timeStr = `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`;

    // استخراج کار (بعد از کاما یا بعد از زمان)
    let task;
    const commaPos = text.indexOf('،') !== -1 ? text.indexOf('،') : text.indexOf(',');

    if (commaPos !== -1) {
        task = text.substring(commaPos + 1).trim();
    } else {
        // اگر کاما نبود، بعد از زمان را بگیر
        const timeEndIndex = match.index + match[0].length;
        task = text.substring(timeEndIndex).trim();
        
        // حذف کلمات اضافی مثل "ساعت" از وسط
        task = task.replace(/^ساعت\s*/i, '');
        // حذف کاما یا فاصله اضافی
        task = task.replace(/^[،,\s]+/, '');
    }

    // اگر task خالی بود، سعی کن کل متن رو به عنوان task بگیر (مثل "23:00 خواب")
    if (!task || task.length < 2) {
        // اگر فقط زمان بود و بعدش کلمه‌ای بود
        const words = text.split(/\s+/);
        const timeIndex = words.findIndex(w => w.match(/(\d{1,2}):(\d{2})/));
        
        if (timeIndex !== -1 && timeIndex < words.length - 1) {
            task = words.slice(timeIndex + 1).join(' ').trim();
            // حذف کاما از ابتدا
            task = task.replace(/^[،,\s]+/, '');
        }
    }

    if (!task || task.length < 2) {
        return [null, null];
    }

    return [timeStr, task];
}

async function startCommand(ctx) {
    await ctx.reply(getHelpMessage(), {
        reply_markup: getMainKeyboard()
    });
}

async function helpCommand(ctx) {
    await ctx.reply(getHelpMessage(), {
        reply_markup: getMainKeyboard()
    });
}

async function todayCommand(ctx) {
    const userId = ctx.from.id.toString();
    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
    
    const tasks = getUserTasks(userId, today);
    const message = formatTodayTasks(tasks);
    
    await ctx.reply(message, {
        reply_markup: getMainKeyboard()
    });
}

async function reportCommand(ctx) {
    const userId = ctx.from.id.toString();
    const today = new Date().toISOString().split('T')[0];

    const stats = getTodayTasksStats(userId, today);
    const report = formatDailyReport(stats);

    await ctx.reply(report, {
        reply_markup: getMainKeyboard()
    });
}

async function statsCommand(ctx) {
    const userId = ctx.from.id.toString();
    const gamification = require('./gamification');
    const stats = gamification.getUserStats(userId);
    
    // دریافت آمار امروز برای نمایش دقیق‌تر
    const today = new Date().toISOString().split('T')[0];
    const todayStats = getTodayTasksStats(userId, today);
    const todayTasks = getUserTasks(userId, today);

    let message = `📊 آمار کامل مائده جان:\n\n`;
    
    // آمار کلی
    message += `⭐ امتیاز: ${stats.points}\n`;
    message += `🏆 سطح: ${stats.level}\n`;
    message += `🔥 استریک فعلی: ${stats.streak} روز\n`;
    message += `🏅 بهترین استریک: ${stats.longestStreak} روز\n`;
    message += `📈 نرخ تکمیل کلی: ${stats.completionRate}%\n`;
    message += `🏅 روزهای کامل: ${stats.perfectDays}\n\n`;
    
    // آمار امروز
    message += `📅 آمار امروز:\n`;
    message += `📋 تعداد کارها: ${todayTasks.length}\n`;
    message += `✅ انجام شده: ${todayStats.totalDone}\n`;
    message += `⏳ باقی‌مانده: ${todayTasks.length - todayStats.totalDone}\n`;
    if (todayTasks.length > 0) {
        const todayCompletionRate = Math.round((todayStats.totalDone / todayTasks.length) * 100);
        message += `📊 نرخ تکمیل امروز: ${todayCompletionRate}%\n`;
    }
    message += `\n`;
    
    // تحلیل رفتاری
    const insights = [];
    if (stats.behavioralInsights.morningPerson) insights.push('🌅 آدم صبحونه!');
    if (stats.behavioralInsights.nightOwl) insights.push('🦉 آدم شبه!');
    if (stats.behavioralInsights.consistent) insights.push('🎯 منظمی!');
    if (stats.behavioralInsights.procrastinator) insights.push('⏰ گاهی تعویق می‌اندازه');
    if (stats.behavioralInsights.overAchiever) insights.push('🚀 فوق‌العاده‌ای!');
    
    if (insights.length > 0) {
        message += `🎯 تحلیل رفتاری:\n`;
        insights.forEach(insight => {
            message += `${insight}\n`;
        });
    } else {
        message += `🎯 تحلیل رفتاری: در حال یادگیری الگوهای رفتاری تو... 💕\n`;
    }

    await ctx.reply(message, {
        reply_markup: getMainKeyboard()
    });
}

async function debugRemindersCommand(ctx) {
    const userId = ctx.from.id.toString();
    const { getPendingReminders, getTasksNotDoneAfterReminder, loadTasks } = require('./database');

    const now = new Date();
    const currentTime = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;

    let message = `🔧 اطلاعات debug یادآوری‌ها:\n\n`;
    message += `🕐 زمان فعلی: ${currentTime}\n\n`;

    // نمایش کارها
    const userTasks = loadTasks()[userId] || [];
    message += `📋 کارهایت (${userTasks.length} تا):\n`;

    userTasks.forEach((task, index) => {
        const status = task.done ? '✅ انجام شده' : (task.reminded ? '📢 یادآوری شده' : '⏳ در انتظار');
        const aware = task.aware ? '👁️ حواسم هست' : '😴 حواسم نیست';
        const lazySent = task.reminderSent ? '📤 یادآوری تنبل ارسال شده' : '';

        message += `${index + 1}. ${task.task}\n`;
        message += `   ⏰ ${task.time} | ${status} | ${aware}`;
        if (lazySent) message += ` | ${lazySent}`;
        message += '\n\n';
    });

    // چک یادآوری‌های در انتظار
    const pendingReminders = getPendingReminders();
    const userPending = pendingReminders.filter(([uid]) => uid === userId);
    message += `🎯 یادآوری‌های در انتظار برای تو: ${userPending.length} تا\n`;

    // چک یادآوری‌های تنبل
    const lazyTasks = getTasksNotDoneAfterReminder(2);
    const userLazy = lazyTasks.filter(([uid]) => uid === userId);
    message += `😤 یادآوری‌های تنبل برای تو: ${userLazy.length} تا\n`;

    await ctx.reply(message);
}

async function suggestCommand(ctx) {
    const userId = ctx.from.id.toString();
    const smartSuggestions = require('./smartSuggestions');
    const suggestions = smartSuggestions.getSmartSuggestions(userId);
    const message = smartSuggestions.generateSuggestionMessage(suggestions);

    await ctx.reply(message, {
        reply_markup: getMainKeyboard()
    });
}

async function motivateCommand(ctx) {
    const userId = ctx.from.id.toString();
    const gamification = require('./gamification');
    const motivationalMessage = gamification.generateMotivationalMessage(userId);

    await ctx.reply(motivationalMessage, {
        reply_markup: getMainKeyboard()
    });

    // ارسال استیکر انگیزشی اگر موجود باشه
    try {
        const successSticker = getRandomSuccessSticker();
        if (successSticker) {
            await sendStickerByPath(ctx, successSticker);
        }
    } catch (error) {
        console.error('خطا در ارسال استیکر انگیزشی:', error);
    }
}

// دستورات تنظیم استیکرها
let waitingForSticker = {}; // { userId: 'lazy' | 'scenario1' | 'scenario2_yes' | 'scenario2_no' }

async function setLazyCommand(ctx) {
    const userId = ctx.from.id.toString();
    waitingForSticker[userId] = 'lazy';
    await ctx.reply('حالا استیکر تنبل رو بفرست 🎭');
}

async function setScenario1Command(ctx) {
    const userId = ctx.from.id.toString();
    waitingForSticker[userId] = 'scenario1';
    await ctx.reply('حالا استیکر سناریو 1 (نصیحت) رو بفرست 💡');
}

async function setScenario2YesCommand(ctx) {
    const userId = ctx.from.id.toString();
    waitingForSticker[userId] = 'scenario2_yes';
    await ctx.reply('حالا استیکر سناریو 2 (آره) رو بفرست 😂');
}

async function setScenario2NoCommand(ctx) {
    const userId = ctx.from.id.toString();
    waitingForSticker[userId] = 'scenario2_no';
    await ctx.reply('حالا استیکر سناریو 2 (نه) رو بفرست 😊');
}

async function buttonCallback(ctx) {
    console.log('🔥 CALLBACK RECEIVED:', ctx.callbackQuery.data);

    try {
        await ctx.answerCbQuery();

        const data = ctx.callbackQuery.data.split('|');
        const userId = (ctx.from || ctx.callbackQuery.from).id.toString();

        console.log('📊 Parsed data:', data);
        console.log('👤 User ID:', userId);

        // اعتبارسنجی داده‌ها
        if (data.length < 2) {
            console.error('❌ داده callback نامعتبر:', data);
            await ctx.answerCbQuery('داده نامعتبر!', { show_alert: true });
            return;
        }

        if (data[0] === 'done') {
            const taskIndex = parseInt(data[1]);
            console.log('✅ Marking task as done:', taskIndex);

            const task = markTaskDone(userId, taskIndex);

            if (task) {
                const message = `${getCompletionMessage()}\n\n` +
                              `کار «${task.task}» انجام شد! 🎉`;
                console.log('📝 Editing message...');
                try {
                    await ctx.editMessageText(message);
                } catch (editError) {
                    // اگر editMessageText خطا داد، پیام جدید بفرست
                    console.log('⚠️ خطا در edit، ارسال پیام جدید...');
                    await ctx.reply(message);
                }

                // ارسال استیکر موفقیت
                try {
                    const randomSticker = getRandomSuccessSticker();
                    console.log('🎭 Sending success sticker:', randomSticker);

                    await sendStickerByPath(ctx, randomSticker);
                    console.log('✅ Success sticker sent');
                } catch (error) {
                    console.error('❌ خطا در ارسال استیکر:', error);
                }
            } else {
                console.log('❌ Task not found');
                await ctx.answerCbQuery('خطا در ثبت انجام کار!', { show_alert: true });
            }
        } else if (data[0] === 'aware') {
            const taskIndex = parseInt(data[1]);
            console.log('👁️ Marking task as aware:', taskIndex);
            console.log('👤 User ID:', userId);
            console.log('📊 Data:', data);

            // بررسی اینکه taskIndex معتبر هست
            if (isNaN(taskIndex)) {
                console.error('❌ taskIndex نامعتبر:', data[1]);
                await ctx.answerCbQuery('خطا: taskIndex نامعتبر!', { show_alert: true });
                return;
            }

            const task = markTaskAware(userId, taskIndex);
            console.log('📋 Task result:', task ? 'found' : 'not found');

            if (task) {
                console.log('📝 Editing message for aware...');
                try {
                    await ctx.editMessageText(
                        `اوکی گلم! حواسم هست که «${task.task}» رو باید انجام بدی 💕\n\n` +
                        `وقتی انجامش دادی، دکمه "انجام شد" رو بزن 😊`,
                        {
                            reply_markup: {
                                inline_keyboard: [[
                                    { text: 'حواسم هست ✅', callback_data: `aware|${taskIndex}`, disabled: true },
                                    { text: 'انجام شد 🎉', callback_data: `done|${taskIndex}` }
                                ]]
                            }
                        }
                    );
                    console.log('✅ Task marked as aware');
                } catch (editError) {
                    // اگر editMessageText خطا داد، پیام جدید بفرست
                    console.log('⚠️ خطا در edit، ارسال پیام جدید...', editError.message);
                    await ctx.reply(
                        `اوکی گلم! حواسم هست که «${task.task}» رو باید انجام بدی 💕\n\n` +
                        `وقتی انجامش دادی، دکمه "انجام شد" رو بزن 😊`,
                        {
                            reply_markup: {
                                inline_keyboard: [[
                                    { text: 'حواسم هست ✅', callback_data: `aware|${taskIndex}`, disabled: true },
                                    { text: 'انجام شد 🎉', callback_data: `done|${taskIndex}` }
                                ]]
                            }
                        }
                    );
                }
            } else {
                console.log('❌ Task not found for aware');
                console.log('🔍 User tasks count:', getUserTasks(userId).length);
                await ctx.answerCbQuery('خطا: کار پیدا نشد!', { show_alert: true });
            }
        } else if (data[0] === 'motivate') {
            const taskIndex = parseInt(data[1]);
            console.log('💪 Motivate button pressed for task:', taskIndex);

            const gamification = require('./gamification');
            const motivationalMessage = gamification.generateMotivationalMessage(userId);
            try {
                await ctx.editMessageText(
                    `${ctx.callbackQuery.message.text}\n\n${motivationalMessage}`,
                    {
                        reply_markup: {
                            inline_keyboard: [[
                                { text: 'حواسم هست ✅', callback_data: `aware|${taskIndex}` },
                                { text: 'انجام شد 🎉', callback_data: `done|${taskIndex}` }
                            ]]
                        }
                    }
                );
            } catch (editError) {
                await ctx.reply(motivationalMessage);
            }

        } else if (data[0] === 'stats') {
            const taskIndex = parseInt(data[1]);
            console.log('📊 Stats button pressed for task:', taskIndex);

            const gamification = require('./gamification');
            const stats = gamification.getUserStats(userId);

            const statsMessage = `📊 آمار مائده جان:\n\n` +
                               `⭐ امتیاز: ${stats.points}\n` +
                               `🏆 سطح: ${stats.level}\n` +
                               `🔥 استریک: ${stats.streak}\n` +
                               `📈 نرخ تکمیل: ${stats.completionRate}%\n` +
                               `🏅 روزهای کامل: ${stats.perfectDays}`;

            try {
                await ctx.editMessageText(
                    `${ctx.callbackQuery.message.text}\n\n${statsMessage}`,
                    {
                        reply_markup: {
                            inline_keyboard: [[
                                { text: 'حواسم هست ✅', callback_data: `aware|${taskIndex}` },
                                { text: 'انجام شد 🎉', callback_data: `done|${taskIndex}` }
                            ]]
                        }
                    }
                );
            } catch (editError) {
                await ctx.reply(statsMessage);
            }

        } else if (data[0] === 'suggest') {
            const taskIndex = parseInt(data[1]);
            console.log('💡 Suggest button pressed for task:', taskIndex);

            const smartSuggestions = require('./smartSuggestions');
            const suggestions = smartSuggestions.getSmartSuggestions(userId);
            const suggestionMessage = smartSuggestions.generateSuggestionMessage(suggestions.slice(0, 2));

            try {
                await ctx.editMessageText(
                    `${ctx.callbackQuery.message.text}\n\n${suggestionMessage}`,
                    {
                        reply_markup: {
                            inline_keyboard: [[
                                { text: 'حواسم هست ✅', callback_data: `aware|${taskIndex}` },
                                { text: 'انجام شد 🎉', callback_data: `done|${taskIndex}` }
                            ]]
                        }
                    }
                );
            } catch (editError) {
                await ctx.reply(suggestionMessage);
            }

        } else {
            console.log('❓ Unknown callback type:', data[0]);
        }
    } catch (error) {
        console.error('💥 خطا در callback handler:', error);
        console.error('🔍 جزئیات خطا:', error.response?.body || error.message);

        try {
            let errorMessage = 'خطایی رخ داد!';
            if (error.code === 400) {
                errorMessage = 'پیام قدیمی یا نامعتبر!';
            } else if (error.code === 403) {
                errorMessage = 'دسترسی غیرمجاز!';
            } else if (error.code === 429) {
                errorMessage = 'زیاد سریع عمل کردی!';
            }

            await ctx.answerCbQuery(errorMessage, { show_alert: true });
        } catch (e) {
            console.error('💥 خطا در ارسال پاسخ خطا:', e);
        }
    }
}

// هندلر استیکر - پاسخ به استیکر و ذخیره file_id
async function handleSticker(ctx) {
    const sticker = ctx.message.sticker;
    const fileId = sticker.file_id;
    const userId = ctx.from.id.toString();

    // چک کردن آیا کاربر در حال تنظیم استیکر خاصی است
    if (waitingForSticker[userId]) {
        const type = waitingForSticker[userId];
        delete waitingForSticker[userId];

        try {
            switch (type) {
                case 'lazy':
                    setLazySticker(fileId);
                    await ctx.reply('✅ استیکر تنبل تنظیم شد! 🎭');
                    // ارسال پیش‌نمایش
                    await ctx.replyWithSticker(fileId);
                    break;
                case 'scenario1':
                    setScenario1Sticker(fileId);
                    await ctx.reply('✅ استیکر سناریو 1 (نصیحت) تنظیم شد! 💡');
                    await ctx.replyWithSticker(fileId);
                    break;
                case 'scenario2_yes':
                    setScenario2YesSticker(fileId);
                    await ctx.reply('✅ استیکر سناریو 2 (آره) تنظیم شد! 😂');
                    await ctx.replyWithSticker(fileId);
                    break;
                case 'scenario2_no':
                    setScenario2NoSticker(fileId);
                    await ctx.reply('✅ استیکر سناریو 2 (نه) تنظیم شد! 😊');
                    await ctx.replyWithSticker(fileId);
                    break;
            }
        } catch (error) {
            console.error('خطا در تنظیم استیکر:', error);
            await ctx.reply('❌ خطا در تنظیم استیکر! لطفاً دوباره امتحان کنید.');
        }
        return;
    }

    // پاسخ بانمک به استیکر
    const stickerResponses = [
        'آخی چقدر قشنگ! 😍💕 این استیکر خیلی بامزه بود!',
        'وای چقدر بانمک! 🥰✨ استیکرت عالیه عشقم!',
        'خیلی دوست‌داشتنی! 😘💖 استیکر قشنگت رو دوست داشتم!',
        'عشقم چقدر قشنگ! 😍💕 این استیکر خیلی شیرین بود!',
        'وای چقدر عزیزی! 🥰💖 استیکر بامزه‌ای فرستادی!'
    ];

    const randomResponse = stickerResponses[Math.floor(Math.random() * stickerResponses.length)];

    try {
        await ctx.reply(randomResponse);

        // ذخیره file_id برای استفاده بعدی (استیکر موفقیت)
        const { addSuccessSticker } = require('./stickerManager');
        addSuccessSticker(fileId);

        // ارسال استیکر پاسخ رندوم (30% احتمال)
        if (Math.random() < 0.3) {
            const successSticker = getRandomSuccessSticker();
            if (successSticker) {
                await sendStickerByPath(ctx, successSticker);
            }
        }

        // راهنمای تنظیم استیکرها (کمتر نمایش داده شود)
        if (Math.random() < 0.2) { // 20% احتمال
            await ctx.reply(
                '💡 این استیکر به لیست استیکرهای موفقیت اضافه شد!\n\n' +
                'برای تنظیم استیکرهای دیگه:\n' +
                '/set_lazy - استیکر تنبل\n' +
                '/set_scenario1 - استیکر نصیحت\n' +
                '/set_scenario2_yes - استیکر اعتراض (آره)\n' +
                '/set_scenario2_no - استیکر اعتراض (نه)'
            );
        }
    } catch (error) {
        console.error('خطا در پاسخ به استیکر:', error);
        // پاسخ ساده در صورت خطا
        await ctx.reply('😍 استیکر قشنگت رو دوست داشتم!');
    }
}

function detectYesNo(text) {
    const textLower = text.toLowerCase().trim();
    const yesWords = ['آره', 'اره', 'بله', 'بلی', 'yes', 'yeah', 'yep', 'ok', 'باشه', 'حله'];
    const noWords = ['نه', 'خیر', 'no', 'nope', 'nah'];
    
    for (const word of yesWords) {
        if (textLower.includes(word)) return 'yes';
    }
    for (const word of noWords) {
        if (textLower.includes(word)) return 'no';
    }
    return null;
}

// ذخیره سناریوی فعال برای هر کاربر
const activeScenarios = {};

async function handleMessage(ctx) {
    const text = ctx.message.text.trim();
    const userId = ctx.from.id.toString();

    // چک کردن دکمه‌های keyboard
    if (text === '📅 کارهای امروز') {
        await todayCommand(ctx);
        return;
    }
    if (text === '📊 گزارش') {
        await reportCommand(ctx);
        return;
    }
    if (text === '📈 آمار') {
        await statsCommand(ctx);
        return;
    }
    if (text === '💡 پیشنهاد') {
        await suggestCommand(ctx);
        return;
    }
    if (text === '💪 انگیزشی') {
        await motivateCommand(ctx);
        return;
    }
    if (text === '❓ راهنما') {
        await helpCommand(ctx);
        return;
    }

    // اول چک کنیم آیا این یک کار جدید است یا نه (قبل از سناریو)
    const [timeStr, task] = parseTimeAndTask(text);
    
    // اگر کار جدید بود، سناریو رو پاک کن و کار رو ثبت کن
    if (timeStr && task) {
        // پاک کردن سناریوی فعال اگر وجود داشته باشه
        if (activeScenarios[userId]) {
            delete activeScenarios[userId];
        }
        
        // اضافه کردن وظیفه
        addTask(userId, task, timeStr);
        
        // پیام تأیید با نام کاربر (اگر موجود باشد)
        const userName = ctx.from.first_name || 'مائده';
        const message = formatTaskMessage(task, timeStr, userName);
        
        // دکمه‌های حواسم هست و انجام شد
        const userTasks = getUserTasks(userId);
        const taskIndex = userTasks.length - 1;
        
        const keyboard = getTaskKeyboard(taskIndex);
        
        await ctx.reply(message, { reply_markup: keyboard });
        return;
    }

    // تحلیل احساسات پیام کاربر
    const { analyzeSentiment } = require('./analytics');
    const sentiment = analyzeSentiment(text);

    // چک کردن کارهای گذشته شده
    const overdueTasks = getOverdueTasks(userId);
    if (overdueTasks.length > 0 && Math.random() < 0.3) { // 30% احتمال
        const randomTask = overdueTasks[Math.floor(Math.random() * overdueTasks.length)];

        // پیام بر اساس احساسات کاربر
        let reminderMessage;
        if (sentiment === 'negative') {
            reminderMessage = `مائده جانم! 😔 ناراحت نباش، من اینجام که کمکت کنم. کار «${randomTask.task}» رو هنوز انجام ندادی، ولی با هم انجامش می‌دیم! 💕`;
        } else if (sentiment === 'positive') {
            reminderMessage = `مائده گلم! 😊 انرژی خوبی داری! یادت نره کار «${randomTask.task}» رو انجام بدی! 💪`;
        } else {
            reminderMessage = `مائده عزیزم! کار «${randomTask.task}» رو هنوز انجام ندادی! 💕`;
        }

        await ctx.reply(reminderMessage);
        try {
            // ارسال استیکر تنبل
            const lazySticker = getLazySticker();
            await sendStickerByPath(ctx, lazySticker);
        } catch (error) {
            console.error('خطا در ارسال استیکر:', error);
        }
    }

    // چک کردن سناریوی فعال - بعد از چک کردن کار جدید
    if (activeScenarios[userId]) {
        const scenario = activeScenarios[userId];
        const yesNo = detectYesNo(text);

        console.log('🎭 سناریوی فعال:', scenario.type);
        console.log('💬 پاسخ کاربر:', yesNo);

        if (yesNo === 'yes') {
            delete activeScenarios[userId];
            try {
                // ارسال استیکر پاسخ آره
                let stickerPath;
                if (scenario.type === 'complaint') {
                    // برای سناریو اعتراض - استیکر آره
                    stickerPath = scenario.yesSticker || 'stik/2.webp';
                } else {
                    // برای سناریو نصیحت
                    stickerPath = scenario.sticker || 'stik/1.webp';
                }
                console.log('📤 ارسال استیکر برای پاسخ آره:', stickerPath);
                await sendStickerByPath(ctx, stickerPath);
            } catch (error) {
                console.error('❌ خطا در ارسال استیکر:', error);
                console.error('🔍 جزئیات:', error.message);
            }
            return; // همیشه return می‌کنیم وقتی سناریو فعال هست
        } else if (yesNo === 'no' && scenario.type === 'complaint') {
            delete activeScenarios[userId];
            try {
                // ارسال استیکر پاسخ نه (فقط برای سناریو اعتراض)
                const stickerPath = scenario.noSticker || 'stik/5.webp';
                console.log('📤 ارسال استیکر برای پاسخ نه:', stickerPath);
                await sendStickerByPath(ctx, stickerPath);
            } catch (error) {
                console.error('❌ خطا در ارسال استیکر:', error);
                console.error('🔍 جزئیات:', error.message);
            }
            return; // همیشه return می‌کنیم وقتی سناریو فعال هست
        } else {
            // اگر پاسخ نامشخص بود، سناریو رو نگه داریم و چیزی نگیم
            console.log('🤔 پاسخ نامشخص، سناریو فعال باقی می‌مونه');
            return; // همیشه return می‌کنیم وقتی سناریو فعال هست
        }
    }

    // اول چک کردن انواع پیام‌ها
    const messageType = detectMessageType(text);

    if (messageType === 'greeting') {
        await ctx.reply(getGreetingResponse());
        return;
    } else if (messageType === 'how_are_you') {
        await ctx.reply(getHowAreYouResponse());
        return;
    } else if (messageType === 'about') {
        await ctx.reply(getAboutMessage());
        return;
    } else if (messageType === 'thanks') {
        await ctx.reply(getThankYouResponse());
        return;
    } else if (messageType === 'compliment') {
        await ctx.reply(getComplimentResponse());
        return;
    } else if (messageType === 'positive') {
        await ctx.reply(getPositiveResponse());
        return;
    } else if (messageType === 'report') {
        const userId = ctx.from.id.toString();
        const today = new Date().toISOString().split('T')[0];

        const stats = getTodayTasksStats(userId, today);
        const report = formatDailyReport(stats);

        await ctx.reply(report);
        return;
    }
    
    // اگر به اینجا رسیدیم یعنی نه کار جدید بود، نه سناریو فعال، نه پیام خاص
    // پس یک سناریو رندوم نشون بدیم
    {
        // اگر فرمت درست نبود - جملات رندوم با استیکر
        const randomChoice = Math.random();

        if (randomChoice < 0.5) { // 50% احتمال سناریو 1: نصیحت
            activeScenarios[userId] = {
                question: "میخوای یه نصیحتت کنم؟ 😏💕",
                type: 'advice',
                sticker: 'stik/1.webp'
            };
            await ctx.reply("میخوای یه نصیحتت کنم؟ 😏💕");
        } else {
            // 50% احتمال سناریو 2: اعتراض
            activeScenarios[userId] = {
                question: "مثل اینکه با قوانین ممد مشکل داری که درست نمینویسی درسته؟ 😂",
                type: 'complaint',
                yesSticker: 'stik/2.webp',
                noSticker: 'stik/5.webp'
            };
            await ctx.reply("مثل اینکه با قوانین ممد مشکل داری که درست نمینویسی درسته؟ 😂");
        }
    }
}

module.exports = {
    startCommand,
    helpCommand,
    todayCommand,
    reportCommand,
    statsCommand,
    debugRemindersCommand,
    suggestCommand,
    motivateCommand,
    setLazyCommand,
    setScenario1Command,
    setScenario2YesCommand,
    setScenario2NoCommand,
    buttonCallback,
    handleMessage,
    handleSticker
};

