service_worker.js

// Privacy Shield Service Worker (Manifest V3)
// Implements aggressive tracker blocking and third-party cookie enforcement

// Import blocklist manager
importScripts('blocklist.js');


// Track blocked requests per tab
const blockedStats = new Map(); // tabId -> { count, domains: Set() }

// Get or create stats for a tab
function getTabStats(tabId) {
    if (!blockedStats.has(tabId)) {
        blockedStats.set(tabId, { count: 0, domains: new Set() });
    }
    return blockedStats.get(tabId);
}

// Clean up stats when tab is closed
chrome.tabs.onRemoved.addListener((tabId) => {
    blockedStats.delete(tabId);
});

// Reset stats when navigation occurs
chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
    if (changeInfo.status === 'loading') {
        blockedStats.delete(tabId);
    }
});


// Essential trackers to block immediately (fallback)
const ESSENTIAL_TRACKERS = [
    'google-analytics.com',
    'googletagmanager.com',
    'googlesyndication.com',
    'doubleclick.net',
    'googleadservices.com',
    'facebook.com/tr',
    'facebook.net',
    'scorecardresearch.com',
    'adservice.google',
    'analytics.google.com'
];

// Create immediate blocking rules from essential trackers
function createEssentialRules(allowlist = []) {
    return ESSENTIAL_TRACKERS.map((domain, index) => ({
        id: index + 1,
        priority: 1,
        action: { type: 'block' },
        condition: {
            urlFilter: `*://*.${domain}/*`,
            resourceTypes: ['script', 'xmlhttprequest', 'image', 'sub_frame', 'ping', 'other'],
            excludedInitiatorDomains: allowlist.length > 0 ? allowlist : undefined
        }
    }));
}

chrome.runtime.onInstalled.addListener(async (details) => {
    console.log('Privacy Shield: Extension installed/updated');

    try {
        // Load allowlist from storage
        const { allowlist = [] } = await chrome.storage.local.get(['allowlist']);
        console.log(`Privacy Shield: Loaded ${allowlist.length} allowlisted sites`);

        // STEP 1: Apply essential blocking rules IMMEDIATELY
        const essentialRules = createEssentialRules(allowlist);
        console.log('Privacy Shield: Applying essential tracker blocking rules...');

        await chrome.declarativeNetRequest.updateDynamicRules({
            removeRuleIds: await chrome.declarativeNetRequest.getDynamicRules().then(rules => rules.map(r => r.id)),
            addRules: essentialRules
        });

        console.log(`Privacy Shield: ${essentialRules.length} essential trackers blocked immediately`);

        // Verify rules were applied
        const appliedRules = await chrome.declarativeNetRequest.getDynamicRules();
        console.log(`Privacy Shield: ${appliedRules.length} rules currently active`);
        console.log('Privacy Shield: Sample rule:', appliedRules[0]);

        // STEP 2: Fetch comprehensive blocklist in background
        console.log('Privacy Shield: Fetching comprehensive blocklist...');

        try {
            const domains = await initializeBlocklist();
            console.log(`Privacy Shield: Loaded ${domains.length} tracker domains from blocklist`);

            // Convert to rules with allowlist
            const blocklistRules = domainsToRules(domains, allowlist);
            console.log(`Privacy Shield: Created ${blocklistRules.length} blocklist rules`);

            // IMPORTANT: Keep essential rules + add blocklist rules
            // Essential rules have wildcards like *.doubleclick.net which catch all subdomains
            // Blocklist has specific domains that might not be caught by wildcards

            // Adjust rule IDs to avoid conflicts
            const maxEssentialId = essentialRules.length;
            const adjustedBlocklistRules = blocklistRules.map(rule => ({
                ...rule,
                id: rule.id + maxEssentialId
            }));

            // Keep first 4990 blocklist rules (5000 total - 10 essential = 4990)
            const limitedBlocklistRules = adjustedBlocklistRules.slice(0, 4990);

            // Combine essential + blocklist
            const allRules = [...essentialRules, ...limitedBlocklistRules];

            // Update with combined rules (remove all first)
            const existingRuleIds = (await chrome.declarativeNetRequest.getDynamicRules()).map(rule => rule.id);

            await chrome.declarativeNetRequest.updateDynamicRules({
                removeRuleIds: existingRuleIds,
                addRules: allRules
            });

            console.log('Privacy Shield: Comprehensive tracker blocking rules applied');
            console.log(`Privacy Shield: ${allRules.length} total rules (${essentialRules.length} essential + ${limitedBlocklistRules.length} from blocklist)`);

            // Verify DoubleClick wildcard is active
            const finalRules = await chrome.declarativeNetRequest.getDynamicRules();
            const dclickRule = finalRules.find(r => r.condition.urlFilter && r.condition.urlFilter.includes('*.doubleclick.net'));
            console.log('Privacy Shield: DoubleClick wildcard rule active:', dclickRule ? '✅ YES' : '❌ NO');


            // Store activation status with comprehensive blocklist
            await chrome.storage.local.set({
                privacyShieldActive: true,
                activationTimestamp: Date.now(),
                blockedTrackers: allRules.length,
                totalDomains: domains.length + ESSENTIAL_TRACKERS.length
            });

        } catch (blocklistError) {
            console.error('Privacy Shield: Error loading comprehensive blocklist:', blocklistError);
            console.log('Privacy Shield: Continuing with essential trackers only');

            // Store partial activation status
            await chrome.storage.local.set({
                privacyShieldActive: true,
                activationTimestamp: Date.now(),
                blockedTrackers: essentialRules.length,
                totalDomains: ESSENTIAL_TRACKERS.length,
                lastError: blocklistError.message
            });
        }

        console.log('Privacy Shield: Fully activated and ready');

    } catch (error) {
        console.error('Privacy Shield: Critical error during initialization:', error);

        // Store error state
        await chrome.storage.local.set({
            privacyShieldActive: false,
            lastError: error.message
        });
    }
});

// Track blocked requests for statistics (only available in dev mode)
if (chrome.declarativeNetRequest.onRuleMatchedDebug) {
    chrome.declarativeNetRequest.onRuleMatchedDebug.addListener((details) => {
        console.log('Privacy Shield: Blocked request to', details.request.url);

        // Track per-tab statistics
        if (details.request.tabId && details.request.tabId >= 0) {
            const stats = getTabStats(details.request.tabId);
            stats.count++;

            // Extract domain from URL
            try {
                const url = new URL(details.request.url);
                stats.domains.add(url.hostname);
            } catch (e) {
                // Invalid URL, skip
            }
        }
    });
} else {
    console.log('Privacy Shield: onRuleMatchedDebug not available (normal in production)');
}

// Add alarm to periodically update the blocklist (once per day)
chrome.alarms.create('updateBlocklist', { periodInMinutes: 1440 });

chrome.alarms.onAlarm.addListener(async (alarm) => {
    if (alarm.name === 'updateBlocklist') {
        console.log('Privacy Shield: Updating blocklist...');

        try {
            const domains = await initializeBlocklist();
            const rules = domainsToRules(domains);
            const existingRuleIds = (await chrome.declarativeNetRequest.getDynamicRules()).map(rule => rule.id);

            await chrome.declarativeNetRequest.updateDynamicRules({
                removeRuleIds: existingRuleIds,
                addRules: rules
            });

            await chrome.storage.local.set({
                blockedTrackers: rules.length,
                totalDomains: domains.length,
                lastUpdate: Date.now()
            });

            console.log(`Privacy Shield: Blocklist updated - ${domains.length} domains`);
        } catch (error) {
            console.error('Privacy Shield: Error updating blocklist:', error);
        }
    }
});

// Listen for allowlist updates from popup
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    if (message.action === 'updateAllowlist') {
        console.log('Privacy Shield: Updating allowlist...', message.allowlist);

        // Reload all rules with new allowlist
        (async () => {
            try {
                const { blockedDomains = [] } = await chrome.storage.local.get(['blockedDomains']);

                let rules;
                if (blockedDomains.length > 0) {
                    rules = domainsToRules(blockedDomains, message.allowlist);
                } else {
                    rules = createEssentialRules(message.allowlist);
                }

                const existingRuleIds = (await chrome.declarativeNetRequest.getDynamicRules()).map(rule => rule.id);

                await chrome.declarativeNetRequest.updateDynamicRules({
                    removeRuleIds: existingRuleIds,
                    addRules: rules
                });

                console.log(`Privacy Shield: Rules updated with ${message.allowlist.length} allowlisted sites`);
            } catch (error) {
                console.error('Privacy Shield: Error updating allowlist:', error);
            }
        })();

        return true;
    }

    // Get stats for current tab
    if (message.action === 'getTabStats') {
        const stats = blockedStats.get(message.tabId);
        sendResponse({
            count: stats ? stats.count : 0,
            domains: stats ? Array.from(stats.domains) : []
        });
        return true;
    }
});

console.log('Privacy Shield: Service worker loaded');