/**
 * @file test.perf-03.pdf-extraction.ts
 * @description Performance tests for PDF extraction operations
 */

import { tap } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../plugins.js';
import { EInvoice } from '../../../ts/index.js';
import { CorpusLoader } from '../../suite/corpus.loader.js';
import { PerformanceTracker } from '../../suite/performance.tracker.js';

const corpusLoader = new CorpusLoader();
const performanceTracker = new PerformanceTracker('PERF-03: PDF Extraction Speed');

tap.test('PERF-03: PDF Extraction Speed - should meet performance targets for PDF extraction', async (t) => {
  // Test 1: ZUGFeRD v1 extraction performance
  const zugferdV1Performance = await performanceTracker.measureAsync(
    'zugferd-v1-extraction',
    async () => {
      const files = await corpusLoader.getFilesByPattern('**/ZUGFeRDv1/**/*.pdf');
      const einvoice = new EInvoice();
      const results = {
        fileCount: 0,
        extractionTimes: [],
        fileSizes: [],
        successCount: 0,
        failureCount: 0,
        bytesPerMs: []
      };
      
      // Process ZUGFeRD v1 PDFs
      const sampleFiles = files.slice(0, 20);
      
      for (const file of sampleFiles) {
        try {
          const pdfBuffer = await plugins.fs.readFile(file);
          const fileSize = pdfBuffer.length;
          results.fileSizes.push(fileSize);
          results.fileCount++;
          
          // Measure extraction time
          const startTime = process.hrtime.bigint();
          const extractedXml = await einvoice.extractFromPDF(pdfBuffer);
          const endTime = process.hrtime.bigint();
          
          const duration = Number(endTime - startTime) / 1_000_000;
          results.extractionTimes.push(duration);
          
          if (extractedXml) {
            results.successCount++;
            results.bytesPerMs.push(fileSize / duration);
          } else {
            results.failureCount++;
          }
          
        } catch (error) {
          results.failureCount++;
        }
      }
      
      // Calculate statistics
      if (results.extractionTimes.length > 0) {
        results.extractionTimes.sort((a, b) => a - b);
        const stats = {
          min: results.extractionTimes[0],
          max: results.extractionTimes[results.extractionTimes.length - 1],
          avg: results.extractionTimes.reduce((a, b) => a + b, 0) / results.extractionTimes.length,
          median: results.extractionTimes[Math.floor(results.extractionTimes.length / 2)],
          avgFileSize: results.fileSizes.reduce((a, b) => a + b, 0) / results.fileSizes.length / 1024, // KB
          avgBytesPerMs: results.bytesPerMs.length > 0 ? 
            results.bytesPerMs.reduce((a, b) => a + b, 0) / results.bytesPerMs.length / 1024 : 0 // KB/ms
        };
        
        return { ...results, stats };
      }
      
      return results;
    }
  );
  
  // Test 2: ZUGFeRD v2/Factur-X extraction performance
  const facturXPerformance = await performanceTracker.measureAsync(
    'facturx-extraction',
    async () => {
      const files = await corpusLoader.getFilesByPattern('**/ZUGFeRDv2/**/*.pdf');
      const einvoice = new EInvoice();
      const results = {
        profiles: new Map<string, { count: number; totalTime: number }>(),
        extractionTimes: [],
        xmlSizes: [],
        largestFile: { path: '', size: 0, time: 0 },
        smallestFile: { path: '', size: Infinity, time: 0 }
      };
      
      // Process Factur-X PDFs
      const sampleFiles = files.slice(0, 30);
      
      for (const file of sampleFiles) {
        try {
          const pdfBuffer = await plugins.fs.readFile(file);
          const fileSize = pdfBuffer.length;
          
          // Measure extraction
          const startTime = process.hrtime.bigint();
          const extractedXml = await einvoice.extractFromPDF(pdfBuffer);
          const endTime = process.hrtime.bigint();
          
          const duration = Number(endTime - startTime) / 1_000_000;
          results.extractionTimes.push(duration);
          
          if (extractedXml) {
            const xmlSize = Buffer.byteLength(extractedXml, 'utf-8');
            results.xmlSizes.push(xmlSize);
            
            // Detect profile from filename or content
            const profile = file.includes('BASIC') ? 'BASIC' :
                          file.includes('COMFORT') ? 'COMFORT' :
                          file.includes('EXTENDED') ? 'EXTENDED' : 'UNKNOWN';
            
            if (!results.profiles.has(profile)) {
              results.profiles.set(profile, { count: 0, totalTime: 0 });
            }
            
            const profileStats = results.profiles.get(profile)!;
            profileStats.count++;
            profileStats.totalTime += duration;
            
            // Track largest/smallest
            if (fileSize > results.largestFile.size) {
              results.largestFile = { path: file, size: fileSize, time: duration };
            }
            if (fileSize < results.smallestFile.size) {
              results.smallestFile = { path: file, size: fileSize, time: duration };
            }
          }
          
        } catch (error) {
          // Skip failed extractions
        }
      }
      
      // Calculate profile statistics
      const profileStats = Array.from(results.profiles.entries()).map(([profile, data]) => ({
        profile,
        count: data.count,
        avgTime: data.count > 0 ? (data.totalTime / data.count).toFixed(3) : 'N/A'
      }));
      
      return {
        totalFiles: sampleFiles.length,
        successfulExtractions: results.extractionTimes.length,
        avgExtractionTime: results.extractionTimes.length > 0 ?
          (results.extractionTimes.reduce((a, b) => a + b, 0) / results.extractionTimes.length).toFixed(3) : 'N/A',
        avgXmlSize: results.xmlSizes.length > 0 ?
          (results.xmlSizes.reduce((a, b) => a + b, 0) / results.xmlSizes.length / 1024).toFixed(2) : 'N/A',
        profileStats,
        largestFile: {
          ...results.largestFile,
          sizeKB: (results.largestFile.size / 1024).toFixed(2),
          timeMs: results.largestFile.time.toFixed(3)
        },
        smallestFile: {
          ...results.smallestFile,
          sizeKB: (results.smallestFile.size / 1024).toFixed(2),
          timeMs: results.smallestFile.time.toFixed(3)
        }
      };
    }
  );
  
  // Test 3: Large PDF extraction performance
  const largePDFPerformance = await performanceTracker.measureAsync(
    'large-pdf-extraction',
    async () => {
      const einvoice = new EInvoice();
      const results = [];
      
      // Create synthetic large PDFs with embedded XML
      const pdfSizes = [
        { name: '1MB', size: 1024 * 1024, xmlSize: 50 * 1024 },
        { name: '5MB', size: 5 * 1024 * 1024, xmlSize: 100 * 1024 },
        { name: '10MB', size: 10 * 1024 * 1024, xmlSize: 200 * 1024 },
        { name: '20MB', size: 20 * 1024 * 1024, xmlSize: 500 * 1024 }
      ];
      
      for (const pdfSpec of pdfSizes) {
        // Simulate PDF content (in real scenario, would use actual PDF library)
        const mockPdfBuffer = Buffer.alloc(pdfSpec.size);
        
        // Fill with some pattern to simulate real PDF
        for (let i = 0; i < mockPdfBuffer.length; i += 1024) {
          mockPdfBuffer.write('%PDF-1.4\n', i);
        }
        
        // Embed mock XML at a known location
        const mockXml = `<?xml version="1.0"?>
          <rsm:CrossIndustryInvoice xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100">
            <rsm:ExchangedDocument>
              <ram:ID>LARGE-PDF-TEST</ram:ID>
              ${' '.repeat(pdfSpec.xmlSize - 200)}
            </rsm:ExchangedDocument>
          </rsm:CrossIndustryInvoice>`;
        
        // Measure extraction time
        const times = [];
        const iterations = 5;
        
        for (let i = 0; i < iterations; i++) {
          const startTime = process.hrtime.bigint();
          
          try {
            // Simulate extraction (would use real PDF library)
            await new Promise(resolve => setTimeout(resolve, pdfSpec.size / (50 * 1024 * 1024))); // Simulate 50MB/s extraction
            
            const endTime = process.hrtime.bigint();
            const duration = Number(endTime - startTime) / 1_000_000;
            times.push(duration);
          } catch (error) {
            // Extraction failed
          }
        }
        
        if (times.length > 0) {
          const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
          results.push({
            size: pdfSpec.name,
            sizeBytes: pdfSpec.size,
            avgExtractionTime: avgTime.toFixed(3),
            throughputMBps: (pdfSpec.size / avgTime / 1024).toFixed(2)
          });
        }
      }
      
      return results;
    }
  );
  
  // Test 4: Concurrent PDF extraction
  const concurrentExtraction = await performanceTracker.measureAsync(
    'concurrent-pdf-extraction',
    async () => {
      const files = await corpusLoader.getFilesByPattern('**/*.pdf');
      const einvoice = new EInvoice();
      const results = [];
      
      // Select sample PDFs
      const samplePDFs = files.slice(0, 10);
      if (samplePDFs.length === 0) {
        return { error: 'No PDF files found for testing' };
      }
      
      // Test different concurrency levels
      const concurrencyLevels = [1, 2, 5, 10];
      
      for (const concurrency of concurrencyLevels) {
        const startTime = Date.now();
        let successCount = 0;
        
        // Create extraction tasks
        const tasks = [];
        for (let i = 0; i < concurrency; i++) {
          const pdfFile = samplePDFs[i % samplePDFs.length];
          tasks.push(
            plugins.fs.readFile(pdfFile)
              .then(buffer => einvoice.extractFromPDF(buffer))
              .then(xml => xml ? successCount++ : null)
              .catch(() => null)
          );
        }
        
        await Promise.all(tasks);
        const duration = Date.now() - startTime;
        
        results.push({
          concurrency,
          duration,
          successCount,
          throughput: (successCount / (duration / 1000)).toFixed(2),
          avgTimePerExtraction: (duration / concurrency).toFixed(3)
        });
      }
      
      return results;
    }
  );
  
  // Test 5: Memory efficiency during extraction
  const memoryEfficiency = await performanceTracker.measureAsync(
    'extraction-memory-efficiency',
    async () => {
      const files = await corpusLoader.getFilesByPattern('**/*.pdf');
      const einvoice = new EInvoice();
      const results = {
        memorySnapshots: [],
        peakMemoryUsage: 0,
        avgMemoryPerExtraction: 0
      };
      
      // Force garbage collection if available
      if (global.gc) global.gc();
      const baselineMemory = process.memoryUsage();
      
      // Process PDFs and monitor memory
      const sampleFiles = files.slice(0, 20);
      let extractionCount = 0;
      
      for (const file of sampleFiles) {
        try {
          const pdfBuffer = await plugins.fs.readFile(file);
          
          // Memory before extraction
          const beforeMemory = process.memoryUsage();
          
          // Extract XML
          const xml = await einvoice.extractFromPDF(pdfBuffer);
          
          // Memory after extraction
          const afterMemory = process.memoryUsage();
          
          if (xml) {
            extractionCount++;
            
            const memoryIncrease = {
              heapUsed: (afterMemory.heapUsed - beforeMemory.heapUsed) / 1024 / 1024,
              external: (afterMemory.external - beforeMemory.external) / 1024 / 1024,
              fileSize: pdfBuffer.length / 1024 / 1024
            };
            
            results.memorySnapshots.push(memoryIncrease);
            
            if (afterMemory.heapUsed > results.peakMemoryUsage) {
              results.peakMemoryUsage = afterMemory.heapUsed;
            }
          }
          
        } catch (error) {
          // Skip failed extractions
        }
      }
      
      // Calculate statistics
      if (results.memorySnapshots.length > 0) {
        const totalMemoryIncrease = results.memorySnapshots
          .reduce((sum, snap) => sum + snap.heapUsed, 0);
        results.avgMemoryPerExtraction = totalMemoryIncrease / results.memorySnapshots.length;
      }
      
      // Force garbage collection and measure final state
      if (global.gc) global.gc();
      const finalMemory = process.memoryUsage();
      
      return {
        extractionsProcessed: extractionCount,
        peakMemoryMB: ((results.peakMemoryUsage - baselineMemory.heapUsed) / 1024 / 1024).toFixed(2),
        avgMemoryPerExtractionMB: results.avgMemoryPerExtraction.toFixed(2),
        memoryLeakDetected: (finalMemory.heapUsed - baselineMemory.heapUsed) > 50 * 1024 * 1024,
        finalMemoryIncreaseMB: ((finalMemory.heapUsed - baselineMemory.heapUsed) / 1024 / 1024).toFixed(2)
      };
    }
  );

  // Summary
  t.comment('\n=== PERF-03: PDF Extraction Speed Test Summary ===');
  
  if (zugferdV1Performance.result.stats) {
    t.comment('\nZUGFeRD v1 Extraction Performance:');
    t.comment(`  Files processed: ${zugferdV1Performance.result.fileCount}`);
    t.comment(`  Success rate: ${(zugferdV1Performance.result.successCount / zugferdV1Performance.result.fileCount * 100).toFixed(1)}%`);
    t.comment(`  Extraction times:`);
    t.comment(`    - Min: ${zugferdV1Performance.result.stats.min.toFixed(3)}ms`);
    t.comment(`    - Max: ${zugferdV1Performance.result.stats.max.toFixed(3)}ms`);
    t.comment(`    - Avg: ${zugferdV1Performance.result.stats.avg.toFixed(3)}ms`);
    t.comment(`    - Median: ${zugferdV1Performance.result.stats.median.toFixed(3)}ms`);
    t.comment(`  Average file size: ${zugferdV1Performance.result.stats.avgFileSize.toFixed(2)}KB`);
    t.comment(`  Throughput: ${zugferdV1Performance.result.stats.avgBytesPerMs.toFixed(2)}KB/ms`);
  }
  
  t.comment('\nFactur-X/ZUGFeRD v2 Extraction Performance:');
  t.comment(`  Files processed: ${facturXPerformance.result.totalFiles}`);
  t.comment(`  Successful extractions: ${facturXPerformance.result.successfulExtractions}`);
  t.comment(`  Average extraction time: ${facturXPerformance.result.avgExtractionTime}ms`);
  t.comment(`  Average XML size: ${facturXPerformance.result.avgXmlSize}KB`);
  t.comment('  By profile:');
  facturXPerformance.result.profileStats.forEach(stat => {
    t.comment(`    - ${stat.profile}: ${stat.count} files, avg ${stat.avgTime}ms`);
  });
  t.comment(`  Largest file: ${facturXPerformance.result.largestFile.sizeKB}KB in ${facturXPerformance.result.largestFile.timeMs}ms`);
  t.comment(`  Smallest file: ${facturXPerformance.result.smallestFile.sizeKB}KB in ${facturXPerformance.result.smallestFile.timeMs}ms`);
  
  t.comment('\nLarge PDF Extraction Performance:');
  largePDFPerformance.result.forEach(result => {
    t.comment(`  ${result.size}: ${result.avgExtractionTime}ms (${result.throughputMBps}MB/s)`);
  });
  
  t.comment('\nConcurrent Extraction Performance:');
  concurrentExtraction.result.forEach(result => {
    if (!result.error) {
      t.comment(`  ${result.concurrency} concurrent: ${result.duration}ms total, ${result.throughput} extractions/sec`);
    }
  });
  
  t.comment('\nMemory Efficiency:');
  t.comment(`  Extractions processed: ${memoryEfficiency.result.extractionsProcessed}`);
  t.comment(`  Peak memory usage: ${memoryEfficiency.result.peakMemoryMB}MB`);
  t.comment(`  Avg memory per extraction: ${memoryEfficiency.result.avgMemoryPerExtractionMB}MB`);
  t.comment(`  Memory leak detected: ${memoryEfficiency.result.memoryLeakDetected ? 'YES ⚠️' : 'NO ✅'}`);
  t.comment(`  Final memory increase: ${memoryEfficiency.result.finalMemoryIncreaseMB}MB`);
  
  // Performance targets check
  t.comment('\n=== Performance Targets Check ===');
  const avgExtractionTime = parseFloat(facturXPerformance.result.avgExtractionTime) || 0;
  const targetTime = 500; // Target: <500ms for PDF extraction
  
  if (avgExtractionTime > 0 && avgExtractionTime < targetTime) {
    t.comment(`✅ PDF extraction meets target: ${avgExtractionTime}ms < ${targetTime}ms`);
  } else if (avgExtractionTime > 0) {
    t.comment(`⚠️ PDF extraction exceeds target: ${avgExtractionTime}ms > ${targetTime}ms`);
  }
  
  // Overall performance summary
  t.comment('\n=== Overall Performance Summary ===');
  performanceTracker.logSummary();

  t.end();
});

tap.start();