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

const performanceTracker = new PerformanceTracker('EDGE-09: Corrupted ZIP Containers');

tap.test('EDGE-09: Corrupted ZIP Containers - should handle corrupted ZIP/container files', async (t) => {
  const einvoice = new EInvoice();

  // Test 1: Invalid ZIP headers
  const invalidZipHeaders = await performanceTracker.measureAsync(
    'invalid-zip-headers',
    async () => {
      const corruptHeaders = [
        {
          name: 'wrong-magic-bytes',
          data: Buffer.from('NOTAZIP\x00\x00\x00\x00'),
          description: 'Invalid ZIP signature'
        },
        {
          name: 'partial-header',
          data: Buffer.from('PK\x03'),
          description: 'Incomplete ZIP header'
        },
        {
          name: 'corrupted-local-header',
          data: Buffer.concat([
            Buffer.from('PK\x03\x04'), // Local file header signature
            Buffer.from([0xFF, 0xFF, 0xFF, 0xFF]), // Corrupted version/flags
            Buffer.alloc(20, 0) // Rest of header
          ]),
          description: 'Corrupted local file header'
        },
        {
          name: 'missing-central-directory',
          data: Buffer.concat([
            Buffer.from('PK\x03\x04'), // Local file header
            Buffer.alloc(26, 0), // Header data
            Buffer.from('PK\x07\x08'), // Data descriptor
            Buffer.alloc(12, 0), // Descriptor data
            // Missing central directory
          ]),
          description: 'Missing central directory'
        }
      ];
      
      const results = [];
      
      for (const corrupt of corruptHeaders) {
        try {
          const extracted = await einvoice.extractFromContainer(corrupt.data);
          
          results.push({
            type: corrupt.name,
            recovered: !!extracted,
            filesExtracted: extracted?.files?.length || 0,
            error: null
          });
        } catch (error) {
          results.push({
            type: corrupt.name,
            recovered: false,
            error: error.message,
            isZipError: error.message.toLowerCase().includes('zip') || 
                       error.message.toLowerCase().includes('archive')
          });
        }
      }
      
      return results;
    }
  );

  invalidZipHeaders.forEach(result => {
    t.ok(!result.recovered || result.isZipError, 
      `Invalid header ${result.type} should fail or be detected`);
  });

  // Test 2: Truncated ZIP files
  const truncatedZipFiles = await performanceTracker.measureAsync(
    'truncated-zip-files',
    async () => {
      // Create a valid ZIP structure and truncate at different points
      const validZip = createValidZipStructure();
      
      const truncationPoints = [
        { point: 10, name: 'header-truncated' },
        { point: 50, name: 'file-data-truncated' },
        { point: validZip.length - 50, name: 'directory-truncated' },
        { point: validZip.length - 10, name: 'eocd-truncated' },
        { point: validZip.length - 1, name: 'last-byte-missing' }
      ];
      
      const results = [];
      
      for (const truncation of truncationPoints) {
        const truncated = validZip.slice(0, truncation.point);
        
        try {
          const recovery = await einvoice.recoverFromCorruptedZip(truncated, {
            attemptPartialRecovery: true
          });
          
          results.push({
            truncation: truncation.name,
            size: truncated.length,
            recovered: recovery?.success || false,
            filesRecovered: recovery?.recoveredFiles || 0,
            dataRecovered: recovery?.recoveredBytes || 0
          });
        } catch (error) {
          results.push({
            truncation: truncation.name,
            size: truncated.length,
            recovered: false,
            error: error.message
          });
        }
      }
      
      return results;
    }
  );

  truncatedZipFiles.forEach(result => {
    t.ok(result.recovered === false || result.filesRecovered < 1, 
      `Truncated ZIP at ${result.truncation} should have limited recovery`);
  });

  // Test 3: CRC errors
  const crcErrors = await performanceTracker.measureAsync(
    'crc-checksum-errors',
    async () => {
      const scenarios = [
        {
          name: 'single-bit-flip',
          corruption: (data: Buffer) => {
            const copy = Buffer.from(data);
            // Flip a bit in the compressed data
            if (copy.length > 100) {
              copy[100] ^= 0x01;
            }
            return copy;
          }
        },
        {
          name: 'data-corruption',
          corruption: (data: Buffer) => {
            const copy = Buffer.from(data);
            // Corrupt a chunk of data
            for (let i = 50; i < Math.min(100, copy.length); i++) {
              copy[i] = 0xFF;
            }
            return copy;
          }
        },
        {
          name: 'wrong-crc-stored',
          corruption: (data: Buffer) => {
            const copy = Buffer.from(data);
            // Find and corrupt CRC values
            const crcOffset = findCRCOffset(copy);
            if (crcOffset > 0) {
              copy.writeUInt32LE(0xDEADBEEF, crcOffset);
            }
            return copy;
          }
        }
      ];
      
      const results = [];
      
      for (const scenario of scenarios) {
        const validZip = createZipWithInvoice();
        const corrupted = scenario.corruption(validZip);
        
        try {
          const extraction = await einvoice.extractFromContainer(corrupted, {
            ignoreCRCErrors: false
          });
          
          results.push({
            scenario: scenario.name,
            extracted: true,
            crcValidated: extraction?.crcValid || false,
            dataIntegrity: extraction?.integrityCheck || 'unknown'
          });
        } catch (error) {
          results.push({
            scenario: scenario.name,
            extracted: false,
            error: error.message,
            isCRCError: error.message.toLowerCase().includes('crc') || 
                       error.message.toLowerCase().includes('checksum')
          });
        }
      }
      
      return results;
    }
  );

  crcErrors.forEach(result => {
    t.ok(!result.extracted || !result.crcValidated || result.isCRCError, 
      `CRC error ${result.scenario} should be detected`);
  });

  // Test 4: Compression method issues
  const compressionMethodIssues = await performanceTracker.measureAsync(
    'compression-method-issues',
    async () => {
      const compressionTests = [
        {
          name: 'unsupported-method',
          method: 99, // Invalid compression method
          description: 'Unknown compression algorithm'
        },
        {
          name: 'store-but-compressed',
          method: 0, // Store (no compression)
          compressed: true,
          description: 'Stored method but data is compressed'
        },
        {
          name: 'deflate-corrupted',
          method: 8, // Deflate
          corrupted: true,
          description: 'Deflate stream corrupted'
        },
        {
          name: 'bzip2-in-zip',
          method: 12, // Bzip2 (not standard in ZIP)
          description: 'Non-standard compression method'
        }
      ];
      
      const results = [];
      
      for (const test of compressionTests) {
        const zipData = createZipWithCompressionMethod(test.method, test);
        
        try {
          const extracted = await einvoice.extractFromContainer(zipData);
          
          results.push({
            test: test.name,
            method: test.method,
            extracted: true,
            filesFound: extracted?.files?.length || 0,
            decompressed: extracted?.decompressed || false
          });
        } catch (error) {
          results.push({
            test: test.name,
            method: test.method,
            extracted: false,
            error: error.message,
            isCompressionError: error.message.includes('compress') || 
                               error.message.includes('method')
          });
        }
      }
      
      return results;
    }
  );

  compressionMethodIssues.forEach(result => {
    if (result.method === 0 || result.method === 8) {
      t.ok(result.extracted || result.isCompressionError, 
        `Standard compression ${result.test} should be handled`);
    } else {
      t.notOk(result.extracted, 
        `Non-standard compression ${result.test} should fail`);
    }
  });

  // Test 5: Nested/recursive ZIP bombs
  const nestedZipBombs = await performanceTracker.measureAsync(
    'nested-zip-bombs',
    async () => {
      const bombTypes = [
        {
          name: 'deep-nesting',
          depth: 10,
          description: 'ZIP within ZIP, 10 levels deep'
        },
        {
          name: 'exponential-expansion',
          copies: 10,
          description: 'Each level contains 10 copies'
        },
        {
          name: 'circular-reference',
          circular: true,
          description: 'ZIP contains itself'
        },
        {
          name: 'compression-ratio-bomb',
          ratio: 1000,
          description: 'Extreme compression ratio'
        }
      ];
      
      const results = [];
      
      for (const bomb of bombTypes) {
        const bombZip = createZipBomb(bomb);
        
        const startTime = Date.now();
        const startMemory = process.memoryUsage();
        
        try {
          const extraction = await einvoice.extractFromContainer(bombZip, {
            maxDepth: 5,
            maxExpandedSize: 100 * 1024 * 1024, // 100MB limit
            maxFiles: 1000
          });
          
          const endTime = Date.now();
          const endMemory = process.memoryUsage();
          
          results.push({
            type: bomb.name,
            handled: true,
            timeTaken: endTime - startTime,
            memoryUsed: endMemory.heapUsed - startMemory.heapUsed,
            depthReached: extraction?.maxDepth || 0,
            stopped: extraction?.limitReached || false
          });
        } catch (error) {
          results.push({
            type: bomb.name,
            handled: true,
            prevented: true,
            error: error.message,
            isBombDetected: error.message.includes('bomb') || 
                           error.message.includes('depth') ||
                           error.message.includes('limit')
          });
        }
      }
      
      return results;
    }
  );

  nestedZipBombs.forEach(result => {
    t.ok(result.prevented || result.stopped, 
      `ZIP bomb ${result.type} should be prevented or limited`);
  });

  // Test 6: Character encoding in filenames
  const filenameEncodingIssues = await performanceTracker.measureAsync(
    'filename-encoding-issues',
    async () => {
      const encodingTests = [
        {
          name: 'utf8-bom-filename',
          filename: '\uFEFFファイル.xml',
          encoding: 'utf8'
        },
        {
          name: 'cp437-extended',
          filename: 'Ñoño_español.xml',
          encoding: 'cp437'
        },
        {
          name: 'mixed-encoding',
          filename: 'Test_文件_файл.xml',
          encoding: 'mixed'
        },
        {
          name: 'null-bytes',
          filename: 'file\x00.xml',
          encoding: 'binary'
        },
        {
          name: 'path-traversal',
          filename: '../../../etc/passwd',
          encoding: 'ascii'
        }
      ];
      
      const results = [];
      
      for (const test of encodingTests) {
        const zipData = createZipWithFilename(test.filename, test.encoding);
        
        try {
          const extracted = await einvoice.extractFromContainer(zipData);
          const files = extracted?.files || [];
          
          results.push({
            test: test.name,
            extracted: true,
            fileCount: files.length,
            filenamePreserved: files.some(f => f.name === test.filename),
            filenameNormalized: files[0]?.name || null,
            securityCheck: !files.some(f => f.name.includes('..'))
          });
        } catch (error) {
          results.push({
            test: test.name,
            extracted: false,
            error: error.message
          });
        }
      }
      
      return results;
    }
  );

  filenameEncodingIssues.forEach(result => {
    t.ok(result.securityCheck, 
      `Filename ${result.test} should pass security checks`);
  });

  // Test 7: Factur-X/ZUGFeRD specific corruptions
  const facturXCorruptions = await performanceTracker.measureAsync(
    'facturx-zugferd-corruptions',
    async () => {
      const corruptionTypes = [
        {
          name: 'missing-metadata',
          description: 'PDF/A-3 without required metadata'
        },
        {
          name: 'wrong-attachment-relationship',
          description: 'XML not marked as Alternative'
        },
        {
          name: 'multiple-xml-versions',
          description: 'Both Factur-X and ZUGFeRD XML present'
        },
        {
          name: 'corrupted-xml-stream',
          description: 'XML attachment stream corrupted'
        }
      ];
      
      const results = [];
      
      for (const corruption of corruptionTypes) {
        const corruptedPDF = createCorruptedFacturX(corruption.name);
        
        try {
          const extraction = await einvoice.extractFromPDF(corruptedPDF);
          
          results.push({
            corruption: corruption.name,
            extracted: !!extraction,
            hasValidXML: extraction?.xml && isValidXML(extraction.xml),
            hasMetadata: !!extraction?.metadata,
            conformance: extraction?.conformanceLevel || 'unknown'
          });
        } catch (error) {
          results.push({
            corruption: corruption.name,
            extracted: false,
            error: error.message
          });
        }
      }
      
      return results;
    }
  );

  facturXCorruptions.forEach(result => {
    t.ok(result.extracted || result.error, 
      `Factur-X corruption ${result.corruption} was handled`);
  });

  // Test 8: Recovery strategies
  const recoveryStrategies = await performanceTracker.measureAsync(
    'zip-recovery-strategies',
    async () => {
      const strategies = [
        {
          name: 'scan-for-headers',
          description: 'Scan for local file headers'
        },
        {
          name: 'reconstruct-central-dir',
          description: 'Rebuild central directory'
        },
        {
          name: 'raw-deflate-extraction',
          description: 'Extract raw deflate streams'
        },
        {
          name: 'pattern-matching',
          description: 'Find XML by pattern matching'
        }
      ];
      
      const corruptedZip = createSeverelyCorruptedZip();
      const results = [];
      
      for (const strategy of strategies) {
        try {
          const recovered = await einvoice.attemptZipRecovery(corruptedZip, {
            strategy: strategy.name
          });
          
          results.push({
            strategy: strategy.name,
            success: recovered?.success || false,
            filesRecovered: recovered?.files?.length || 0,
            xmlFound: recovered?.files?.some(f => f.name.endsWith('.xml')) || false,
            confidence: recovered?.confidence || 0
          });
        } catch (error) {
          results.push({
            strategy: strategy.name,
            success: false,
            error: error.message
          });
        }
      }
      
      return results;
    }
  );

  recoveryStrategies.forEach(result => {
    t.ok(result.success || result.error, 
      `Recovery strategy ${result.strategy} was attempted`);
  });

  // Test 9: Multi-part archive issues
  const multiPartArchiveIssues = await performanceTracker.measureAsync(
    'multi-part-archive-issues',
    async () => {
      const multiPartTests = [
        {
          name: 'missing-parts',
          parts: ['part1.zip', null, 'part3.zip'],
          description: 'Missing middle part'
        },
        {
          name: 'wrong-order',
          parts: ['part3.zip', 'part1.zip', 'part2.zip'],
          description: 'Parts in wrong order'
        },
        {
          name: 'mixed-formats',
          parts: ['part1.zip', 'part2.rar', 'part3.zip'],
          description: 'Different archive formats'
        },
        {
          name: 'size-mismatch',
          parts: createMismatchedParts(),
          description: 'Part sizes do not match'
        }
      ];
      
      const results = [];
      
      for (const test of multiPartTests) {
        try {
          const assembled = await einvoice.assembleMultiPartArchive(test.parts);
          const extracted = await einvoice.extractFromContainer(assembled);
          
          results.push({
            test: test.name,
            assembled: true,
            extracted: !!extracted,
            complete: extracted?.isComplete || false
          });
        } catch (error) {
          results.push({
            test: test.name,
            assembled: false,
            error: error.message
          });
        }
      }
      
      return results;
    }
  );

  multiPartArchiveIssues.forEach(result => {
    t.ok(!result.assembled || !result.complete, 
      `Multi-part issue ${result.test} should cause problems`);
  });

  // Test 10: Performance with corrupted files
  const corruptedPerformance = await performanceTracker.measureAsync(
    'corrupted-file-performance',
    async () => {
      const sizes = [
        { size: 1024, name: '1KB' },
        { size: 1024 * 1024, name: '1MB' },
        { size: 10 * 1024 * 1024, name: '10MB' }
      ];
      
      const results = [];
      
      for (const sizeTest of sizes) {
        // Create corrupted file of specific size
        const corrupted = createCorruptedZipOfSize(sizeTest.size);
        
        const startTime = Date.now();
        const timeout = 10000; // 10 second timeout
        
        try {
          const extractPromise = einvoice.extractFromContainer(corrupted);
          const timeoutPromise = new Promise((_, reject) => 
            setTimeout(() => reject(new Error('Timeout')), timeout)
          );
          
          await Promise.race([extractPromise, timeoutPromise]);
          
          const timeTaken = Date.now() - startTime;
          
          results.push({
            size: sizeTest.name,
            completed: true,
            timeTaken,
            timedOut: false
          });
        } catch (error) {
          const timeTaken = Date.now() - startTime;
          
          results.push({
            size: sizeTest.name,
            completed: false,
            timeTaken,
            timedOut: error.message === 'Timeout',
            error: error.message
          });
        }
      }
      
      return results;
    }
  );

  corruptedPerformance.forEach(result => {
    t.ok(!result.timedOut, 
      `Corrupted file ${result.size} should not cause timeout`);
  });

  // Print performance summary
  performanceTracker.printSummary();
});

// Helper functions

function createValidZipStructure(): Buffer {
  // Simplified ZIP structure
  const parts = [];
  
  // Local file header
  parts.push(Buffer.from('PK\x03\x04')); // Signature
  parts.push(Buffer.alloc(26, 0)); // Header fields
  parts.push(Buffer.from('test.xml')); // Filename
  parts.push(Buffer.from('<Invoice><ID>123</ID></Invoice>')); // File data
  
  // Central directory
  parts.push(Buffer.from('PK\x01\x02')); // Signature
  parts.push(Buffer.alloc(42, 0)); // Header fields
  parts.push(Buffer.from('test.xml')); // Filename
  
  // End of central directory
  parts.push(Buffer.from('PK\x05\x06')); // Signature
  parts.push(Buffer.alloc(18, 0)); // EOCD fields
  
  return Buffer.concat(parts);
}

function createZipWithInvoice(): Buffer {
  // Create a simple ZIP with invoice XML
  return createValidZipStructure();
}

function findCRCOffset(data: Buffer): number {
  // Find CRC32 field in ZIP structure
  const sig = Buffer.from('PK\x03\x04');
  const idx = data.indexOf(sig);
  if (idx >= 0) {
    return idx + 14; // CRC32 offset in local file header
  }
  return -1;
}

function createZipWithCompressionMethod(method: number, options: any): Buffer {
  const parts = [];
  
  // Local file header with specific compression method
  parts.push(Buffer.from('PK\x03\x04'));
  const header = Buffer.alloc(26, 0);
  header.writeUInt16LE(method, 8); // Compression method
  parts.push(header);
  parts.push(Buffer.from('invoice.xml'));
  
  // Add compressed or uncompressed data based on method
  if (options.corrupted) {
    parts.push(Buffer.from([0xFF, 0xFE, 0xFD])); // Invalid deflate stream
  } else if (method === 0) {
    parts.push(Buffer.from('<Invoice/>'));
  } else {
    parts.push(Buffer.from([0x78, 0x9C])); // Deflate header
    parts.push(Buffer.alloc(10, 0)); // Compressed data
  }
  
  return Buffer.concat(parts);
}

function createZipBomb(config: any): Buffer {
  // Create various types of ZIP bombs
  if (config.circular) {
    // Create a ZIP that references itself
    return Buffer.from('PK...[circular reference]...');
  } else if (config.depth) {
    // Create nested ZIPs
    let zip = Buffer.from('<Invoice/>');
    for (let i = 0; i < config.depth; i++) {
      zip = wrapInZip(zip, `level${i}.zip`);
    }
    return zip;
  }
  return Buffer.from('PK');
}

function wrapInZip(content: Buffer, filename: string): Buffer {
  // Wrap content in a ZIP file
  return Buffer.concat([
    Buffer.from('PK\x03\x04'),
    Buffer.alloc(26, 0),
    Buffer.from(filename),
    content
  ]);
}

function createZipWithFilename(filename: string, encoding: string): Buffer {
  const parts = [];
  
  parts.push(Buffer.from('PK\x03\x04'));
  const header = Buffer.alloc(26, 0);
  
  // Set filename length
  const filenameBuffer = Buffer.from(filename, encoding === 'binary' ? 'binary' : 'utf8');
  header.writeUInt16LE(filenameBuffer.length, 24);
  
  parts.push(header);
  parts.push(filenameBuffer);
  parts.push(Buffer.from('<Invoice/>'));
  
  return Buffer.concat(parts);
}

function createCorruptedFacturX(type: string): Buffer {
  // Create corrupted Factur-X/ZUGFeRD PDFs
  const mockPDF = Buffer.from('%PDF-1.4\n...');
  return mockPDF;
}

function createSeverelyCorruptedZip(): Buffer {
  // Create a severely corrupted ZIP for recovery testing
  const data = Buffer.alloc(1024);
  data.fill(0xFF);
  // Add some ZIP-like signatures at random positions
  data.write('PK\x03\x04', 100);
  data.write('<Invoice', 200);
  data.write('</Invoice>', 300);
  return data;
}

function createMismatchedParts(): Buffer[] {
  return [
    Buffer.alloc(1000, 1),
    Buffer.alloc(500, 2),
    Buffer.alloc(1500, 3)
  ];
}

function createCorruptedZipOfSize(size: number): Buffer {
  const data = Buffer.alloc(size);
  // Fill with random data
  for (let i = 0; i < size; i += 4) {
    data.writeUInt32LE(Math.random() * 0xFFFFFFFF, i);
  }
  // Add ZIP signature at start
  data.write('PK\x03\x04', 0);
  return data;
}

function isValidXML(content: string): boolean {
  try {
    // Simple XML validation check
    return content.includes('<?xml') && content.includes('>');
  } catch {
    return false;
  }
}

// Run the test
tap.start();