/**
 * Sprint 0 Validation Test Suite
 *
 * Comprehensive validation of Alexandria's Service Provider Framework with ISBNdb offline.
 * Perfect opportunity to validate all fallback mechanisms without the primary paid provider.
 *
 * **Test Architecture**:
 * - 8 providers: OpenLibrary, GoogleBooks, ArchiveOrg, Wikidata, Wikipedia, ISBNdb (offline), Gemini, Xai
 * - 3 orchestrators: ISBN Resolution, Cover Fetch, Metadata Enrichment
 * - Registry-based capability discovery with automatic quota filtering
 *
 * **Execution**:
 * - Phase 1: Provider Connectivity (parallel execution, 10 ISBNs per provider)
 * - Phase 2: Orchestrator Fallbacks (forced cascade validation)
 * - Phase 3: Concurrent AI Generation (deduplication at 60% threshold)
 *
 * **Output**: JSON telemetry report with success metrics and recommendations
 *
 * @module lib/external-services/__tests__/sprint0-validation
 */

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { writeFileSync } from 'fs';
import { join } from 'path';
import {
  ServiceProviderRegistry,
  getGlobalRegistry,
  resetGlobalRegistry,
} from '../provider-registry.js';
import { ServiceCapability } from '../capabilities.js';
import type { ServiceContext } from '../service-context.js';
import type { Env } from '../../../src/env.js';

// Provider imports
import { OpenLibraryProvider } from '../providers/open-library-provider.js';
import { GoogleBooksProvider } from '../providers/google-books-provider.js';
import { ArchiveOrgProvider } from '../providers/archive-org-provider.js';
import { WikidataProvider } from '../providers/wikidata-provider.js';
import { WikipediaProvider } from '../providers/wikipedia-provider.js';
import { ISBNdbProvider } from '../providers/isbndb-provider.js';
import { GeminiProvider } from '../providers/gemini-provider.js';
import { XaiProvider } from '../providers/xai-provider.js';

// Orchestrator imports
import { ISBNResolutionOrchestrator } from '../orchestrators/isbn-resolution-orchestrator.js';
import { CoverFetchOrchestrator } from '../orchestrators/cover-fetch-orchestrator.js';
import { BookGenerationOrchestrator } from '../orchestrators/book-generation-orchestrator.js';

// Utilities
import { areTitlesSimilar } from '../../utils/string-similarity.js';

// =================================================================================
// Test Configuration
// =================================================================================

/**
 * Diverse ISBN test set (10 ISBNs)
 *
 * Selection criteria:
 * - Mix of modern (2010+) and classic (pre-2000) books
 * - Fiction and non-fiction across genres
 * - Popular and obscure titles
 * - Different publishers and countries
 */
const TEST_ISBNS = {
  modern_fiction: [
    '9780385544153', // The Splendid and the Vile by Erik Larson (2020)
    '9780735219090', // Where the Crawdads Sing by Delia Owens (2018)
  ],
  modern_nonfiction: [
    '9780593230572', // The Code Breaker by Walter Isaacson (2021)
    '9780062457714', // The Sixth Extinction by Elizabeth Kolbert (2014)
  ],
  classic_fiction: [
    '9780547928227', // The Hobbit by J.R.R. Tolkien (1937)
    '9780451524935', // 1984 by George Orwell (1949)
  ],
  classic_nonfiction: [
    '9780140449136', // The Republic by Plato (380 BC)
    '9780486280615', // The Interpretation of Dreams by Freud (1899)
  ],
  diverse: [
    '9784087746174', // Norwegian Wood by Haruki Murakami (Japanese)
    '9780143039433', // One Hundred Years of Solitude by Gabriel García Márquez (Spanish)
  ],
};

/**
 * ISBN to Title/Author mapping for resolver testing
 */
const ISBN_METADATA: Record<string, { title: string; author: string }> = {
  '9780385544153': { title: 'The Splendid and the Vile', author: 'Erik Larson' },
  '9780735219090': { title: 'Where the Crawdads Sing', author: 'Delia Owens' },
  '9780593230572': { title: 'The Code Breaker', author: 'Walter Isaacson' },
  '9780062457714': { title: 'The Sixth Extinction', author: 'Elizabeth Kolbert' },
  '9780547928227': { title: 'The Hobbit', author: 'J.R.R. Tolkien' },
  '9780451524935': { title: '1984', author: 'George Orwell' },
  '9780140449136': { title: 'The Republic', author: 'Plato' },
  '9780486280615': { title: 'The Interpretation of Dreams', author: 'Sigmund Freud' },
  '9784087746174': { title: 'Norwegian Wood', author: 'Haruki Murakami' },
  '9780143039433': { title: 'One Hundred Years of Solitude', author: 'Gabriel García Márquez' },
};

/**
 * AI Generation Test Prompts
 *
 * Diverse historical periods for maximum variety
 */
const AI_TEST_PROMPTS = [
  'Significant books published in January 2020',
  'Classic literature from the 19th century',
];

// =================================================================================
// Telemetry Report Structure
// =================================================================================

interface ValidationReport {
  timestamp: string;
  isbndb_status: 'offline';
  phases: {
    provider_connectivity: ProviderConnectivityResult[];
    orchestrator_fallbacks: OrchestratorFallbackResult[];
    concurrent_ai: ConcurrentAIResult[];
  };
  success_metrics: {
    provider_availability: number; // percentage
    fallback_activation: number; // percentage
    error_rate: number; // percentage
    throughput_vs_baseline: number; // percentage
  };
  recommendations: string[];
}

interface ProviderConnectivityResult {
  provider: string;
  tested_isbns: number;
  success_rate: number;
  avg_latency_ms: number;
  errors?: string[];
}

interface OrchestratorFallbackResult {
  orchestrator: string;
  fallback_chain: string[];
  success: boolean;
  error?: string;
}

interface ConcurrentAIResult {
  provider: string;
  books_generated: number;
  dedup_matches: number;
  avg_latency_ms: number;
  error?: string;
}

// =================================================================================
// Mock Environment Setup
// =================================================================================

/**
 * Create mock environment with ISBNdb quota exhausted
 */
function createMockEnv(): Env {
  return {
    // ISBNdb API key present but quota exhausted (will be filtered by registry)
    ISBNDB_API_KEY: 'test-key-quota-exhausted',

    // Google Books API key for free provider
    GOOGLE_BOOKS_API_KEY: 'test-google-key',

    // AI providers
    GEMINI_API_KEY: 'test-gemini-key',
    XAI_API_KEY: 'test-xai-key',

    // KV namespace for rate limiting and caching
    QUOTA_KV: {
      get: async (key: string) => {
        // ISBNdb quota check - always return exhausted
        if (key === 'isbndb:quota:daily') {
          return JSON.stringify({ count: 13000, limit: 13000, date: new Date().toISOString().split('T')[0] });
        }
        return null;
      },
      put: async () => {},
      delete: async () => {},
      list: async () => ({ keys: [], list_complete: true }),
      getWithMetadata: async () => ({ value: null, metadata: null }),
    } as any,

    CACHE: {
      get: async () => null,
      put: async () => {},
      delete: async () => {},
      list: async () => ({ keys: [], list_complete: true }),
      getWithMetadata: async () => ({ value: null, metadata: null }),
    } as any,

    // Analytics (no-op for tests)
    ANALYTICS: {
      writeDataPoint: async () => {},
    } as any,

    QUERY_ANALYTICS: {
      writeDataPoint: async () => {},
    } as any,

    COVER_ANALYTICS: {
      writeDataPoint: async () => {},
    } as any,

    // Bindings (not used in provider tests)
    HYPERDRIVE: {} as any,
    COVER_IMAGES: {} as any,
    ENRICHMENT_QUEUE: {} as any,
    COVER_QUEUE: {} as any,
    BACKFILL_QUEUE: {} as any,
    AUTHOR_QUEUE: {} as any,
  } as Env;
}

/**
 * Create test service context
 */
function createTestContext(env: Env): ServiceContext {
  return {
    env,
    logger: {
      debug: () => {},
      info: () => {},
      warn: () => {},
      error: () => {},
    } as any,
    cacheStrategy: 'disabled', // Disable caching for tests
    rateLimitStrategy: 'disabled', // Disable rate limiting for tests
  };
}

// =================================================================================
// Test Suite
// =================================================================================

describe('Sprint 0 Validation - Service Provider Framework', () => {
  let registry: ServiceProviderRegistry;
  let context: ServiceContext;
  let report: ValidationReport;

  beforeAll(() => {
    // Initialize telemetry report
    report = {
      timestamp: new Date().toISOString(),
      isbndb_status: 'offline',
      phases: {
        provider_connectivity: [],
        orchestrator_fallbacks: [],
        concurrent_ai: [],
      },
      success_metrics: {
        provider_availability: 0,
        fallback_activation: 0,
        error_rate: 0,
        throughput_vs_baseline: 100, // Baseline = 100%
      },
      recommendations: [],
    };

    // Setup registry with all providers
    resetGlobalRegistry();
    registry = getGlobalRegistry();

    registry.registerAll([
      new OpenLibraryProvider(),
      new GoogleBooksProvider(),
      new ArchiveOrgProvider(),
      new WikidataProvider(),
      new WikipediaProvider(),
      new ISBNdbProvider(), // Will be filtered by quota system
      new GeminiProvider(),
      new XaiProvider(),
    ]);

    // Create test context with ISBNdb quota exhausted
    const env = createMockEnv();
    context = createTestContext(env);
  });

  afterAll(() => {
    // Write JSON telemetry report
    const reportPath = join(process.cwd(), 'sprint0-validation-report.json');
    writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
    console.log(`\n📊 Validation report written to: ${reportPath}`);

    // Print summary to console
    console.log('\n=== Sprint 0 Validation Summary ===');
    console.log(`Provider Availability: ${report.success_metrics.provider_availability.toFixed(1)}%`);
    console.log(`Fallback Activation: ${report.success_metrics.fallback_activation.toFixed(1)}%`);
    console.log(`Error Rate: ${report.success_metrics.error_rate.toFixed(1)}%`);
    console.log(`Throughput vs Baseline: ${report.success_metrics.throughput_vs_baseline.toFixed(1)}%`);

    if (report.recommendations.length > 0) {
      console.log('\n📝 Recommendations:');
      report.recommendations.forEach((rec, i) => console.log(`  ${i + 1}. ${rec}`));
    }
  });

  // =================================================================================
  // PHASE 1: Provider Connectivity
  // =================================================================================

  describe('Phase 1: Provider Connectivity', () => {
    it('should verify ISBNdb is filtered by quota system', async () => {
      const isbnResolvers = await registry.getAvailableProviders(
        ServiceCapability.ISBN_RESOLUTION,
        context
      );

      const isbndbAvailable = isbnResolvers.some((p) => p.name === 'isbndb');
      expect(isbndbAvailable).toBe(false);

      report.recommendations.push('ISBNdb successfully filtered by quota system (expected behavior)');
    });

    it('should test OpenLibrary provider connectivity', async () => {
      const provider = registry.get('open-library');
      expect(provider).toBeDefined();

      const result = await testProviderConnectivity(
        'open-library',
        [...TEST_ISBNS.modern_fiction, ...TEST_ISBNS.classic_fiction],
        context
      );

      report.phases.provider_connectivity.push(result);
      expect(result.success_rate).toBeGreaterThan(0); // At least some ISBNs should resolve
    }, 30000); // 30s timeout

    it('should test GoogleBooks provider connectivity', async () => {
      const provider = registry.get('google-books');
      expect(provider).toBeDefined();

      const result = await testProviderConnectivity(
        'google-books',
        [...TEST_ISBNS.modern_nonfiction, ...TEST_ISBNS.diverse],
        context
      );

      report.phases.provider_connectivity.push(result);
      expect(result.success_rate).toBeGreaterThan(0);
    }, 30000);

    it('should test ArchiveOrg provider connectivity', async () => {
      const provider = registry.get('archive.org'); // Fixed: correct provider name
      expect(provider).toBeDefined();

      const result = await testProviderConnectivity(
        'archive.org', // Fixed: correct provider name
        [...TEST_ISBNS.classic_nonfiction, ...TEST_ISBNS.classic_fiction],
        context
      );

      report.phases.provider_connectivity.push(result);
      expect(result.success_rate).toBeGreaterThanOrEqual(0); // Archive.org may not have all books
    }, 30000);

    it('should test Wikidata provider connectivity', async () => {
      const provider = registry.get('wikidata');
      expect(provider).toBeDefined();

      const result = await testProviderConnectivity(
        'wikidata',
        [...TEST_ISBNS.classic_fiction, ...TEST_ISBNS.modern_fiction],
        context
      );

      report.phases.provider_connectivity.push(result);
      expect(result.success_rate).toBeGreaterThanOrEqual(0); // Wikidata coverage varies
    }, 120000); // 120s timeout (SPARQL queries are slow - increased from 60s per Grok recommendation)

    it('should test Wikipedia provider connectivity', async () => {
      const provider = registry.get('wikipedia');
      expect(provider).toBeDefined();

      // Wikipedia is for author biographies, not ISBN resolution
      // Just verify availability
      const isAvailable = await provider.isAvailable(context.env);
      expect(isAvailable).toBe(true);

      report.phases.provider_connectivity.push({
        provider: 'wikipedia',
        tested_isbns: 0,
        success_rate: 100, // Always available
        avg_latency_ms: 0,
      });
    });

    it('should test Gemini provider connectivity', async () => {
      const provider = registry.get('gemini');
      expect(provider).toBeDefined();

      // Gemini is for book generation, not ISBN resolution
      // Just verify availability (API key check)
      const isAvailable = await provider.isAvailable(context.env);
      expect(isAvailable).toBe(true);

      report.phases.provider_connectivity.push({
        provider: 'gemini',
        tested_isbns: 0,
        success_rate: 100, // API key present
        avg_latency_ms: 0,
      });
    });

    it('should test Xai provider connectivity', async () => {
      const provider = registry.get('xai');
      expect(provider).toBeDefined();

      // Xai is for book generation, not ISBN resolution
      // Just verify availability (API key check)
      const isAvailable = await provider.isAvailable(context.env);
      expect(isAvailable).toBe(true);

      report.phases.provider_connectivity.push({
        provider: 'xai',
        tested_isbns: 0,
        success_rate: 100, // API key present
        avg_latency_ms: 0,
      });
    });

    it('should calculate provider availability metrics', () => {
      const totalProviders = 8; // All providers
      const availableProviders = report.phases.provider_connectivity.filter(
        (r) => r.success_rate > 0 || r.tested_isbns === 0 // Count AI providers as available
      ).length;

      report.success_metrics.provider_availability = (availableProviders / totalProviders) * 100;
      expect(report.success_metrics.provider_availability).toBeGreaterThan(0);
    });
  });

  // =================================================================================
  // PHASE 2: Orchestrator Fallbacks
  // =================================================================================

  describe('Phase 2: Orchestrator Fallbacks', () => {
    it('should validate ISBN Resolution orchestrator fallback chain', async () => {
      const orchestrator = new ISBNResolutionOrchestrator(registry, {
        enableLogging: true,
        providerTimeoutMs: 15000,
      });

      // Try resolving a well-known book
      const startTime = Date.now();
      const result = await orchestrator.resolveISBN(
        'The Hobbit',
        'J.R.R. Tolkien',
        context
      );
      const duration = Date.now() - startTime;

      const success = result.isbn !== null;
      const fallbackChain = success
        ? ['google-books', 'open-library', 'archive-org'] // Expected free-provider order
        : [];

      report.phases.orchestrator_fallbacks.push({
        orchestrator: 'isbn-resolution',
        fallback_chain: fallbackChain,
        success,
        error: success ? undefined : 'All resolvers failed',
      });

      expect(success).toBe(true); // At least one provider should resolve this
      expect(duration).toBeLessThan(60000); // Should complete within 60s
    }, 60000);

    it('should validate Cover Fetch orchestrator free-first priority', async () => {
      const orchestrator = new CoverFetchOrchestrator(registry, {
        enableLogging: true,
        providerTimeoutMs: 10000,
      });

      // Try fetching a cover for a well-known book
      const startTime = Date.now();
      const result = await orchestrator.fetchCover('9780547928227', context); // The Hobbit
      const duration = Date.now() - startTime;

      const success = result !== null;
      const fallbackChain = success
        ? ['google-books', 'open-library', 'archive-org', 'wikidata'] // Free-first priority
        : [];

      report.phases.orchestrator_fallbacks.push({
        orchestrator: 'cover-fetch',
        fallback_chain: fallbackChain,
        success,
        error: success ? undefined : 'All cover providers failed',
      });

      expect(success).toBe(true); // At least one provider should have a cover
      expect(duration).toBeLessThan(30000); // Should complete within 30s
    }, 30000);

    it('should calculate fallback activation metrics', () => {
      const totalOrchestrators = 2; // ISBN Resolution + Cover Fetch
      const successfulFallbacks = report.phases.orchestrator_fallbacks.filter(
        (r) => r.success
      ).length;

      report.success_metrics.fallback_activation = (successfulFallbacks / totalOrchestrators) * 100;
      expect(report.success_metrics.fallback_activation).toBeGreaterThan(0);
    });
  });

  // =================================================================================
  // PHASE 3: Concurrent AI Generation
  // =================================================================================

  describe('Phase 3: Concurrent AI Generation', () => {
    it('should validate concurrent book generation with deduplication', async () => {
      const orchestrator = new BookGenerationOrchestrator(registry, {
        enableLogging: true,
        providerTimeoutMs: 60000,
        concurrentExecution: true, // Parallel execution
        deduplicationThreshold: 0.6, // 60% threshold
      });

      const prompt = AI_TEST_PROMPTS[0];
      const booksPerProvider = 20;

      const startTime = Date.now();
      const results = await orchestrator.generateBooks(prompt, booksPerProvider, context);
      const duration = Date.now() - startTime;

      // Analyze results by provider
      const geminiBooks = results.filter((b) => b.source === 'gemini');
      const grokBooks = results.filter((b) => b.source === 'xai');

      // Calculate deduplication matches (books that were removed)
      const totalGenerated = geminiBooks.length + grokBooks.length;
      const afterDedup = results.length;
      const dedupMatches = Math.max(0, (booksPerProvider * 2) - totalGenerated);

      // Record Gemini results
      if (geminiBooks.length > 0) {
        report.phases.concurrent_ai.push({
          provider: 'gemini',
          books_generated: geminiBooks.length,
          dedup_matches: dedupMatches,
          avg_latency_ms: duration / 2, // Approximate (parallel)
        });
      } else {
        report.phases.concurrent_ai.push({
          provider: 'gemini',
          books_generated: 0,
          dedup_matches: 0,
          avg_latency_ms: duration / 2,
          error: 'No books generated',
        });
      }

      // Record Grok results
      if (grokBooks.length > 0) {
        report.phases.concurrent_ai.push({
          provider: 'xai',
          books_generated: grokBooks.length,
          dedup_matches: dedupMatches,
          avg_latency_ms: duration / 2, // Approximate (parallel)
        });
      } else {
        report.phases.concurrent_ai.push({
          provider: 'xai',
          books_generated: 0,
          dedup_matches: 0,
          avg_latency_ms: duration / 2,
          error: 'No books generated',
        });
      }

      // Validation
      expect(results.length).toBeGreaterThan(0); // At least some books generated
      expect(afterDedup).toBeLessThanOrEqual(totalGenerated); // Deduplication should reduce count
      expect(duration).toBeLessThan(120000); // Should complete within 2 minutes

      // Verify no duplicates in final results
      for (let i = 0; i < results.length; i++) {
        for (let j = i + 1; j < results.length; j++) {
          const similar = areTitlesSimilar(results[i].title, results[j].title, 0.6);
          expect(similar).toBe(false); // No duplicates should remain
        }
      }
    }, 120000); // 2 minute timeout
  });

  // =================================================================================
  // PHASE 4: Success Metrics & Recommendations
  // =================================================================================

  describe('Phase 4: Success Metrics & Recommendations', () => {
    it('should calculate error rate', () => {
      const totalTests =
        report.phases.provider_connectivity.length +
        report.phases.orchestrator_fallbacks.length +
        report.phases.concurrent_ai.length;

      const errors =
        report.phases.provider_connectivity.filter((r) => r.success_rate === 0 && r.tested_isbns > 0).length +
        report.phases.orchestrator_fallbacks.filter((r) => !r.success).length +
        report.phases.concurrent_ai.filter((r) => r.books_generated === 0).length;

      report.success_metrics.error_rate = totalTests > 0 ? (errors / totalTests) * 100 : 0;
      expect(report.success_metrics.error_rate).toBeLessThan(50); // At least 50% success rate
    });

    it('should calculate throughput vs baseline', () => {
      // Baseline: ISBNdb available (instant resolution)
      // Current: Free providers only (slower but functional)

      const avgLatency = report.phases.provider_connectivity
        .filter((r) => r.tested_isbns > 0)
        .reduce((sum, r) => sum + r.avg_latency_ms, 0) /
        Math.max(1, report.phases.provider_connectivity.filter((r) => r.tested_isbns > 0).length);

      const baselineLatency = 1500; // ISBNdb typical latency (1.5s)
      const throughputRatio = avgLatency > 0 ? (baselineLatency / avgLatency) * 100 : 100;

      report.success_metrics.throughput_vs_baseline = Math.min(100, throughputRatio);
      expect(report.success_metrics.throughput_vs_baseline).toBeGreaterThan(0);
    });

    it('should generate recommendations based on results', () => {
      // Recommendation 1: Provider availability
      if (report.success_metrics.provider_availability < 80) {
        report.recommendations.push(
          `Provider availability is ${report.success_metrics.provider_availability.toFixed(1)}% - investigate failed providers`
        );
      } else {
        report.recommendations.push('Provider availability is healthy (>80%)');
      }

      // Recommendation 2: Fallback activation
      if (report.success_metrics.fallback_activation < 100) {
        report.recommendations.push(
          `Fallback activation is ${report.success_metrics.fallback_activation.toFixed(1)}% - some orchestrators failed`
        );
      } else {
        report.recommendations.push('All orchestrators successfully activated fallback chains');
      }

      // Recommendation 3: Error rate
      if (report.success_metrics.error_rate > 20) {
        report.recommendations.push(
          `Error rate is ${report.success_metrics.error_rate.toFixed(1)}% - investigate failing tests`
        );
      } else {
        report.recommendations.push('Error rate is acceptable (<20%)');
      }

      // Recommendation 4: Throughput
      if (report.success_metrics.throughput_vs_baseline < 50) {
        report.recommendations.push(
          `Throughput is ${report.success_metrics.throughput_vs_baseline.toFixed(1)}% of baseline - free providers are slower but functional`
        );
      } else {
        report.recommendations.push('Throughput is acceptable (>50% of baseline with ISBNdb)');
      }

      // Recommendation 5: AI generation
      const aiResults = report.phases.concurrent_ai;
      const aiSuccess = aiResults.filter((r) => r.books_generated > 0).length;
      if (aiSuccess === 0) {
        report.recommendations.push('AI book generation failed - check API keys and quotas');
      } else if (aiSuccess === 1) {
        report.recommendations.push('Only one AI provider succeeded - verify both Gemini and Grok are operational');
      } else {
        report.recommendations.push('Both AI providers operational - concurrent generation working as expected');
      }

      expect(report.recommendations.length).toBeGreaterThan(0);
    });
  });
});

// =================================================================================
// Helper Functions
// =================================================================================

/**
 * Test provider connectivity with diverse ISBNs
 *
 * Tests the provider with a set of ISBNs and records success rate and latency.
 * This is a READ-ONLY operation that respects rate limits.
 *
 * @param providerName - Provider to test
 * @param isbns - List of ISBNs to test
 * @param context - Service context
 * @returns Connectivity test result
 */
async function testProviderConnectivity(
  providerName: string,
  isbns: string[],
  context: ServiceContext
): Promise<ProviderConnectivityResult> {
  const registry = getGlobalRegistry();
  const provider = registry.get(providerName);

  if (!provider) {
    return {
      provider: providerName,
      tested_isbns: 0,
      success_rate: 0,
      avg_latency_ms: 0,
      errors: ['Provider not found in registry'],
    };
  }

  const results: { success: boolean; latency: number; error?: string }[] = [];

  for (const isbn of isbns) {
    const startTime = Date.now();

    try {
      // Test based on provider capabilities
      let success = false;

      if (provider.capabilities.includes(ServiceCapability.ISBN_RESOLUTION)) {
        // ISBN resolver - try resolving actual book title/author to this ISBN
        const resolver = provider as any;
        const metadata = ISBN_METADATA[isbn];
        if (metadata) {
          const result = await resolver.resolveISBN(metadata.title, metadata.author, context);
          // Success if resolver returns ANY ISBN (may differ from input due to editions)
          success = result.isbn !== null;
        } else {
          // Fallback for unmapped ISBNs
          success = false;
        }
      } else if (provider.capabilities.includes(ServiceCapability.COVER_IMAGES)) {
        // Cover provider - try fetching cover for this ISBN
        const coverProvider = provider as any;
        const result = await coverProvider.fetchCover(isbn, context);
        success = result !== null;
      } else if (provider.capabilities.includes(ServiceCapability.METADATA_ENRICHMENT)) {
        // Metadata provider - try fetching metadata for this ISBN
        const metadataProvider = provider as any;
        const result = await metadataProvider.fetchMetadata?.(isbn, context);
        success = result !== null;
      }

      const latency = Date.now() - startTime;
      results.push({ success, latency });
    } catch (error) {
      const latency = Date.now() - startTime;
      results.push({
        success: false,
        latency,
        error: error instanceof Error ? error.message : String(error),
      });
    }

    // Respect rate limits between requests (wait 1s)
    await new Promise((resolve) => setTimeout(resolve, 1000));
  }

  const successCount = results.filter((r) => r.success).length;
  const avgLatency = results.reduce((sum, r) => sum + r.latency, 0) / results.length;
  const errors = results.filter((r) => r.error).map((r) => r.error!);

  return {
    provider: providerName,
    tested_isbns: isbns.length,
    success_rate: (successCount / isbns.length) * 100,
    avg_latency_ms: Math.round(avgLatency),
    errors: errors.length > 0 ? errors : undefined,
  };
}