// Check premium status before enabling features
async function checkFeatureAccess(featureName) {
  const { license } = await chrome.storage.local.get('license');
  const premiumFeatures = ['bulk-export', 'cloud-sync', 'advanced-filters'];

  if (premiumFeatures.includes(featureName) && !license?.active) {
    showUpgradePrompt(featureName);
    return false;
  }
  return true;
}

// Store license status after validation
async function cacheLicenseStatus(licenseData) {
  await chrome.storage.local.set({
    license: {
      active: licenseData.active,
      plan: licenseData.plan,
      validUntil: licenseData.validUntil,
      cachedAt: Date.now()
    }
  });
}

// Open Stripe Checkout from extension popup
async function openCheckout(priceId) {
  const response = await fetch('https://your-api.com/create-checkout', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      priceId,
      extensionId: chrome.runtime.id,
      userId: await getUserId()
    })
  });

  const { url } = await response.json();
  chrome.tabs.create({ url });
}

// Listen for successful payment via your backend webhook
chrome.runtime.onMessageExternal.addListener(
  async (message, sender) => {
    if (message.type === 'PAYMENT_SUCCESS') {
      await cacheLicenseStatus(message.license);
      chrome.action.setBadgeText({ text: 'PRO' });
    }
  }
);

// Validate a license key against your server
async function validateLicenseKey(key) {
  const response = await fetch('https://your-api.com/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      key,
      extensionId: chrome.runtime.id,
      machineId: await getMachineFingerprint()
    })
  });

  const result = await response.json();
  if (result.valid) {
    await chrome.storage.local.set({
      license: { key, active: true, activatedAt: Date.now() }
    });
  }
  return result;
}

// Show relevant affiliate suggestions based on user context
function getAffiliateRecommendation(context) {
  const affiliateMap = {
    'hosting': {
      url: 'https://partner.example.com/hosting?ref=your-ext',
      text: 'Recommended hosting for extension backends'
    },
    'analytics': {
      url: 'https://partner.example.com/analytics?ref=your-ext',
      text: 'Privacy-first analytics we use ourselves'
    }
  };
  return affiliateMap[context] || null;
}

// Check API quota before making server calls
async function callBackendAPI(endpoint, data) {
  const { apiKey, quota } = await chrome.storage.local.get(['apiKey', 'quota']);

  if (!apiKey) {
    showUpgradePrompt('api-access');
    return null;
  }

  if (quota && quota.remaining <= 0) {
    showQuotaExceeded(quota.resetsAt);
    return null;
  }

  const response = await fetch(`https://api.your-service.com/${endpoint}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
  });

  // Update local quota cache
  const remaining = parseInt(response.headers.get('X-RateLimit-Remaining'));
  await chrome.storage.local.set({
    quota: { remaining, resetsAt: response.headers.get('X-RateLimit-Reset') }
  });

  return response.json();
}