Tab Name              | CPU    | Memory  | Network
----------------------|--------|---------|----------
Gmail (active)        | 12%    | 250 MB  | 45 KB/s
Slack (background)    | 3%     | 180 MB  | 2 KB/s
GitHub (background)   | 2%     | 95 MB   | 0 KB/s
News Site (idle)      | 1%     | 120 MB  | 0 KB/s

# Windows: Measure application power consumption
powercfg /energy /output power_report.html

# macOS: Check energy impact via Activity Monitor
# Or use: pmset -g log

// Tab Suspender Pro uses chrome.tabGroups API for intelligent batching
// and chrome.scripting to inject complete freeze scripts

async function suspendTab(tabId) {
  // Completely freeze the tab - no JS can run
  await chrome.scripting.executeScript({
    target: { tabId },
    func: () => {
      // Freeze all timers and connections
      window.cancelAnimationFrame(0);
      // Additional freeze logic...
    }
  });
  
  // Update tab to show suspended state
  await chrome.tabs.update(tabId, {
    autoDiscardable: true,
    discarded: true
  });
}

// Using Chrome's idle API to detect when to suspend
chrome.idle.onStateChanged.addListener((state) => {
  if (state === 'idle') {
    // User away - activate aggressive suspension
    activatePowerSavingMode();
  } else if (state === 'active') {
    // User returned - restore suspended tabs
    deactivatePowerSavingMode();
  }
});

// Check battery status (if available)
navigator.getBattery().then(battery => {
  if (battery.level < 0.2 && !battery.charging) {
    // Low battery - enable aggressive suspension
    enableLowPowerSuspension();
  }
  
  battery.addEventListener('levelchange', () => {
    if (battery.level < 0.2 && !battery.charging) {
      enableLowPowerSuspension();
    }
  });
});

// Suspend tabs after configurable idle time
const SUSPENSION_DELAY_MS = 300000; // 5 minutes default

chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  if (changeInfo.status === 'complete' && !tab.active) {
    // Start timer for this tab
    startSuspensionTimer(tabId, SUSPENSION_DELAY_MS);
  }
});

chrome.tabs.onActivated.addListener(({ tabId }) => {
  // Cancel timer when user switches to tab
  cancelSuspensionTimer(tabId);
});

// Never suspend whitelisted domains
const WHITELIST = ['localhost', 'docs.google.com', 'mail.google.com'];

function shouldSuspend(tab) {
  const url = new URL(tab.url);
  return !WHITELIST.some(domain => url.hostname.includes(domain));
}

class TabSuspensionManager {
  constructor() {
    this.suspendedTabs = new Map();
    this.suspensionConfig = {
      idleTime: 5 * 60 * 1000, // 5 minutes
      whitelist: [],
      excludePinned: true,
      excludePlaying: true
    };
  }

  async suspendTab(tabId) {
    const tab = await chrome.tabs.get(tabId);
    
    // Check if tab should be suspended
    if (!this.shouldSuspend(tab)) return false;
    
    try {
      // Save tab state
      const tabState = await this.captureTabState(tabId);
      this.suspendedTabs.set(tabId, tabState);
      
      // Discard the tab (frees memory)
      await chrome.tabs.discard(tabId);
      
      // Mark as suspended in our storage
      await this.markTabSuspended(tabId);
      
      return true;
    } catch (error) {
      console.error('Failed to suspend tab:', error);
      return false;
    }
  }

  async restoreTab(tabId) {
    const tabState = this.suspendedTabs.get(tabId);
    if (!tabState) return false;
    
    // Reopen the URL (this recreates the tab)
    const newTab = await chrome.tabs.create({
      url: tabState.url,
      active: tabState.isActive,
      pinned: tabState.isPinned
    });
    
    // Remove from suspended cache
    this.suspendedTabs.delete(tabId);
    
    return newTab.id;
  }
}