main.js

const { app, BrowserWindow, ipcMain, Notification, dialog } = require('electron');
const path = require('path');
const fs = require('fs').promises;

let mainWindow;
let notificationCheckInterval = null;
let activeTasks = new Set();

// Path to tasks.json
const tasksFilePath = path.join(__dirname, 'data', 'tasks.json');
const uploadsDir = path.join(__dirname, 'data', 'uploads');

// Ensure data directory exists
async function ensureDataDirectory() {
    const dataDir = path.dirname(tasksFilePath);
    try {
        await fs.access(dataDir);
    } catch {
        await fs.mkdir(dataDir, { recursive: true });
    }
    // Ensure uploads directory exists
    try {
        await fs.access(uploadsDir);
    } catch {
        await fs.mkdir(uploadsDir, { recursive: true });
    }
}

// Copy file to uploads directory
async function copyFileToUploads(filePath) {
    try {
        await ensureDataDirectory();
        const fileName = path.basename(filePath);
        const timestamp = Date.now();
        const ext = path.extname(fileName);
        const nameWithoutExt = path.basename(fileName, ext);
        const newFileName = `${nameWithoutExt}_${timestamp}${ext}`;
        const destPath = path.join(uploadsDir, newFileName);

        await fs.copyFile(filePath, destPath);
        return destPath;
    } catch (error) {
        console.error('Error copying file:', error);
        return null;
    }
}

// Delete file from uploads
async function deleteUploadedFile(filePath) {
    try {
        if (filePath && filePath.startsWith(uploadsDir)) {
            await fs.unlink(filePath);
            return true;
        }
        return false;
    } catch (error) {
        console.error('Error deleting file:', error);
        return false;
    }
}

// Read tasks from JSON file
async function loadTasks() {
    try {
        await ensureDataDirectory();
        const data = await fs.readFile(tasksFilePath, 'utf8');
        const parsed = JSON.parse(data);
        // Handle legacy format (array) or new format (object)
        if (Array.isArray(parsed)) {
            return { tasks: parsed, categories: [] };
        }
        return parsed;
    } catch (error) {
        // If file doesn't exist, return empty structure
        if (error.code === 'ENOENT') {
            return { tasks: [], categories: [] };
        }
        console.error('Error loading tasks:', error);
        return { tasks: [], categories: [] };
    }
}

// Save tasks to JSON file
async function saveTasks(data) {
    try {
        await ensureDataDirectory();
        await fs.writeFile(tasksFilePath, JSON.stringify(data, null, 2), 'utf8');
        return true;
    } catch (error) {
        console.error('Error saving tasks:', error);
        return false;
    }
}

// Check and send notifications
async function checkNotifications() {
    try {
        const data = await loadTasks();
        const tasks = data.tasks || [];
        const now = new Date();
        const nowDateOnly = new Date(now);
        nowDateOnly.setHours(0, 0, 0, 0);

        tasks.forEach(task => {
            if (!task.date || task.completed) return;

            // Parse task date (handles both date and datetime strings)
            const taskDateFull = new Date(task.date);
            const taskDate = new Date(taskDateFull);
            taskDate.setHours(0, 0, 0, 0);

            if (taskDate < nowDateOnly) return; // Past dates

            const daysUntil = Math.floor((taskDate - nowDateOnly) / (1000 * 60 * 60 * 24));

            // Initialize notificationsSent if it doesn't exist
            if (!task.notificationsSent) {
                task.notificationsSent = {
                    weekBefore: false,
                    dayBefore: false,
                    dayOf: false,
                    oneMinuteBefore: false,
                    timeReached: false
                };
            }
            if (task.notificationsSent.timeReached === undefined) {
                task.notificationsSent.timeReached = false;
            }

            let shouldNotify = false;
            let notificationText = '';
            let notificationBody = task.text;

            // Check if task has time
            const hasTime = task.date.includes('T') && task.date.split('T')[1];
            if (hasTime) {
                const timeStr = taskDateFull.toLocaleTimeString('en-US', {
                    hour: 'numeric',
                    minute: '2-digit',
                    hour12: true
                });
                notificationBody = `${task.text} at ${timeStr}`;

                // Check if it's exactly the scheduled time (within 1 minute window)
                if (daysUntil === 0) {
                    const timeDiff = Math.abs(now - taskDateFull);

                    // Check for exactly at the time (within 1 minute window)
                    if (timeDiff < 60000 && !activeTasks.has(task.id)) {
                        // Task is now active
                        activeTasks.add(task.id);
                        if (mainWindow && !mainWindow.isDestroyed()) {
                            mainWindow.webContents.send('task-active', task.id);
                        }
                        shouldNotify = true;
                        notificationText = `Now: ${task.text}`;
                        if (!task.notificationsSent.timeReached) {
                            task.notificationsSent.timeReached = true;
                        }
                    }
                    // Check if task time has passed (more than 1 minute past)
                    else if (now > taskDateFull && (now - taskDateFull) > 60000 && activeTasks.has(task.id)) {
                        // Task is no longer active
                        activeTasks.delete(task.id);
                        if (mainWindow && !mainWindow.isDestroyed()) {
                            mainWindow.webContents.send('task-inactive', task.id);
                        }
                    }

                }

                // Check for 1 minute before the scheduled time
                if (daysUntil === 0 && !task.notificationsSent.oneMinuteBefore) {
                    const oneMinuteBefore = new Date(taskDateFull);
                    oneMinuteBefore.setMinutes(oneMinuteBefore.getMinutes() - 1);

                    // Check if current time is within 1 minute of the "1 minute before" time
                    const timeDiff = Math.abs(now - oneMinuteBefore);
                    if (timeDiff < 60000 && !shouldNotify) { // Within 1 minute (60 seconds)
                        shouldNotify = true;
                        notificationText = `Starting in 1 minute: ${task.text}`;
                        task.notificationsSent.oneMinuteBefore = true;
                    }
                }
            }

            // Check for 1 week before (7 days) - only if not already notified
            if (!shouldNotify && daysUntil === 7 && !task.notificationsSent.weekBefore) {
                shouldNotify = true;
                notificationText = `1 week until: ${task.text}`;
                task.notificationsSent.weekBefore = true;
            }
            // Check for 1 day before (1 day)
            else if (!shouldNotify && daysUntil === 1 && !task.notificationsSent.dayBefore) {
                shouldNotify = true;
                notificationText = `Tomorrow: ${task.text}`;
                task.notificationsSent.dayBefore = true;
            }
            // Check for day of (0 days) - only if task doesn't have time or already sent 1-min notification
            else if (!shouldNotify && daysUntil === 0 && !task.notificationsSent.dayOf) {
                // If task has time, wait for the 1-minute-before notification
                // If task doesn't have time, send day-of notification
                if (!hasTime) {
                    shouldNotify = true;
                    notificationText = `Today: ${task.text}`;
                    task.notificationsSent.dayOf = true;
                }
            }

            if (shouldNotify) {
                sendNotification(notificationText, notificationBody);
                // Save updated notification state
                saveTasks(data);
            }
        });
    } catch (error) {
        console.error('Error checking notifications:', error);
    }
}

// Send notification
function sendNotification(title, body) {
    if (!Notification.isSupported()) {
        console.log('Notifications not supported');
        return;
    }

    const notification = new Notification({
        title: title,
        body: body,
        silent: false
    });

    notification.show();
}

// Start notification checking
function startNotificationChecker() {
    // Check immediately
    checkNotifications();

    // Check every minute for precise timing (especially for 1-minute-before notifications)
    notificationCheckInterval = setInterval(() => {
        checkNotifications();
    }, 60 * 1000); // 1 minute
}

// Stop notification checking
function stopNotificationChecker() {
    if (notificationCheckInterval) {
        clearInterval(notificationCheckInterval);
        notificationCheckInterval = null;
    }
}

// Create the main window
function createWindow() {
    mainWindow = new BrowserWindow({
        width: 1100,
        height: 800,
        backgroundColor: '#1e1e1e',
        webPreferences: {
            preload: path.join(__dirname, 'preload.js'),
            contextIsolation: true,
            nodeIntegration: false
        },
        autoHideMenuBar: true
    });

    mainWindow.loadFile('index.html');
}

// IPC Handlers
ipcMain.handle('load-tasks', async () => {
    return await loadTasks();
});

ipcMain.handle('save-tasks', async (event, data) => {
    const result = await saveTasks(data);
    // Re-check notifications after saving
    if (result) {
        setTimeout(() => checkNotifications(), 1000);
    }
    return result;
});

ipcMain.handle('select-file', async () => {
    const result = await dialog.showOpenDialog(mainWindow, {
        properties: ['openFile'],
        filters: [
            { name: 'Images', extensions: ['jpg', 'jpeg', 'png', 'gif', 'webp'] },
            { name: 'Documents', extensions: ['pdf', 'doc', 'docx', 'txt'] },
            { name: 'All Files', extensions: ['*'] }
        ]
    });

    if (result.canceled) {
        return null;
    }

    const filePath = result.filePaths[0];
    const copiedPath = await copyFileToUploads(filePath);
    return copiedPath;
});

ipcMain.handle('delete-file', async (event, filePath) => {
    return await deleteUploadedFile(filePath);
});

// App lifecycle
app.whenReady().then(() => {
    // Request notification permission
    if (process.platform === 'win32') {
        app.setAppUserModelId(app.getName());
    }

    createWindow();
    startNotificationChecker();

    app.on('activate', () => {
        if (BrowserWindow.getAllWindows().length === 0) {
            createWindow();
        }
    });
});

app.on('window-all-closed', () => {
    stopNotificationChecker();
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.on('before-quit', () => {
    stopNotificationChecker();
});