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

tap.test('PARSE-01: Basic XML structure parsing', async () => {
  const testCases = [
    {
      name: 'Minimal invoice',
      xml: '<?xml version="1.0" encoding="UTF-8"?>\n<invoice><id>TEST-001</id></invoice>',
      expectedId: null // Generic invoice element not recognized
    },
    {
      name: 'Invoice with namespaces',
      xml: `<?xml version="1.0" encoding="UTF-8"?>
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
  <cbc:ID>TEST-002</cbc:ID>
</ubl:Invoice>`,
      expectedId: 'TEST-002'
    },
    {
      name: 'XRechnung UBL invoice',
      xml: `<?xml version="1.0" encoding="UTF-8"?>
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2" xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2">
  <cbc:ID>TEST-003</cbc:ID>
  <cbc:IssueDate>2024-01-01</cbc:IssueDate>
  <cac:AccountingSupplierParty>
    <cac:Party>
      <cac:PartyName>
        <cbc:Name>Test Supplier</cbc:Name>
      </cac:PartyName>
      <cac:PostalAddress>
        <cbc:CityName>Berlin</cbc:CityName>
        <cbc:PostalZone>10115</cbc:PostalZone>
        <cac:Country>
          <cbc:IdentificationCode>DE</cbc:IdentificationCode>
        </cac:Country>
      </cac:PostalAddress>
    </cac:Party>
  </cac:AccountingSupplierParty>
  <cac:AccountingCustomerParty>
    <cac:Party>
      <cac:PartyName>
        <cbc:Name>Test Customer</cbc:Name>
      </cac:PartyName>
      <cac:PostalAddress>
        <cbc:CityName>Munich</cbc:CityName>
        <cbc:PostalZone>80331</cbc:PostalZone>
        <cac:Country>
          <cbc:IdentificationCode>DE</cbc:IdentificationCode>
        </cac:Country>
      </cac:PostalAddress>
    </cac:Party>
  </cac:AccountingCustomerParty>
  <cac:InvoiceLine>
    <cbc:ID>1</cbc:ID>
    <cbc:InvoicedQuantity unitCode="EA">1</cbc:InvoicedQuantity>
    <cbc:LineExtensionAmount currencyID="EUR">100.00</cbc:LineExtensionAmount>
    <cac:Item>
      <cbc:Name>Test Product</cbc:Name>
    </cac:Item>
    <cac:Price>
      <cbc:PriceAmount currencyID="EUR">100.00</cbc:PriceAmount>
    </cac:Price>
  </cac:InvoiceLine>
  <cac:LegalMonetaryTotal>
    <cbc:TaxInclusiveAmount currencyID="EUR">119.00</cbc:TaxInclusiveAmount>
  </cac:LegalMonetaryTotal>
</ubl:Invoice>`,
      expectedId: 'TEST-003'
    }
  ];
  
  for (const testCase of testCases) {
    const { result, metric } = await PerformanceTracker.track(
      'xml-parsing',
      async () => {
        const invoice = new einvoice.EInvoice();
        
        try {
          await invoice.fromXmlString(testCase.xml);
          return {
            success: true,
            id: invoice.id,
            hasFrom: !!invoice.from,
            hasTo: !!invoice.to,
            itemCount: invoice.items?.length || 0
          };
        } catch (error) {
          return {
            success: false,
            error: error.message
          };
        }
      }
    );
    
    console.log(`${testCase.name}: ${result.success ? '✓' : '✗'}`);
    
    if (testCase.expectedId !== null) {
      if (result.success) {
        expect(result.id).toEqual(testCase.expectedId);
        console.log(`  ID: ${result.id}`);
        console.log(`  Has supplier: ${result.hasFrom}`);
        console.log(`  Has customer: ${result.hasTo}`);
        console.log(`  Item count: ${result.itemCount}`);
      } else {
        console.log(`  Error: ${result.error}`);
      }
    }
    
    console.log(`  Parse time: ${metric.duration.toFixed(2)}ms`);
  }
});

tap.test('PARSE-01: Character encoding handling', async () => {
  const encodingTests = [
    {
      name: 'UTF-8 with special characters',
      xml: `<?xml version="1.0" encoding="UTF-8"?>
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
  <cbc:ID>UTF8-TEST</cbc:ID>
  <cbc:Note>Special chars: äöü ñ € « » 中文</cbc:Note>
</ubl:Invoice>`,
      expectedNote: 'Special chars: äöü ñ € « » 中文'
    },
    {
      name: 'ISO-8859-1 declaration',
      xml: `<?xml version="1.0" encoding="ISO-8859-1"?>
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
  <cbc:ID>ISO-TEST</cbc:ID>
  <cbc:Note>Latin-1 chars: àèìòù</cbc:Note>
</ubl:Invoice>`,
      expectedNote: 'Latin-1 chars: àèìòù'
    }
  ];
  
  for (const test of encodingTests) {
    const { result } = await PerformanceTracker.track(
      'encoding-test',
      async () => {
        const invoice = new einvoice.EInvoice();
        
        try {
          await invoice.fromXmlString(test.xml);
          return {
            success: true,
            notes: invoice.notes,
            id: invoice.id
          };
        } catch (error) {
          return {
            success: false,
            error: error.message
          };
        }
      }
    );
    
    console.log(`${test.name}: ${result.success ? '✓' : '✗'}`);
    
    if (result.success) {
      expect(result.notes).toBeDefined();
      if (result.notes && result.notes.length > 0) {
        expect(result.notes[0]).toEqual(test.expectedNote);
        console.log(`  Note preserved: ${result.notes[0]}`);
      }
    }
  }
});

tap.test('PARSE-01: Namespace handling', async () => {
  const namespaceTests = [
    {
      name: 'Multiple namespace declarations',
      xml: `<?xml version="1.0" encoding="UTF-8"?>
<rsm:CrossIndustryInvoice 
  xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
  xmlns:qdt="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
  xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100">
  <rsm:ExchangedDocumentContext>
    <ram:GuidelineSpecifiedDocumentContextParameter>
      <ram:ID>urn:cen.eu:en16931:2017#conformant#urn:factur-x.eu:1p0:extended</ram:ID>
    </ram:GuidelineSpecifiedDocumentContextParameter>
  </rsm:ExchangedDocumentContext>
  <rsm:ExchangedDocument>
    <ram:ID>NS-TEST-001</ram:ID>
  </rsm:ExchangedDocument>
</rsm:CrossIndustryInvoice>`,
      expectedFormat: einvoice.InvoiceFormat.FACTURX,
      expectedId: 'NS-TEST-001'
    },
    {
      name: 'Default namespace',
      xml: `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
  <ID xmlns="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">DEFAULT-NS-TEST</ID>
</Invoice>`,
      expectedFormat: einvoice.InvoiceFormat.UBL,
      expectedId: 'DEFAULT-NS-TEST'
    }
  ];
  
  for (const test of namespaceTests) {
    const { result } = await PerformanceTracker.track(
      'namespace-test',
      async () => {
        const invoice = new einvoice.EInvoice();
        
        try {
          await invoice.fromXmlString(test.xml);
          return {
            success: true,
            format: invoice.getFormat(),
            id: invoice.id
          };
        } catch (error) {
          return {
            success: false,
            error: error.message
          };
        }
      }
    );
    
    console.log(`${test.name}: ${result.success ? '✓' : '✗'}`);
    
    if (result.success) {
      expect(result.format).toEqual(test.expectedFormat);
      expect(result.id).toEqual(test.expectedId);
      console.log(`  Detected format: ${einvoice.InvoiceFormat[result.format]}`);
      console.log(`  ID: ${result.id}`);
    }
  }
});

tap.test('PARSE-01: Large XML file parsing', async () => {
  // Generate a large invoice with many line items
  const generateLargeInvoice = (lineCount: number): string => {
    const lines = [];
    for (let i = 1; i <= lineCount; i++) {
      lines.push(`
    <cac:InvoiceLine>
      <cbc:ID>${i}</cbc:ID>
      <cbc:InvoicedQuantity unitCode="EA">${i}</cbc:InvoicedQuantity>
      <cbc:LineExtensionAmount currencyID="EUR">${(i * 10).toFixed(2)}</cbc:LineExtensionAmount>
      <cac:Item>
        <cbc:Name>Product ${i}</cbc:Name>
        <cbc:Description>Description for product ${i} with some additional text to make it larger</cbc:Description>
      </cac:Item>
      <cac:Price>
        <cbc:PriceAmount currencyID="EUR">10.00</cbc:PriceAmount>
      </cac:Price>
    </cac:InvoiceLine>`);
    }
    
    return `<?xml version="1.0" encoding="UTF-8"?>
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" 
             xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
             xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2">
  <cbc:ID>LARGE-INVOICE-${lineCount}</cbc:ID>
  <cbc:IssueDate>2024-01-01</cbc:IssueDate>
  <cac:AccountingSupplierParty>
    <cac:Party>
      <cac:PartyName>
        <cbc:Name>Large Supplier Inc</cbc:Name>
      </cac:PartyName>
      <cac:PostalAddress>
        <cbc:CityName>Berlin</cbc:CityName>
        <cbc:PostalZone>10115</cbc:PostalZone>
        <cac:Country>
          <cbc:IdentificationCode>DE</cbc:IdentificationCode>
        </cac:Country>
      </cac:PostalAddress>
    </cac:Party>
  </cac:AccountingSupplierParty>
  <cac:AccountingCustomerParty>
    <cac:Party>
      <cac:PartyName>
        <cbc:Name>Large Customer Corp</cbc:Name>
      </cac:PartyName>
      <cac:PostalAddress>
        <cbc:CityName>Munich</cbc:CityName>
        <cbc:PostalZone>80331</cbc:PostalZone>
        <cac:Country>
          <cbc:IdentificationCode>DE</cbc:IdentificationCode>
        </cac:Country>
      </cac:PostalAddress>
    </cac:Party>
  </cac:AccountingCustomerParty>
${lines.join('')}
</ubl:Invoice>`;
  };
  
  const sizes = [10, 100, 1000];
  
  for (const size of sizes) {
    const xml = generateLargeInvoice(size);
    const xmlSize = Buffer.byteLength(xml, 'utf-8') / 1024; // KB
    
    const { result, metric } = await PerformanceTracker.track(
      `parse-${size}-lines`,
      async () => {
        const invoice = new einvoice.EInvoice();
        
        try {
          await invoice.fromXmlString(xml);
          return {
            success: true,
            itemCount: invoice.items?.length || 0,
            memoryUsed: metric?.memory?.used || 0
          };
        } catch (error) {
          return {
            success: false,
            error: error.message
          };
        }
      }
    );
    
    console.log(`Parse ${size} line items (${xmlSize.toFixed(1)}KB): ${result.success ? '✓' : '✗'}`);
    
    if (result.success) {
      expect(result.itemCount).toEqual(size);
      console.log(`  Items parsed: ${result.itemCount}`);
      console.log(`  Parse time: ${metric.duration.toFixed(2)}ms`);
      console.log(`  Memory used: ${(metric.memory.used / 1024 / 1024).toFixed(2)}MB`);
      console.log(`  Speed: ${(xmlSize / metric.duration * 1000).toFixed(2)}KB/s`);
    }
  }
});

tap.test('PARSE-01: Real corpus file parsing', async () => {
  // Try to load some real files from the corpus
  const testFiles = [
    { category: 'UBL_XMLRECHNUNG', file: 'XRECHNUNG_Einfach.ubl.xml' },
    { category: 'CII_XMLRECHNUNG', file: 'XRECHNUNG_Einfach.cii.xml' },
    { category: 'ZUGFERDV2_CORRECT', file: null } // Will use first available
  ];
  
  for (const testFile of testFiles) {
    try {
      let xmlContent: string;
      
      if (testFile.file) {
        xmlContent = await CorpusLoader.loadTestFile(testFile.category, testFile.file);
      } else {
        const files = await CorpusLoader.getCorpusFiles(testFile.category);
        if (files.length > 0) {
          xmlContent = await CorpusLoader.loadTestFile(testFile.category, files[0]);
        } else {
          console.log(`No files found in category ${testFile.category}`);
          continue;
        }
      }
      
      const { result, metric } = await PerformanceTracker.track(
        'corpus-parsing',
        async () => {
          const invoice = new einvoice.EInvoice();
          
          try {
            await invoice.fromXmlString(xmlContent);
            return {
              success: true,
              format: invoice.getFormat(),
              id: invoice.id,
              hasData: !!invoice.from && !!invoice.to && invoice.items?.length > 0
            };
          } catch (error) {
            return {
              success: false,
              error: error.message
            };
          }
        }
      );
      
      console.log(`${testFile.category}/${testFile.file || 'first-file'}: ${result.success ? '✓' : '✗'}`);
      
      if (result.success) {
        console.log(`  Format: ${einvoice.InvoiceFormat[result.format]}`);
        console.log(`  ID: ${result.id}`);
        console.log(`  Has complete data: ${result.hasData}`);
        console.log(`  Parse time: ${metric.duration.toFixed(2)}ms`);
      } else {
        console.log(`  Error: ${result.error}`);
      }
    } catch (error) {
      console.log(`Failed to load ${testFile.category}/${testFile.file}: ${error.message}`);
    }
  }
});

tap.test('PARSE-01: Error recovery', async () => {
  const errorCases = [
    {
      name: 'Empty XML',
      xml: '',
      expectError: true
    },
    {
      name: 'Invalid XML syntax',
      xml: '<?xml version="1.0"?><invoice><id>TEST</id><invoice>',
      expectError: true
    },
    {
      name: 'Non-invoice XML',
      xml: '<?xml version="1.0"?><root><data>test</data></root>',
      expectError: true
    },
    {
      name: 'Missing mandatory fields',
      xml: `<?xml version="1.0"?>
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
  <!-- Missing ID and other required fields -->
</ubl:Invoice>`,
      expectError: true
    }
  ];
  
  for (const testCase of errorCases) {
    const { result } = await PerformanceTracker.track(
      'error-recovery',
      async () => {
        const invoice = new einvoice.EInvoice();
        
        try {
          await invoice.fromXmlString(testCase.xml);
          return { success: true };
        } catch (error) {
          return {
            success: false,
            error: error.message,
            errorType: error.constructor.name
          };
        }
      }
    );
    
    console.log(`${testCase.name}: ${testCase.expectError ? (result.success ? '✗' : '✓') : (result.success ? '✓' : '✗')}`);
    
    if (testCase.expectError) {
      expect(result.success).toBeFalse();
      console.log(`  Error type: ${result.errorType}`);
      console.log(`  Error message: ${result.error}`);
    } else {
      expect(result.success).toBeTrue();
    }
  }
});

tap.test('PARSE-01: Performance summary', async () => {
  const stats = PerformanceTracker.getStats('xml-parsing');
  
  if (stats) {
    console.log('\nPerformance Summary:');
    console.log(`  Total parses: ${stats.count}`);
    console.log(`  Average time: ${stats.avg.toFixed(2)}ms`);
    console.log(`  Min time: ${stats.min.toFixed(2)}ms`);
    console.log(`  Max time: ${stats.max.toFixed(2)}ms`);
    console.log(`  P95 time: ${stats.p95.toFixed(2)}ms`);
    
    // Check against thresholds
    expect(stats.avg).toBeLessThan(50); // 50ms average for small files
    expect(stats.p95).toBeLessThan(100); // 100ms for 95th percentile
  }
});

// Run the tests
tap.start();