background.js

const DEFAULT_SETTINGS = {
    showWidget: false,
    reloadPage: true,
    closePopup: true,
    protectedWeb: false,
    clearCookies: true,
    clearCache: true,
    clearCacheStorage: true,
    clearFileSystems: false,
    clearIndexedDB: false,
    clearLocalStorage: true,
    clearSessionStorage: true,
    clearServiceWorkers: false,
    clearWebSQL: false,
    settingsVisited: false,
    lastSeenVersion: chrome.runtime.getManifest().version
};

/**
 * Clears data for a specific tab based on settings.
 * @param {chrome.tabs.Tab} tab - The tab to clear data for.
 * @param {Object} [settings] - Optional settings override.
 */
async function clearData(tab, settings = null) {
    if (!tab || !tab.url) {
        console.error("Tab or URL unavailable");
        return;
    }

    // Update badge to indicate processing
    chrome.action.setBadgeText({ text: "🗑️", tabId: tab.id });

    try {
        // Validate URL
        try {
            new URL(tab.url);
        } catch (e) {
            throw new Error("Invalid URL provided");
        }

        // Get settings if not provided
        if (!settings) {
            settings = await chrome.storage.local.get([
                "reloadPage", "clearCookies", "clearCache", "clearCacheStorage",
                "clearFileSystems", "clearIndexedDB", "clearLocalStorage",
                "clearSessionStorage", "clearServiceWorkers", "clearWebSQL",
                "protectedWeb"
            ]);
        }

        const origins = [tab.url];
        const originTypes = { unprotectedWeb: true };
        if (settings.protectedWeb) {
            originTypes.protectedWeb = true;
        }

        const removalOptions = {
            cache: settings.clearCache,
            cacheStorage: settings.clearCacheStorage,
            cookies: settings.clearCookies,
            fileSystems: settings.clearFileSystems,
            indexedDB: settings.clearIndexedDB,
            localStorage: settings.clearLocalStorage,
            serviceWorkers: settings.clearServiceWorkers,
            webSQL: settings.clearWebSQL
        };

        // 1. Clear via browsingData API
        try {
            await chrome.browsingData.remove({ originTypes, origins }, removalOptions);
        } catch (e) {
            console.error("Error clearing browsingData:", e);
            throw e;
        }

        // 2. Clear via Content Script (for Storage APIs that might need context or are more reliable from within)
        if (settings.clearLocalStorage || settings.clearSessionStorage || settings.clearIndexedDB) {
            try {
                await chrome.tabs.sendMessage(tab.id, {
                    action: "clearStorageData",
                    clearLocalStorage: settings.clearLocalStorage,
                    clearSessionStorage: settings.clearSessionStorage,
                    clearIndexedDB: settings.clearIndexedDB
                });
            } catch (e) {
                console.log("Content script unavailable or error:", e);
            }
        }

        // 3. Manual Cookie Cleanup (Fallback/Specific handling)
        if (settings.clearCookies) {
            try {
                const cookies = await chrome.cookies.getAll({ url: tab.url });
                for (const cookie of cookies) {
                    await removeCookie(cookie);
                }
            } catch (e) {
                console.log("Additional cookie clearing error:", e);
            }
        }

        // 4. Reload Page
        if (settings.reloadPage) {
            chrome.tabs.reload(tab.id);
        }

        // Success Badge
        chrome.action.setBadgeText({ text: "✅", tabId: tab.id });

    } catch (e) {
        console.error("Error clearing data:", e);
        chrome.action.setBadgeText({ text: "❌", tabId: tab.id });
    } finally {
        // Clear badge after delay
        setTimeout(() => {
            chrome.action.setBadgeText({ text: "", tabId: tab.id });
        }, 2000);
    }
}

/**
 * Manually removes a cookie.
 * @param {chrome.cookies.Cookie} cookie 
 */
function removeCookie(cookie) {
    return new Promise((resolve) => {
        const protocols = cookie.secure ? ["https:"] : ["http:", "https:"];
        let removed = false;
        let completed = 0;

        for (const protocol of protocols) {
            const domain = cookie.domain.startsWith(".") ? cookie.domain.substring(1) : cookie.domain;
            const url = `${protocol}//${domain}${cookie.path}`;

            const details = {
                url: url,
                name: cookie.name,
                storeId: cookie.storeId
            };

            if (cookie.partitionKey) {
                details.partitionKey = cookie.partitionKey;
            }

            chrome.cookies.remove(details, (details) => {
                completed++;
                if (details) removed = true;
                if (completed === protocols.length) {
                    resolve(removed);
                }
            });
        }
    });
}

// Event Listeners

chrome.action.onClicked.addListener(async (tab) => {
    // This might not trigger if a popup is defined in manifest, 
    // but kept for compatibility or if popup is removed.
    await clearData(tab);
});

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
    if (request.message === "clearSiteData") {
        clearData(sender.tab).then(() => {
            sendResponse({ success: true });
        }).catch((e) => {
            sendResponse({ success: false, error: e.message });
        });
        return true; // Keep channel open
    }

    if (request.message === "openPopupWithAutoClear") {
        chrome.action.openPopup();
        sendResponse({ success: true });
        return true;
    }

    if (request.action === "getCurrentSite") {
        const tab = sender.tab;
        if (tab && tab.url) {
            try {
                const url = new URL(tab.url);
                if (["chrome:", "chrome-extension:", "moz-extension:"].includes(url.protocol) || !url.hostname) {
                    sendResponse({ hostname: chrome.i18n.getMessage("currentSite") });
                } else {
                    sendResponse({ hostname: url.hostname, favIconUrl: tab.favIconUrl });
                }
            } catch (e) {
                sendResponse({ hostname: chrome.i18n.getMessage("currentSite") });
            }
        } else {
            sendResponse({ hostname: chrome.i18n.getMessage("currentSite") });
        }
        return true;
    }

    if (request.action === "clearDataFromPopup") {
        const tab = request.tab || sender.tab;
        if (tab && tab.url) {
            clearData(tab, request.settings).then(() => {
                sendResponse({ success: true });
            }).catch((e) => {
                sendResponse({ success: false, error: e.message });
            });
        } else {
            sendResponse({ success: false, error: "Unable to determine the current site" });
        }
        return true;
    }
});

chrome.runtime.onInstalled.addListener((details) => {
    if (details.reason === chrome.runtime.OnInstalledReason.INSTALL) {
        chrome.storage.local.set(DEFAULT_SETTINGS);
        const installDate = new Date().toISOString();
        chrome.storage.sync.set({ installDate });
    }
});