/**
 * Process a list of URLs in batches, taking screenshots via API
 * @param {string[]} urls - Array of URLs to screenshot
 * @param {number} batchSize - Number of concurrent requests (default: 25)
 * @param {Object} options - Screenshot API options
 * @returns {Promise<Array>} - Results from all API calls
 */
async function processScreenshotBatches(urls, batchSize = 25, options = {}) {
  // Default API options
  const defaultOptions = {
    fmt: 'png',
    qual: 80,
    full: false,
    ads: true,
    cookie: true,
    track: true,
    wait: 0,
    clear: true,
    device: 'desktop',
    dark: false,
    width: 1920,
    height: 1080,
    scale: 1,
    mobile: false,
    touch: false,
    land: true,
    load: 'networkidle',
    timeout: 120,
    trans: false,
    key: '' // TODO: Add your API key here
  };
 
  // Merge default options with any provided options
  const apiOptions = { ...defaultOptions, ...options };
  
  // Results array to store all responses
  const results = [];
  
  // Process URLs in batches
  for (let i = 0; i < urls.length; i += batchSize) {
    console.log(`Processing batch ${i/batchSize + 1} of ${Math.ceil(urls.length/batchSize)}`);
    
    // Get current batch of URLs
    const batch = urls.slice(i, i + batchSize);
    
    // Create array of promises for current batch
    const batchPromises = batch.map(url => {
      return fetchScreenshot(url, apiOptions);
    });
    
    // Wait for all promises in current batch to resolve
    const batchResults = await Promise.all(batchPromises);
    
    // Add batch results to overall results
    results.push(...batchResults);
    
    // Optional: Add a small delay between batches to avoid overwhelming the API
    if (i + batchSize < urls.length) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
  
  return results;
}
 
/**
 * Fetch a screenshot for a single URL
 * @param {string} url - URL to screenshot
 * @param {Object} options - API options
 * @returns {Promise<Object>} - API response
 */
async function fetchScreenshot(url, options) {
  try {
    // Create a copy of options to avoid modifying the original
    const requestOptions = { ...options };
    
    // Add the URL parameter separately (don't double-encode)
    const params = new URLSearchParams();
    params.append('url', url);
    
    // Add all other options
    for (const [key, value] of Object.entries(requestOptions)) {
      params.append(key, value);
    }
    
    // Make API request
    const apiUrl = `https://api.screenshotsapi.dev/take?${params.toString()}`;
    console.log(`Fetching: ${apiUrl}`);
    
    const response = await fetch(apiUrl);
    
    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`API error: ${response.status} ${response.statusText} - ${errorText}`);
    }
    
    const data = await response.json();
    return {
      url,
      success: true,
      data
    };
  } catch (error) {
    console.error(`Error fetching screenshot for ${url}:`, error);
    return {
      url,
      success: false,
      error: error.message
    };
  }
}
 
// Example usage
async function main() {
  // Example list of URLs (you would replace this with your actual list of URLs)
  const urlsToProcess = [
    'https://sitelifter.com',
    'https://google.com',
    'https://github.com',
    // ... more URLs
  ];
  
  // Process URLs in batches of 25
  const results = await processScreenshotBatches(urlsToProcess);
  
  console.log(`Processed ${results.length} URLs`);
  console.log(`Successful: ${results.filter(r => r.success).length}`);
  console.log(`Failed: ${results.filter(r => !r.success).length}`);
 
  console.log(results);
  
  // Do something with the results
  return results;
}
 
// Export functions for use in other modules
module.exports = {
  processScreenshotBatches,
  fetchScreenshot
};