/**
 * مدیریت ذخیره و بارگذاری داده‌ها
 */
const fs = require('fs');
const path = require('path');
const { DATA_FILE } = require('./config');

function loadTasks() {
    if (fs.existsSync(DATA_FILE)) {
        try {
            const data = fs.readFileSync(DATA_FILE, 'utf8');
            return JSON.parse(data);
        } catch (error) {
            console.error('خطا در خواندن فایل:', error);
            return {};
        }
    }
    return {};
}

function saveTasks(tasks) {
    try {
        fs.writeFileSync(DATA_FILE, JSON.stringify(tasks, null, 4), 'utf8');
    } catch (error) {
        console.error('خطا در ذخیره فایل:', error);
    }
}

function addTask(userId, task, timeStr, date = null) {
    const tasks = loadTasks();

    if (!tasks[userId]) {
        tasks[userId] = [];
    }

    if (!date) {
        const now = new Date();
        const today = now.toISOString().split('T')[0]; // YYYY-MM-DD

        // بررسی اینکه آیا زمان مشخص شده امروز گذشته یا نه
        const [hours, minutes] = timeStr.split(':').map(Number);
        const taskDateTime = new Date(today + 'T' + timeStr + ':00');

        // اگر زمان کار امروز گذشته، برای فردا برنامه‌ریزی کن
        if (taskDateTime <= now) {
            const tomorrow = new Date(now);
            tomorrow.setDate(tomorrow.getDate() + 1);
            date = tomorrow.toISOString().split('T')[0];
            console.log('⏰ زمان کار گذشته، برای فردا برنامه‌ریزی شد:', date, timeStr);
        } else {
            date = today;
        }
    }

    const fullTime = `${date} ${timeStr}`;

    const newTask = {
        task: task,
        time: fullTime,
        done: false,
        date: date,
        reminded: false,
        aware: false // حواسم هست یا نه
    };

    tasks[userId].push(newTask);
    saveTasks(tasks);

    console.log('✅ کار اضافه شد:', task, 'برای زمان:', fullTime);
    return newTask;
}

function getOverdueTasks(userId) {
    const tasks = loadTasks();
    const userTasks = tasks[userId] || [];
    const now = new Date();
    const currentTime = formatDateTime(now);
    
    return userTasks.filter(task => {
        // کارهایی که وقتشون گذشته و انجام نشده
        return !task.done && task.time < currentTime && task.reminded;
    });
}

function getUserTasks(userId, date = null) {
    // همیشه از فایل خوانده می‌شه (نه از cache) برای داینامیک بودن
    const tasks = loadTasks();
    const userTasks = tasks[userId] || [];
    
    if (date) {
        // فیلتر بر اساس تاریخ دقیق
        const filteredTasks = userTasks.filter(t => {
            // اگر task.date وجود داره، استفاده کن
            if (t.date) {
                return t.date === date;
            }
            // در غیر این صورت از time استخراج کن
            if (t.time) {
                const taskDate = t.time.split(' ')[0];
                return taskDate === date;
            }
            return false;
        });
        
        // مرتب‌سازی بر اساس زمان
        return filteredTasks.sort((a, b) => {
            if (!a.time || !b.time) return 0;
            const timeA = a.time.split(' ')[1] || '00:00';
            const timeB = b.time.split(' ')[1] || '00:00';
            return timeA.localeCompare(timeB);
        });
    }
    
    // مرتب‌سازی تمام کارها بر اساس زمان (جدیدترین اول)
    return userTasks.sort((a, b) => {
        if (!a.time || !b.time) return 0;
        const dateA = new Date(a.time.replace(' ', 'T'));
        const dateB = new Date(b.time.replace(' ', 'T'));
        return dateB - dateA; // جدیدترین اول
    });
}

function markTaskDone(userId, taskIndex) {
    const tasks = loadTasks();
    
    if (tasks[userId] && taskIndex >= 0 && taskIndex < tasks[userId].length) {
        tasks[userId][taskIndex].done = true;
        saveTasks(tasks);
        return tasks[userId][taskIndex];
    }
    
    return null;
}

function markTaskReminded(userId, taskIndex) {
    const tasks = loadTasks();

    if (tasks[userId] && taskIndex >= 0 && taskIndex < tasks[userId].length) {
        const now = new Date();
        tasks[userId][taskIndex].reminded = true;
        tasks[userId][taskIndex].reminded_at = now.toISOString(); // ذخیره زمان یادآوری دقیق
        console.log('✅ کار یادآوری شد:', tasks[userId][taskIndex].task, 'در زمان:', formatDateTime(now));
        saveTasks(tasks);
    }
}

function markTaskAware(userId, taskIndex) {
    const tasks = loadTasks();
    if (tasks[userId] && taskIndex >= 0 && taskIndex < tasks[userId].length) {
        tasks[userId][taskIndex].aware = true; // حواسم هست
        saveTasks(tasks);
        return tasks[userId][taskIndex];
    }
    return null;
}

function getTodayTasksStats(userId, date = null) {
    if (!date) {
        const now = new Date();
        date = now.toISOString().split('T')[0];
    }

    // همیشه از فایل خوانده می‌شه (نه از cache) برای داینامیک بودن
    const tasks = loadTasks();
    const userTasks = tasks[userId] || [];

    // فقط کارهای امروز رو بررسی می‌کنیم (دقیق‌تر)
    const relevantTasks = userTasks.filter(task => {
        // چک کردن از طریق task.date
        if (task.date) {
            return task.date === date;
        }
        // چک کردن از طریق task.time
        if (task.time) {
            const taskDate = task.time.split(' ')[0];
            return taskDate === date;
        }
        return false;
    });

    let notAware = 0; // اصلا حواست نبود
    let awareNotDone = 0; // حواست بود انجام ندادی
    let awareAndDone = 0; // حواست بود و انجام دادی
    let doneWithoutAware = 0; // انجام دادی ولی حواست نبود

    relevantTasks.forEach(task => {
        if (task.done) {
            if (task.aware) {
                awareAndDone++;
            } else {
                doneWithoutAware++;
            }
        } else {
            if (task.aware) {
                awareNotDone++;
            } else {
                notAware++;
            }
        }
    });

    return {
        notAware,
        awareNotDone,
        awareAndDone,
        doneWithoutAware,
        total: relevantTasks.length,
        totalDone: awareAndDone + doneWithoutAware
    };
}

function getOverdueTasks(userId) {
    const tasks = loadTasks();
    const userTasks = tasks[userId] || [];
    const now = new Date();
    const currentTime = formatDateTime(now);
    
    return userTasks.filter(task => {
        // کارهایی که وقتشون گذشته و انجام نشده
        return !task.done && task.time < currentTime && task.reminded;
    });
}

function formatDateTime(date) {
    // فرمت: YYYY-MM-DD HH:MM
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    return `${year}-${month}-${day} ${hours}:${minutes}`;
}

function getPendingReminders() {
    const tasks = loadTasks();
    const now = new Date();

    const reminders = [];

    for (const [userId, userTasks] of Object.entries(tasks)) {
        userTasks.forEach((task, i) => {
            // فقط کارهایی که انجام نشده و یادآوری نشده
            if (!task.done && !task.reminded) {
                const taskTime = new Date(task.time.replace(' ', 'T'));
                const timeDiff = Math.abs(now - taskTime) / 1000; // تفاوت به ثانیه

                // اگر زمان یادآوری رسیده یا حداکثر 2 دقیقه تأخیر دارد
                if (timeDiff <= 120) { // 2 دقیقه = 120 ثانیه
                    reminders.push([userId, i, task]);
                }
            }
        });
    }

    console.log('🔍 یافت شد', reminders.length, 'یادآوری در انتظار');
    return reminders;
}

// دریافت کارهایی که یادآوری شدن ولی بعد از X دقیقه انجام نشدن
function getTasksNotDoneAfterReminder(minutesAfter = 2) {
    const tasks = loadTasks();
    const now = new Date();
    const result = [];

    console.log('🔍 جستجو برای کارهایی که', minutesAfter, 'دقیقه از یادآوری‌شون گذشته...');

    for (const [userId, userTasks] of Object.entries(tasks)) {
        userTasks.forEach((task, index) => {
            // فقط کارهایی که یادآوری شدن، انجام نشدن و یادآوری 2 دقیقه‌ای ارسال نشده
            if (!task.done && task.reminded && !task.reminderSent) {
                let reminderTime;

                // اگر زمان یادآوری ذخیره شده، از اون استفاده کن
                if (task.reminded_at) {
                    reminderTime = new Date(task.reminded_at);
                    console.log('📅 زمان یادآوری ذخیره شده:', task.reminded_at, 'برای کار:', task.task);
                } else {
                    // در غیر این صورت زمان کار رو به عنوان زمان یادآوری در نظر بگیر
                    // (برای سازگاری با داده‌های قدیمی)
                    reminderTime = new Date(task.time.replace(' ', 'T'));
                    console.log('📅 زمان کار به عنوان زمان یادآوری:', task.time, 'برای کار:', task.task);
                }

                // اضافه کردن X دقیقه به زمان یادآوری
                const deadlineTime = new Date(reminderTime.getTime() + (minutesAfter * 60 * 1000));

                console.log('⏰ مهلت انجام:', formatDateTime(deadlineTime), 'زمان فعلی:', formatDateTime(now));

                // چک کردن که آیا مهلت گذشته
                if (now >= deadlineTime) {
                    console.log('⚠️ مهلت کار', task.task, 'گذشته! کاربر:', userId);
                    result.push([userId, index, task]);
                }
            }
        });
    }

    console.log('📋 تعداد کارهایی که مهلت‌شون گذشته:', result.length);
    return result;
}

// علامت‌گذاری که یادآوری 2 دقیقه‌ای ارسال شده
function markReminderSent(userId, taskIndex) {
    const tasks = loadTasks();
    
    if (tasks[userId] && taskIndex >= 0 && taskIndex < tasks[userId].length) {
        tasks[userId][taskIndex].reminderSent = true;
        saveTasks(tasks);
    }
}

// مهاجرت داده‌ها برای سازگاری با نسخه جدید
function migrateTasksData() {
    const tasks = loadTasks();
    let migrated = false;
    const now = new Date();

    for (const [userId, userTasks] of Object.entries(tasks)) {
        userTasks.forEach((task, index) => {
            // اضافه کردن فیلد reminderSent اگر وجود نداشته
            if (task.reminderSent === undefined) {
                task.reminderSent = false;
                migrated = true;
                console.log('🔄 فیلد reminderSent اضافه شد به کار:', task.task);
            }

            // اضافه کردن فیلد aware اگر وجود نداشته
            if (task.aware === undefined) {
                task.aware = false;
                migrated = true;
                console.log('🔄 فیلد aware اضافه شد به کار:', task.task);
            }

            // بررسی و تصحیح زمان‌های گذشته
            if (task.time && !task.done && !task.reminded) {
                const taskDateTime = new Date(task.time.replace(' ', 'T'));
                if (taskDateTime <= now) {
                    // زمان گذشته، به فردا منتقل کن
                    const tomorrow = new Date(now);
                    tomorrow.setDate(tomorrow.getDate() + 1);
                    const newDate = tomorrow.toISOString().split('T')[0];
                    const timePart = task.time.split(' ')[1];
                    const newFullTime = `${newDate} ${timePart}`;

                    task.time = newFullTime;
                    task.date = newDate;
                    migrated = true;
                    console.log('🔄 زمان کار گذشته منتقل شد به فردا:', task.task, '->', newFullTime);
                }
            }
        });
    }

    if (migrated) {
        saveTasks(tasks);
        console.log('✅ مهاجرت داده‌ها انجام شد');
    } else {
        console.log('ℹ️ داده‌ها از قبل بروز هستند');
    }
}

module.exports = {
    loadTasks,
    saveTasks,
    addTask,
    getUserTasks,
    markTaskDone,
    markTaskReminded,
    markTaskAware,
    getPendingReminders,
    getTodayTasksStats,
    getOverdueTasks,
    getTasksNotDoneAfterReminder,
    markReminderSent,
    migrateTasksData
};

