import { tap, expect } from '@push.rocks/tapbundle';
import { XInvoice } from '../ts/classes.xinvoice.js';
import { type ExportFormat } from '../ts/interfaces.js';
import { PDFDocument, PDFName, PDFRawStream } from 'pdf-lib';
import * as pako from 'pako';

// Focused PDF export test with type safety and embedded file verification
tap.test('XInvoice should export PDFs with the correct embedded file structure', async () => {
  // Create a sample invoice with the required fields
  const invoice = new XInvoice();
  const uniqueId = `TEST-PDF-EXPORT-${Date.now()}`;
  
  invoice.content.invoiceData.id = uniqueId;
  invoice.content.invoiceData.billedBy.name = 'Test Seller';
  invoice.content.invoiceData.billedTo.name = 'Test Buyer';
  
  // Add required address details
  invoice.content.invoiceData.billedBy.address.streetName = '123 Seller St';
  invoice.content.invoiceData.billedBy.address.city = 'Seller City';
  invoice.content.invoiceData.billedBy.address.postalCode = '12345';
  
  invoice.content.invoiceData.billedTo.address.streetName = '456 Buyer St';
  invoice.content.invoiceData.billedTo.address.city = 'Buyer City';
  invoice.content.invoiceData.billedTo.address.postalCode = '67890';
  
  // Add a test item
  invoice.content.invoiceData.items.push({
    position: 1,
    name: 'Test Product',
    unitType: 'piece',
    unitQuantity: 2,
    unitNetPrice: 99.95,
    vatPercentage: 19
  });
  
  // Create a simple PDF
  const pdfDoc = await PDFDocument.create();
  pdfDoc.addPage().drawText('PDF Export Test');
  const pdfBuffer = await pdfDoc.save();
  
  // Store original buffer size for comparison
  const originalSize = pdfBuffer.byteLength;
  console.log(`Original PDF size: ${originalSize} bytes`);
  
  // Load the PDF into the invoice
  invoice.pdf = {
    name: 'test.pdf',
    id: `test-${Date.now()}`,
    metadata: {
      textExtraction: 'PDF Export Test'
    },
    buffer: pdfBuffer
  };
  
  // Test each format
  const formats: ExportFormat[] = ['facturx', 'zugferd', 'xrechnung', 'ubl'];
  
  // Create a table to show results
  console.log('\nFormat-specific PDF file size increases:');
  console.log('----------------------------------------');
  console.log('Format    | Original | With XML | Increase');
  console.log('----------|----------|----------|------------');
  
  for (const format of formats) {
    // This tests the type safety of the parameter
    const exportedPdf = await invoice.exportPdf(format);
    const newSize = exportedPdf.buffer.byteLength;
    const increase = newSize - originalSize;
    const increasePercent = ((increase / originalSize) * 100).toFixed(1);
    
    // Report the size increase
    console.log(`${format.padEnd(10)}| ${originalSize.toString().padEnd(10)}| ${newSize.toString().padEnd(10)}| ${increase} bytes (+${increasePercent}%)`);
    
    // Verify PDF was created properly
    expect(exportedPdf).toBeDefined();
    expect(exportedPdf.buffer).toBeDefined();
    expect(exportedPdf.buffer.byteLength).toBeGreaterThan(originalSize);
    
    // Check the PDF structure for embedded files
    const pdfDoc = await PDFDocument.load(exportedPdf.buffer);
    
    // Verify Names dictionary exists - required for embedded files
    const namesDict = pdfDoc.catalog.lookup(PDFName.of('Names'));
    expect(namesDict).toBeDefined();
    
    // Verify EmbeddedFiles entry exists
    const embeddedFilesDict = namesDict.lookup(PDFName.of('EmbeddedFiles'));
    expect(embeddedFilesDict).toBeDefined();
    
    // Verify Names array exists
    const namesArray = embeddedFilesDict.lookup(PDFName.of('Names'));
    expect(namesArray).toBeDefined();
    
    // Count the number of entries (should be at least one file per format)
    // Each entry consists of a name and a file spec dictionary
    const entriesCount = namesArray.size() / 2;
    console.log(`✓ Found ${entriesCount} embedded file(s) in ${format} PDF`);
    
    // List the raw filenames (without trying to decode)
    for (let i = 0; i < namesArray.size(); i += 2) {
      const nameObj = namesArray.lookup(i);
      if (nameObj) {
        console.log(`  - Embedded file: ${nameObj.toString()}`);
      }
    }
  }
  
  console.log('\n✓ All formats successfully exported PDFs with embedded files');
});

// Format parameter type check test
tap.test('XInvoice should accept only valid export formats', async () => {
  // This test doesn't actually run code, but verifies that the type system works
  // The compiler should catch invalid format types
  
  // Create a sample XInvoice instance
  const xInvoice = new XInvoice();
  
  // These should compile fine - they're valid ExportFormat values
  const validFormats: ExportFormat[] = ['facturx', 'zugferd', 'xrechnung', 'ubl'];
  
  // For each format, verify it's part of the expected enum values
  for (const format of validFormats) {
    expect(['facturx', 'zugferd', 'xrechnung', 'ubl'].includes(format)).toBeTrue();
  }
  
  // This test passes if it compiles without type errors
  expect(true).toBeTrue();
});

// Test specific invoice items get preserved through PDF export and import
tap.test('Invoice items should be preserved in PDF export and import cycle', async () => {
  // 1. Create invoice with UNIQUE items for verification
  const originalInvoice = new XInvoice();
  
  // Set basic invoice details
  const uniqueId = `ITEM-TEST-${Date.now()}`;
  originalInvoice.content.invoiceData.id = uniqueId;
  originalInvoice.content.invoiceData.billedBy.name = 'Items Test Seller';
  originalInvoice.content.invoiceData.billedTo.name = 'Items Test Buyer';
  
  // Add required address details
  originalInvoice.content.invoiceData.billedBy.address.streetName = '123 Seller St';
  originalInvoice.content.invoiceData.billedBy.address.city = 'Seller City';
  originalInvoice.content.invoiceData.billedBy.address.postalCode = '12345';
  
  originalInvoice.content.invoiceData.billedTo.address.streetName = '456 Buyer St';
  originalInvoice.content.invoiceData.billedTo.address.city = 'Buyer City';
  originalInvoice.content.invoiceData.billedTo.address.postalCode = '67890';
  
  // Add multiple test items with UNIQUE identifiable names and values
  const itemsToTest = [
    {
      position: 1,
      name: `Special Product A-${Math.floor(Math.random() * 10000)}`,
      unitType: 'piece',
      unitQuantity: 2,
      unitNetPrice: 99.95,
      vatPercentage: 19
    },
    {
      position: 2,
      name: `Premium Service B-${Math.floor(Math.random() * 10000)}`,
      unitType: 'hour',
      unitQuantity: 5,
      unitNetPrice: 120.00,
      vatPercentage: 7
    },
    {
      position: 3,
      name: `Unique Item C-${Math.floor(Math.random() * 10000)}`,
      unitType: 'kg',
      unitQuantity: 10,
      unitNetPrice: 12.50,
      vatPercentage: 19
    }
  ];
  
  // Store the item names for verification
  const itemNames = itemsToTest.map(item => item.name);
  console.log('Created invoice with items:');
  itemNames.forEach(name => console.log(`- ${name}`));
  
  // Add the items to the invoice
  for (const item of itemsToTest) {
    originalInvoice.content.invoiceData.items.push(item);
  }
  
  // Create basic PDF
  const pdfDoc = await PDFDocument.create();
  pdfDoc.addPage().drawText('Invoice Items Test');
  const pdfBuffer = await pdfDoc.save();
  
  // Assign the PDF to the invoice
  originalInvoice.pdf = {
    name: 'items-test.pdf',
    id: `items-${Date.now()}`,
    metadata: {
      textExtraction: 'Items Test'
    },
    buffer: pdfBuffer
  };
  
  // 2. Export to PDF with embedded XML
  console.log('\nExporting invoice with items to PDF...');
  const exportedPdf = await originalInvoice.exportPdf('facturx');
  expect(exportedPdf.buffer.byteLength).toBeGreaterThan(pdfBuffer.byteLength);
  
  // 3. Create new invoice by loading the exported PDF
  console.log('Loading exported PDF into new invoice instance...');
  const loadedInvoice = new XInvoice();
  await loadedInvoice.loadPdf(exportedPdf.buffer);
  
  // 4. Verify the invoice items were preserved
  console.log('Verifying items in loaded invoice...');
  
  // Check invoice ID was preserved
  expect(loadedInvoice.content.invoiceData.id).toEqual(uniqueId);
  
  // Check we have the correct number of items
  expect(loadedInvoice.content.invoiceData.items.length).toEqual(itemsToTest.length);
  console.log(`✓ Found ${loadedInvoice.content.invoiceData.items.length} items (expected ${itemsToTest.length})`);
  
  // Extract loaded item names for comparison
  const loadedItemNames = loadedInvoice.content.invoiceData.items.map(item => item.name);
  console.log('Found items:');
  loadedItemNames.forEach(name => console.log(`- ${name}`));
  
  // Verify each original item is found in the loaded items
  let matchedItems = 0;
  for (const originalName of itemNames) {
    const matchFound = loadedItemNames.some(loadedName => 
      loadedName === originalName ||  // Exact match
      loadedName.includes(originalName.split('-')[0]) // Partial match
    );
    
    if (matchFound) {
      matchedItems++;
      console.log(`✓ Found item: ${originalName}`);
    } else {
      console.log(`✗ Missing item: ${originalName}`);
    }
  }
  
  // Verify all items were matched
  const matchPercent = Math.round((matchedItems / itemNames.length) * 100);
  console.log(`Item match rate: ${matchedItems}/${itemNames.length} (${matchPercent}%)`);
  
  // Even partial matching is acceptable (as transformations may occur in the XML)
  expect(matchedItems).toBeGreaterThan(0);
  
  // Verify at least some core invoice item data is preserved
  const firstLoadedItem = loadedInvoice.content.invoiceData.items[0];
  console.log(`First item details: ${JSON.stringify(firstLoadedItem, null, 2)}`);
  
  // Check for key properties that should be preserved
  expect(firstLoadedItem.name).toBeDefined();
  expect(firstLoadedItem.name.length).toBeGreaterThan(0);
  
  if (firstLoadedItem.unitQuantity !== undefined) {
    console.log(`✓ unitQuantity preserved: ${firstLoadedItem.unitQuantity}`);
    expect(firstLoadedItem.unitQuantity).toBeGreaterThan(0);
  }
  
  if (firstLoadedItem.unitNetPrice !== undefined) {
    console.log(`✓ unitNetPrice preserved: ${firstLoadedItem.unitNetPrice}`);
    expect(firstLoadedItem.unitNetPrice).toBeGreaterThan(0);
  }
  
  if (firstLoadedItem.vatPercentage !== undefined) {
    console.log(`✓ vatPercentage preserved: ${firstLoadedItem.vatPercentage}`);
    expect(firstLoadedItem.vatPercentage).toBeGreaterThanOrEqual(0);
  }
  
  console.log('\n✓ Invoice items successfully preserved through PDF export and import cycle');
});

// Start the tests
export default tap.start();