background.js

// Keep track of active alerts and their tabs
let activeAlerts = {};
let checkInterval = null;

// Function to check a specific tab for alerts
function checkTabForAlerts(tabId, url) {
    // Get all alerts from storage
    chrome.storage.sync.get(['alerts'], (result) => {
        if (!result.alerts) return;

        // Check each alert configuration
        Object.entries(result.alerts).forEach(([alertId, config]) => {
            if (url.includes(config.targetUrl)) {
                // Execute content script to check for the word
                chrome.scripting.executeScript({
                    target: { tabId: tabId },
                    func: (targetWord) => {
                        return document.body.innerText.includes(targetWord);
                    },
                    args: [config.targetWord]
                }, (results) => {
                    if (results && results[0] && results[0].result) {
                        // Word found, trigger alarm
                        chrome.runtime.sendMessage({
                            action: "triggerAlarm",
                            alertId: alertId,
                            config: config
                        });
                    }
                });
            }
        });
    });
}

// Set up periodic checks for all tabs
function setupPeriodicChecks() {
    // Clear any existing intervals
    if (checkInterval) {
        clearInterval(checkInterval);
    }

    // Get all alerts and their intervals
    chrome.storage.sync.get(['alerts'], (result) => {
        if (!result.alerts) return;

        // Find the minimum interval to use as our check frequency
        const minInterval = Math.min(...Object.values(result.alerts).map(a => a.refreshInterval)) * 1000;
        
        // Set up periodic check
        checkInterval = setInterval(() => {
            // Get all tabs
            chrome.tabs.query({}, (tabs) => {
                // Check each tab
                tabs.forEach(tab => {
                    if (tab.url && tab.url.startsWith('http')) {
                        checkTabForAlerts(tab.id, tab.url);
                    }
                });
            });
        }, minInterval);
    });
}

// Listen for tab updates
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
    if (changeInfo.status === 'complete' && tab.url && tab.url.startsWith('http')) {
        checkTabForAlerts(tabId, tab.url);
    }
});

// Listen for storage changes
chrome.storage.onChanged.addListener((changes, namespace) => {
    if (namespace === 'sync' && changes.alerts) {
        setupPeriodicChecks();
    }
});

// Listen for alarm triggers
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    if (message.action === "triggerAlarm") {
        // Show notification
        chrome.notifications.create({
            type: 'basic',
            iconUrl: 'icon.png',
            title: 'Word Watcher Alert',
            message: `Found "${message.config.targetWord}" on ${message.config.targetUrl}`
        });

        // Play sound in all active tabs
        chrome.tabs.query({}, (tabs) => {
            tabs.forEach(tab => {
                chrome.tabs.sendMessage(tab.id, { action: "playAlertSound" });
            });
        });

        // Open notification page
        const notificationUrl = chrome.runtime.getURL('notification.html') + 
            `?alertId=${message.alertId}` +
            `&alertName=${encodeURIComponent(message.config.alertName)}` +
            `&targetWord=${encodeURIComponent(message.config.targetWord)}` +
            `&targetUrl=${encodeURIComponent(message.config.targetUrl)}`;
        
        chrome.tabs.create({ url: notificationUrl });
    }
});

// Initial setup
setupPeriodicChecks();