// Manifest V2 pattern (no longer works reliably)
let isPremium = false;
chrome.runtime.onStartup.addListener(() => {
  validateLicense().then(result => {
    isPremium = result.isPremium;
  });
});

// Manifest V3 pattern
chrome.alarms.create('licenseCheck', { periodInMinutes: 60 });

chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === 'licenseCheck') {
    validateLicense();
  }
});

// Validate when extension UI opens
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.type === 'getLicenseStatus') {
    validateLicense().then(status => {
      sendResponse({ isPremium: status.isPremium });
    });
    return true; // Keep channel open for async response
  }
});

async function validateLicense() {
  // Check cached status first
  const cached = await chrome.storage.local.get('licenseStatus');
  if (cached.licenseStatus?.validUntil > Date.now()) {
    return cached.licenseStatus;
  }
  
  // Fetch fresh status from your server
  const response = await fetch('https://your-api.com/validate', {
    headers: { 'Authorization': `Bearer ${await getAuthToken()}` }
  });
  const status = await response.json();
  
  // Cache the result
  await chrome.storage.local.set({ licenseStatus: status });
  return status;
}

// Create offscreen document for payment processing
async function openPaymentOffscreen() {
  // Check if already exists
  const existingContexts = await chrome.contextMenus?.getAll() || [];
  
  await chrome.offscreen.createDocument({
    url: 'offscreen/payment.html',
    reasons: ['DOM_PARSER', 'WEB_RTC'],
    justification: 'Processing payment transaction'
  });
}

// In your offscreen/payment.html
async function processPayment(paymentIntent) {
  // Process payment with Stripe.js or similar
  const result = await stripe.confirmPayment(paymentIntent);
  
  // Notify service worker of completion
  chrome.runtime.sendMessage({
    type: 'paymentComplete',
    status: result.status
  });
}

{
  "declarative_net_request": {
    "rule_resources": [{
      "id": "ruleset_1",
      "enabled": true,
      "path": "rules.json"
    }]
  }
}

// Store auth tokens in session storage (cleared on browser restart)
async function storeAuthToken(token) {
  await chrome.storage.session.set({ authToken: token });
}

async function getAuthToken() {
  const result = await chrome.storage.session.get('authToken');
  return result.authToken;
}

// Fall back to persistent storage for refresh tokens
async function storeRefreshToken(token) {
  await chrome.storage.local.set({ refreshToken: token });
}

// Initialize license check on extension startup
chrome.runtime.onInstalled.addListener(() => {
  // Check immediately on install
  validateLicense();
  
  // Schedule recurring checks
  chrome.alarms.create('licenseCheck', {
    delayInMinutes: 60,
    periodInMinutes: 60
  });
});

chrome.alarms.onAlarm.addListener(async (alarm) => {
  if (alarm.name === 'licenseCheck') {
    const status = await validateLicense();
    
    // Notify all open extension views
    const views = chrome.extension.getViews({ type: 'popup' });
    views.forEach(view => {
      view.postMessage({ type: 'licenseUpdate', status });
    });
    
    // If license was revoked, revoke access
    if (!status.isValid && status.revoked) {
      await chrome.storage.local.set({ 
        premiumAccess: false,
        licenseRevoked: true
      });
    }
  }
});

// 1. User clicks "Upgrade" in your extension
async function initiateUpgrade() {
  // 2. Create payment session on your server
  const response = await fetch('https://your-api.com/create-checkout-session', {
    method: 'POST',
    headers: { 
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${await getAuthToken()}`
    }
  });
  
  const { sessionId, url } = await response.json();
  
  // 3. Open the payment page
  // For Manifest V3, use tabs API to open payment URL
  chrome.tabs.create({ url });
  
  // 4. Set up webhook listener for payment completion
  // Your server notifies your extension via push or polling
  startPollingForPayment(sessionId);
}

// Alternative: Use Stripe.js in an offscreen document
async function openStripeCheckout() {
  await chrome.offscreen.createDocument({
    url: 'offscreen/stripe-checkout.html',
    reasons: ['DOM_PARSER'],
    justification: 'Processing payment'
  });
}

Chrome Extension ←→ External Website (your product)
                              ↓
                       Payment Provider
                              ↓
                       Webhook → Your API → Extension (via push or polling)

// In your extension's service worker

// 1. Detect when user is on your paid website
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  if (changeInfo.status === 'complete' && tab.url?.includes('yourproduct.com')) {
    // Check if user has premium access
    checkWebsiteAccess(tabId);
  }
});

async function checkWebsiteAccess(tabId) {
  const { premiumAccess } = await chrome.storage.local.get('premiumAccess');
  const { authToken } = await chrome.storage.session.get('authToken');
  
  if (!premiumAccess || !authToken) {
    // Notify the website of access status via content script
    chrome.tabs.sendMessage(tabId, { 
      type: 'accessStatus', 
      isPremium: false 
    });
    return;
  }
  
  // Validate token with your API
  const response = await fetch('https://yourproduct.com/api/validate-token', {
    headers: { 'Authorization': `Bearer ${authToken}` }
  });
  
  const isValid = response.ok;
  
  chrome.tabs.sendMessage(tabId, { 
    type: 'accessStatus', 
    isPremium: isValid 
  });
}

// In your website's JavaScript
window.addEventListener('message', async (event) => {
  if (event.source !== window) return;
  
  if (event.data.type === 'accessStatus') {
    if (!event.data.isPremium) {
      // Show upgrade prompt
      showUpgradePrompt();
    } else {
      // Enable premium features
      enablePremiumFeatures();
    }
  }
});

// Request access status from extension
window.postMessage({ type: 'getAccessStatus' }, '*');

let pendingPaymentSession = null;

async function startPaymentPolling(sessionId) {
  pendingPaymentSession = sessionId;
  
  // Poll every 30 seconds until payment completes or times out
  chrome.alarms.create(`payment-${sessionId}`, {
    delayInMinutes: 0.5,
    periodInMinutes: 0.5
  });
}

chrome.alarms.onAlarm.addListener(async (alarm) => {
  if (alarm.name.startsWith('payment-')) {
    const sessionId = alarm.name.replace('payment-', '');
    const status = await checkPaymentStatus(sessionId);
    
    if (status.completed) {
      // Update license
      await chrome.storage.local.set({ premiumAccess: true });
      chrome.alarms.clear(alarm.name);
      pendingPaymentSession = null;
      
      // Notify open views
      notifyPaymentComplete();
    } else if (status.failed || status.expired) {
      chrome.alarms.clear(alarm.name);
      pendingPaymentSession = null;
    }
  }
});

// Show badge while payment is pending
chrome.action.setBadgeText({ text: '!' });
chrome.action.setBadgeBackgroundColor({ color: '#F59E0B' });

// Clear when complete
chrome.action.setBadgeText({ text: '' });

chrome.runtime.onStartup.addListener(async () => {
  // Check for any pending purchases on startup
  const { pendingSession } = await chrome.storage.local.get('pendingSession');
  if (pendingSession) {
    const status = await checkPaymentStatus(pendingSession);
    if (status.completed) {
      await applyPremiumAccess();
      await chrome.storage.local.remove('pendingSession');
    }
  }
});