background.js

// Color palette for tab groups
const GROUP_COLORS = ['blue', 'red', 'yellow', 'green', 'pink', 'purple', 'cyan', 'orange'];

// Extract domain from URL
function getDomain(url) {
    try {
        const urlObj = new URL(url);
        // Return hostname without 'www.' prefix for cleaner group names
        return urlObj.hostname.replace(/^www\./, '');
    } catch {
        return 'other';
    }
}

// Get a friendly short name for the domain/subdomain
function getGroupName(domain) {
    const parts = domain.split('.');

    // For subdomains like mail.google.com, docs.google.com - use the subdomain as name
    // Examples: mail.google.com -> Mail, docs.google.com -> Docs
    if (parts.length >= 3) {
        const subdomain = parts[0];
        // Skip generic subdomains, use parent domain instead
        if (['www', 'app', 'api', 'm', 'mobile'].includes(subdomain)) {
            return parts[1].charAt(0).toUpperCase() + parts[1].slice(1);
        }
        return subdomain.charAt(0).toUpperCase() + subdomain.slice(1);
    }

    // For regular domains, remove common TLDs and capitalize
    const shortName = domain
        .replace(/\.(com|org|net|io|dev|co|app)$/, '')
        .split('.')
        .pop();

    return shortName.charAt(0).toUpperCase() + shortName.slice(1);
}

// Assign a consistent color based on domain hash
function getColorForDomain(domain) {
    let hash = 0;
    for (let i = 0; i < domain.length; i++) {
        hash = ((hash << 5) - hash) + domain.charCodeAt(i);
        hash = hash & hash; // Convert to 32-bit integer
    }
    return GROUP_COLORS[Math.abs(hash) % GROUP_COLORS.length];
}

// Sort tabs by domain and create groups
async function sortAndGroupTabs() {
    // Get all tabs in the current window
    const tabs = await chrome.tabs.query({ currentWindow: true });

    // Skip chrome:// and edge:// internal pages
    const validTabs = tabs.filter(tab =>
        tab.url &&
        !tab.url.startsWith('chrome://') &&
        !tab.url.startsWith('edge://') &&
        !tab.url.startsWith('chrome-extension://')
    );

    if (validTabs.length === 0) {
        return { groupCount: 0, tabCount: 0 };
    }

    // Group tabs by domain
    const domainGroups = new Map();

    for (const tab of validTabs) {
        const domain = getDomain(tab.url);
        if (!domainGroups.has(domain)) {
            domainGroups.set(domain, []);
        }
        domainGroups.get(domain).push(tab.id);
    }

    // Sort domains by number of tabs (more tabs first)
    const sortedDomains = [...domainGroups.entries()]
        .sort((a, b) => b[1].length - a[1].length);

    let createdGroups = 0;

    // Create Chrome tab groups
    for (const [domain, tabIds] of sortedDomains) {
        // Only create groups for domains with 2+ tabs (skip single tabs)
        if (tabIds.length >= 2) {
            try {
                // First, move tabs to be adjacent
                await chrome.tabs.move(tabIds, { index: -1 });

                // Create the group
                const groupId = await chrome.tabs.group({ tabIds });

                // Update group properties
                await chrome.tabGroups.update(groupId, {
                    title: getGroupName(domain),
                    color: getColorForDomain(domain),
                    collapsed: true // Always collapse groups for cleaner view
                });

                createdGroups++;
            } catch (error) {
                console.error(`Failed to group tabs for ${domain}:`, error);
            }
        }
    }

    return {
        groupCount: createdGroups,
        tabCount: validTabs.length
    };
}

// Save all tabs to storage
async function saveTabs() {
    const tabs = await chrome.tabs.query({ currentWindow: true });

    // Filter and map tabs to save essential data
    const tabsToSave = tabs
        .filter(tab =>
            tab.url &&
            !tab.url.startsWith('chrome://') &&
            !tab.url.startsWith('edge://') &&
            !tab.url.startsWith('chrome-extension://')
        )
        .map(tab => ({
            url: tab.url,
            title: tab.title || 'Untitled',
            favIconUrl: tab.favIconUrl || ''
        }));

    // Save with timestamp
    const session = {
        tabs: tabsToSave,
        savedAt: new Date().toISOString(),
        tabCount: tabsToSave.length
    };

    await chrome.storage.local.set({ savedSession: session });

    return { tabCount: tabsToSave.length };
}

// Load saved tabs
async function loadTabs() {
    const result = await chrome.storage.local.get('savedSession');

    if (!result.savedSession || !result.savedSession.tabs) {
        return { tabCount: 0 };
    }

    const { tabs } = result.savedSession;

    // Open each saved tab
    for (const tab of tabs) {
        try {
            await chrome.tabs.create({
                url: tab.url,
                active: false // Don't switch focus to each new tab
            });
        } catch (error) {
            console.error(`Failed to open tab: ${tab.url}`, error);
        }
    }

    return { tabCount: tabs.length };
}

// Message handler
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    const handlers = {
        sortAndGroup: sortAndGroupTabs,
        saveTabs: saveTabs,
        loadTabs: loadTabs
    };

    const handler = handlers[message.action];

    if (handler) {
        handler()
            .then(result => sendResponse(result))
            .catch(error => sendResponse({ error: error.message }));

        // Return true to indicate async response
        return true;
    }

    sendResponse({ error: 'Unknown action' });
    return false;
});