async function assessClientPortfolio(clientDomains) {
  // Split into batches of 50
  const batches = [];
  for (let i = 0; i < clientDomains.length; i += 50) {
    batches.push(clientDomains.slice(i, i + 50));
  }

  // Scan each batch
  const allResults = [];
  for (const batch of batches) {
    const response = await fetch(
      'https://api.compliancelayer.net/v1/batch/scan',
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          domains: batch,
          sort_by: 'risk'
        })
      }
    );

    const batchResults = await response.json();
    allResults.push(...batchResults.results);

    // Respect rate limits - wait 1 second between batches
    await new Promise(r => setTimeout(r, 1000));
  }

  // Analyze results
  const criticalDomains = allResults.filter(r => r.overall_score < 60);
  const passingDomains = allResults.filter(r => r.overall_score >= 80);

  console.log(`Portfolio Assessment Complete`);
  console.log(`Total domains: ${allResults.length}`);
  console.log(`Critical risk: ${criticalDomains.length}`);
  console.log(`Passing: ${passingDomains.length}`);
  console.log(`\nDomains requiring attention:`);

  criticalDomains.forEach(domain => {
    console.log(`- ${domain.domain}: ${domain.overall_grade}`);
  });

  return {
    total: allResults.length,
    critical: criticalDomains,
    passing: passingDomains,
    all: allResults
  };
}

// Usage
const clients = [
  'client-a.com',
  'client-b.com',
  'client-c.com',
  // ... up to 50+ domains
];

const report = await assessClientPortfolio(clients);

async function competitiveAnalysis(yourDomain, competitors) {
  const domains = [yourDomain, ...competitors];

  const response = await fetch(
    'https://api.compliancelayer.net/v1/batch/compare',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ domains })
    }
  );

  const comparison = await response.json();

  // Find your ranking
  const yourRank = comparison.ranked.find(r => r.domain === yourDomain);

  console.log(`Your Security Position:`);
  console.log(`Rank: #${yourRank.rank} out of ${comparison.ranked.length}`);
  console.log(`Score: ${yourRank.overall_score} (${yourRank.overall_grade})`);

  if (yourRank.rank === 1) {
    console.log(`\n🏆 You're the security leader!`);
  } else {
    const leader = comparison.ranked[0];
    const gap = leader.overall_score - yourRank.overall_score;
    console.log(`\nGap to leader: ${gap} points`);
  }

  // Identify weak areas
  console.log(`\nModule Analysis:`);
  Object.entries(comparison.module_comparison).forEach(([module, scores]) => {
    const yourScore = scores[yourDomain];
    const avgCompetitor = Object.entries(scores)
      .filter(([domain]) => domain !== yourDomain)
      .reduce((sum, [, score]) => sum + score, 0) / competitors.length;

    if (yourScore < avgCompetitor) {
      console.log(`⚠️  ${module}: Below average (yours: ${yourScore}, avg: ${avgCompetitor.toFixed(0)})`);
    }
  });

  return comparison;
}

// Usage
const results = await competitiveAnalysis(
  'your-company.com',
  ['competitor-a.com', 'competitor-b.com', 'competitor-c.com']
);

async function migrationTest(oldDomain, newDomain) {
  const response = await fetch(
    'https://api.compliancelayer.net/v1/batch/compare',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        domains: [oldDomain, newDomain]
      })
    }
  );

  const comparison = await response.json();

  const oldResult = comparison.full_results.find(r => r.domain === oldDomain);
  const newResult = comparison.full_results.find(r => r.domain === newDomain);

  console.log(`Migration Security Assessment`);
  console.log(`
Old Infrastructure (${oldDomain}):`);
  console.log(`  Score: ${oldResult.overall_score}`);
  console.log(`
New Infrastructure (${newDomain}):`);
  console.log(`  Score: ${newResult.overall_score}`);

  const diff = newResult.overall_score - oldResult.overall_score;
  if (diff > 0) {
    console.log(`
✅ Security improved by ${diff} points`);
  } else if (diff < 0) {
    console.log(`
⚠️  Security degraded by ${Math.abs(diff)} points`);
  } else {
    console.log(`
➡️  No change in security score`);
  }

  // Module-level differences
  console.log(`
Module Changes:`);
  Object.keys(comparison.module_comparison).forEach(module => {
    const oldScore = comparison.module_comparison[module][oldDomain];
    const newScore = comparison.module_comparison[module][newDomain];
    const change = newScore - oldScore;

    if (change !== 0) {
      const arrow = change > 0 ? '⬆' : '⬇';
      console.log(`  ${arrow} ${module}: ${oldScore} → ${newScore} (${change > 0 ? '+' : ''}${change})`);
    }
  });

  return comparison;
}

// Usage
await migrationTest('old-site.example.com', 'new-site.example.com');

// Check quota before batch
async function smartBatchScan(domains) {
  // Check remaining quota
  const limitsResponse = await fetch(
    'https://api.compliancelayer.net/v1/usage/limits',
    {
      headers: {
        'Authorization': `Bearer ${process.env.API_KEY}`
      }
    }
  );

  const limits = await limitsResponse.json();
  const remaining = limits.usage.scans_remaining;

  if (domains.length > remaining) {
    console.warn(`⚠️  Batch size (${domains.length}) exceeds remaining quota (${remaining})`);
    console.log(`Scanning only first ${remaining} domains`);
    domains = domains.slice(0, remaining);
  }

  // Proceed with batch
  return await batchScan(domains);
}

async function batchScanWithRetry(domains) {
  const response = await fetch(
    'https://api.compliancelayer.net/v1/batch/scan',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ domains })
    }
  );

  const results = await response.json();

  // Separate successful and failed scans
  const successful = results.results.filter(r => r.error === null);
  const failed = results.results.filter(r => r.error !== null);

  if (failed.length > 0) {
    console.log(`⚠️  ${failed.length} domains failed:`);
    failed.forEach(result => {
      console.log(`  - ${result.domain}: ${result.error}`);
    });

    // Optionally retry failed domains
    if (failed.length < 5) {
      console.log('Retrying failed domains...');
      const retryDomains = failed.map(r => r.domain);
      // ... retry logic
    }
  }

  return { successful, failed };
}

const cache = new Map();

async function cachedCompare(domains) {
  const cacheKey = domains.sort().join(',');

  // Check cache
  if (cache.has(cacheKey)) {
    const cached = cache.get(cacheKey);
    if (Date.now() - cached.timestamp < 3600000) { // 1 hour
      console.log('Using cached comparison');
      return cached.data;
    }
  }

  // Fetch fresh data
  const comparison = await compareDomains(domains);

  // Cache result
  cache.set(cacheKey, {
    data: comparison,
    timestamp: Date.now()
  });

  return comparison;
}