import type { BrowserDatastoreAdapter, BrowserStoreBenchmarkResults, BrowserBenchmarkResult, BrowserTestData } from '../harness/browser-types.js';

export async function runBrowserBenchmarks(
  adapter: BrowserDatastoreAdapter,
  testData: BrowserTestData,
  onProgress?: (phase: string, durationMs?: number, failed?: boolean, error?: string) => void
): Promise<BrowserStoreBenchmarkResults> {
  const results: BrowserStoreBenchmarkResults = {
    storeName: adapter.name,
    userAgent: navigator.userAgent,
    init: { name: 'init', durationMs: 0 },
    writes: {
      allUrls: { name: 'addUrls', durationMs: 0 },
      allImages: { name: 'addImages', durationMs: 0 },
      allDocuments: { name: 'addDocuments', durationMs: 0 },
      allMetadata: { name: 'addMetadata', durationMs: 0 }
    },
    reads: {
      recentUrls: { name: 'getRecentUrls', durationMs: 0 },
      randomImages: { name: 'getRandomImages', durationMs: 0 },
      randomDocuments: { name: 'getRandomDocuments', durationMs: 0 }
    },
    storage: {
      totalBytes: 0
    }
  };

  try {
    // Init
    onProgress?.('Initializing datastore');
    const initStart = performance.now();
    await adapter.init();
    results.init.durationMs = performance.now() - initStart;
    onProgress?.('init', results.init.durationMs);

    // Write: URLs
    onProgress?.('Writing URLs');
    const urlsStart = performance.now();
    await adapter.addUrls(testData.urls);
    results.writes.allUrls.durationMs = performance.now() - urlsStart;
    results.writes.allUrls.itemCount = testData.urls.length;
    onProgress?.('addUrls', results.writes.allUrls.durationMs);

    // Write: Images
    onProgress?.('Writing images');
    const imagesStart = performance.now();
    let imageBytes = 0;
    for (const img of testData.images) {
      await adapter.addImage(img.id, img.data);
      imageBytes += img.data.byteLength;
    }
    results.writes.allImages.durationMs = performance.now() - imagesStart;
    results.writes.allImages.itemCount = testData.images.length;
    results.writes.allImages.bytesProcessed = imageBytes;
    onProgress?.('addImages', results.writes.allImages.durationMs);

    // Write: Documents
    onProgress?.('Writing documents');
    const docsStart = performance.now();
    let docBytes = 0;
    for (const doc of testData.documents) {
      await adapter.addDocument(doc.id, doc.content);
      docBytes += new TextEncoder().encode(doc.content).byteLength;
    }
    results.writes.allDocuments.durationMs = performance.now() - docsStart;
    results.writes.allDocuments.itemCount = testData.documents.length;
    results.writes.allDocuments.bytesProcessed = docBytes;
    onProgress?.('addDocuments', results.writes.allDocuments.durationMs);

    // Write: Metadata
    onProgress?.('Writing metadata');
    const metaStart = performance.now();
    await adapter.addMetadata(testData.metadata);
    results.writes.allMetadata.durationMs = performance.now() - metaStart;
    results.writes.allMetadata.itemCount = testData.metadata.length;
    onProgress?.('addMetadata', results.writes.allMetadata.durationMs);

    // Read: Recent URLs
    onProgress?.('Reading recent URLs');
    const recentUrlsStart = performance.now();
    await adapter.getRecentUrls(100);
    results.reads.recentUrls.durationMs = performance.now() - recentUrlsStart;
    results.reads.recentUrls.itemCount = 100;
    onProgress?.('getRecentUrls', results.reads.recentUrls.durationMs);

    // Read: Random images
    onProgress?.('Reading random images');
    const imageIds = testData.images.slice(0, 10).map(img => img.id);
    const randomImagesStart = performance.now();
    const imgs = await adapter.getImages(imageIds);
    results.reads.randomImages.durationMs = performance.now() - randomImagesStart;
    results.reads.randomImages.itemCount = imgs.size;
    let imgBytes = 0;
    for (const data of imgs.values()) {
      imgBytes += data.byteLength;
    }
    results.reads.randomImages.bytesProcessed = imgBytes;
    onProgress?.('getImages', results.reads.randomImages.durationMs);

    // Read: Random documents
    onProgress?.('Reading random documents');
    const docIds = testData.documents.slice(0, Math.min(1000, testData.documents.length)).map(doc => doc.id);
    const randomDocsStart = performance.now();
    const docs = await adapter.getDocuments(docIds);
    results.reads.randomDocuments.durationMs = performance.now() - randomDocsStart;
    results.reads.randomDocuments.itemCount = docs.size;
    let docSize = 0;
    for (const content of docs.values()) {
      docSize += new TextEncoder().encode(content).byteLength;
    }
    results.reads.randomDocuments.bytesProcessed = docSize;
    onProgress?.('getDocuments', results.reads.randomDocuments.durationMs);

    // Storage usage
    onProgress?.('Measuring storage');
    results.storage.totalBytes = await adapter.getStorageUsage();

    // Cleanup
    await adapter.cleanup();

  } catch (error) {
    console.error('Benchmark error:', error);
    const err = error as Error;
    return {
      ...results,
      init: { ...results.init, failed: true, error: err.message }
    };
  }

  return results;
}