import { test } from '@git.zone/tstest/tapbundle';
import { createTestServer, createSmtpClient } from '../../helpers/utils.js';
import { Email } from '../../../ts/mail/core/classes.email.js';

test('CREL-05: Memory Leak Prevention Reliability Tests', async () => {
  console.log('\n🧠 Testing SMTP Client Memory Leak Prevention');
  console.log('=' .repeat(60));

  // Helper function to get memory usage
  const getMemoryUsage = () => {
    const usage = process.memoryUsage();
    return {
      heapUsed: Math.round(usage.heapUsed / 1024 / 1024 * 100) / 100, // MB
      heapTotal: Math.round(usage.heapTotal / 1024 / 1024 * 100) / 100, // MB
      external: Math.round(usage.external / 1024 / 1024 * 100) / 100, // MB
      rss: Math.round(usage.rss / 1024 / 1024 * 100) / 100 // MB
    };
  };

  // Force garbage collection if available
  const forceGC = () => {
    if (global.gc) {
      global.gc();
      global.gc(); // Run twice for thoroughness
    }
  };

  // Scenario 1: Connection Pool Memory Management
  await test.test('Scenario 1: Connection Pool Memory Management', async () => {
    console.log('\n🏊 Testing connection pool memory management...');
    
    const testServer = await createTestServer({
      responseDelay: 20,
      onConnect: () => {
        console.log('  [Server] Connection established for memory test');
      }
    });

    try {
      const initialMemory = getMemoryUsage();
      console.log(`  Initial memory: ${initialMemory.heapUsed}MB heap, ${initialMemory.rss}MB RSS`);

      console.log('  Phase 1: Creating and using multiple connection pools...');
      const memorySnapshots = [];
      
      for (let poolIndex = 0; poolIndex < 5; poolIndex++) {
        console.log(`  Creating connection pool ${poolIndex + 1}...`);
        
        const smtpClient = createSmtpClient({
          host: testServer.hostname,
          port: testServer.port,
          secure: false,
          pool: true,
          maxConnections: 3,
          maxMessages: 20,
          connectionTimeout: 1000
        });

        // Send emails through this pool
        const emails = [];
        for (let i = 0; i < 6; i++) {
          emails.push(new Email({
            from: `sender${poolIndex}@memoryleak.test`,
            to: [`recipient${i}@memoryleak.test`],
            subject: `Memory Pool Test ${poolIndex + 1}-${i + 1}`,
            text: `Testing memory management in pool ${poolIndex + 1}, email ${i + 1}`,
            messageId: `memory-pool-${poolIndex}-${i}@memoryleak.test`
          }));
        }

        // Send emails concurrently
        const promises = emails.map((email, index) => {
          return smtpClient.sendMail(email).then(result => {
            return { success: true, result };
          }).catch(error => {
            return { success: false, error };
          });
        });

        const results = await Promise.all(promises);
        const successful = results.filter(r => r.success).length;
        console.log(`  Pool ${poolIndex + 1}: ${successful}/${emails.length} emails sent`);

        // Close the pool
        smtpClient.close();
        console.log(`  Pool ${poolIndex + 1} closed`);

        // Force garbage collection and measure memory
        forceGC();
        await new Promise(resolve => setTimeout(resolve, 100));
        
        const currentMemory = getMemoryUsage();
        memorySnapshots.push({
          pool: poolIndex + 1,
          heap: currentMemory.heapUsed,
          rss: currentMemory.rss,
          external: currentMemory.external
        });
        
        console.log(`  Memory after pool ${poolIndex + 1}: ${currentMemory.heapUsed}MB heap`);
      }

      console.log('\n  Memory analysis:');
      memorySnapshots.forEach((snapshot, index) => {
        const memoryIncrease = snapshot.heap - initialMemory.heapUsed;
        console.log(`  Pool ${snapshot.pool}: +${memoryIncrease.toFixed(2)}MB heap increase`);
      });

      // Check for memory leaks (memory should not continuously increase)
      const firstIncrease = memorySnapshots[0].heap - initialMemory.heapUsed;
      const lastIncrease = memorySnapshots[memorySnapshots.length - 1].heap - initialMemory.heapUsed;
      const leakGrowth = lastIncrease - firstIncrease;
      
      console.log(`  Memory leak assessment:`);
      console.log(`  First pool increase: +${firstIncrease.toFixed(2)}MB`);
      console.log(`  Final memory increase: +${lastIncrease.toFixed(2)}MB`);
      console.log(`  Memory growth across pools: +${leakGrowth.toFixed(2)}MB`);
      console.log(`  Memory management: ${leakGrowth < 2.0 ? 'Good (< 2MB growth)' : 'Potential leak detected'}`);

    } finally {
      testServer.close();
    }
  });

  // Scenario 2: Email Object Memory Lifecycle
  await test.test('Scenario 2: Email Object Memory Lifecycle', async () => {
    console.log('\n📧 Testing email object memory lifecycle...');
    
    const testServer = await createTestServer({
      responseDelay: 10
    });

    try {
      const smtpClient = createSmtpClient({
        host: testServer.hostname,
        port: testServer.port,
        secure: false,
        pool: true,
        maxConnections: 2
      });

      const initialMemory = getMemoryUsage();
      console.log(`  Initial memory: ${initialMemory.heapUsed}MB heap`);

      console.log('  Phase 1: Creating large batches of email objects...');
      const batchSizes = [50, 100, 150, 100, 50]; // Varying batch sizes
      const memorySnapshots = [];

      for (let batchIndex = 0; batchIndex < batchSizes.length; batchIndex++) {
        const batchSize = batchSizes[batchIndex];
        console.log(`  Creating batch ${batchIndex + 1} with ${batchSize} emails...`);

        const emails = [];
        for (let i = 0; i < batchSize; i++) {
          emails.push(new Email({
            from: 'sender@emailmemory.test',
            to: [`recipient${i}@emailmemory.test`],
            subject: `Memory Lifecycle Test Batch ${batchIndex + 1} Email ${i + 1}`,
            text: `Testing email object memory lifecycle. This is a moderately long email body to test memory usage patterns. Email ${i + 1} in batch ${batchIndex + 1} of ${batchSize} emails.`,
            html: `<h1>Email ${i + 1}</h1><p>Testing memory patterns with HTML content. Batch ${batchIndex + 1}.</p>`,
            messageId: `email-memory-${batchIndex}-${i}@emailmemory.test`
          }));
        }

        console.log(`  Sending batch ${batchIndex + 1}...`);
        const promises = emails.map((email, index) => {
          return smtpClient.sendMail(email).then(result => {
            return { success: true };
          }).catch(error => {
            return { success: false, error };
          });
        });

        const results = await Promise.all(promises);
        const successful = results.filter(r => r.success).length;
        console.log(`  Batch ${batchIndex + 1}: ${successful}/${batchSize} emails sent`);

        // Clear email references
        emails.length = 0;

        // Force garbage collection
        forceGC();
        await new Promise(resolve => setTimeout(resolve, 100));

        const currentMemory = getMemoryUsage();
        memorySnapshots.push({
          batch: batchIndex + 1,
          size: batchSize,
          heap: currentMemory.heapUsed,
          external: currentMemory.external
        });

        console.log(`  Memory after batch ${batchIndex + 1}: ${currentMemory.heapUsed}MB heap`);
      }

      console.log('\n  Email object memory analysis:');
      memorySnapshots.forEach((snapshot, index) => {
        const memoryIncrease = snapshot.heap - initialMemory.heapUsed;
        console.log(`  Batch ${snapshot.batch} (${snapshot.size} emails): +${memoryIncrease.toFixed(2)}MB`);
      });

      // Check if memory scales reasonably with email batch size
      const maxMemoryIncrease = Math.max(...memorySnapshots.map(s => s.heap - initialMemory.heapUsed));
      const avgBatchSize = batchSizes.reduce((a, b) => a + b, 0) / batchSizes.length;
      
      console.log(`  Maximum memory increase: +${maxMemoryIncrease.toFixed(2)}MB`);
      console.log(`  Average batch size: ${avgBatchSize} emails`);
      console.log(`  Memory per email: ~${(maxMemoryIncrease / avgBatchSize * 1024).toFixed(1)}KB`);
      console.log(`  Email object lifecycle: ${maxMemoryIncrease < 10 ? 'Efficient' : 'Needs optimization'}`);

      smtpClient.close();
    } finally {
      testServer.close();
    }
  });

  // Scenario 3: Long-Running Client Memory Stability
  await test.test('Scenario 3: Long-Running Client Memory Stability', async () => {
    console.log('\n⏱️ Testing long-running client memory stability...');
    
    const testServer = await createTestServer({
      responseDelay: 5 // Fast responses for sustained operation
    });

    try {
      const smtpClient = createSmtpClient({
        host: testServer.hostname,
        port: testServer.port,
        secure: false,
        pool: true,
        maxConnections: 2,
        maxMessages: 1000
      });

      const initialMemory = getMemoryUsage();
      console.log(`  Initial memory: ${initialMemory.heapUsed}MB heap`);

      console.log('  Starting sustained email sending operation...');
      const memoryMeasurements = [];
      const totalEmails = 200; // Reduced for test efficiency
      const measurementInterval = 40; // Measure every 40 emails
      
      let emailsSent = 0;
      let emailsFailed = 0;

      for (let i = 0; i < totalEmails; i++) {
        const email = new Email({
          from: 'sender@longrunning.test',
          to: [`recipient${i}@longrunning.test`],
          subject: `Long Running Test ${i + 1}`,
          text: `Sustained operation test email ${i + 1}`,
          messageId: `longrunning-${i}@longrunning.test`
        });

        try {
          await smtpClient.sendMail(email);
          emailsSent++;
        } catch (error) {
          emailsFailed++;
        }

        // Measure memory at intervals
        if ((i + 1) % measurementInterval === 0) {
          forceGC();
          const currentMemory = getMemoryUsage();
          memoryMeasurements.push({
            emailCount: i + 1,
            heap: currentMemory.heapUsed,
            rss: currentMemory.rss,
            timestamp: Date.now()
          });
          
          console.log(`  ${i + 1}/${totalEmails} emails: ${currentMemory.heapUsed}MB heap`);
        }
      }

      console.log('\n  Long-running memory analysis:');
      console.log(`  Emails sent: ${emailsSent}, Failed: ${emailsFailed}`);
      
      memoryMeasurements.forEach((measurement, index) => {
        const memoryIncrease = measurement.heap - initialMemory.heapUsed;
        console.log(`  After ${measurement.emailCount} emails: +${memoryIncrease.toFixed(2)}MB heap`);
      });

      // Analyze memory growth trend
      if (memoryMeasurements.length >= 2) {
        const firstMeasurement = memoryMeasurements[0];
        const lastMeasurement = memoryMeasurements[memoryMeasurements.length - 1];
        
        const memoryGrowth = lastMeasurement.heap - firstMeasurement.heap;
        const emailsProcessed = lastMeasurement.emailCount - firstMeasurement.emailCount;
        const growthRate = (memoryGrowth / emailsProcessed) * 1000; // KB per email
        
        console.log(`  Memory growth over operation: +${memoryGrowth.toFixed(2)}MB`);
        console.log(`  Growth rate: ~${growthRate.toFixed(2)}KB per email`);
        console.log(`  Memory stability: ${growthRate < 5 ? 'Excellent' : growthRate < 15 ? 'Good' : 'Concerning'}`);
      }

      smtpClient.close();
    } finally {
      testServer.close();
    }
  });

  // Scenario 4: Buffer and Stream Memory Management
  await test.test('Scenario 4: Buffer and Stream Memory Management', async () => {
    console.log('\n🌊 Testing buffer and stream memory management...');
    
    const testServer = await createTestServer({
      responseDelay: 20,
      onData: (data: string) => {
        if (data.includes('large-attachment')) {
          console.log('  [Server] Processing large attachment email');
        }
      }
    });

    try {
      const smtpClient = createSmtpClient({
        host: testServer.hostname,
        port: testServer.port,
        secure: false,
        pool: true,
        maxConnections: 1,
        streamingMode: true, // Enable streaming for large content
        bufferManagement: true
      });

      const initialMemory = getMemoryUsage();
      console.log(`  Initial memory: ${initialMemory.heapUsed}MB heap`);

      console.log('  Testing with various buffer sizes...');
      const bufferSizes = [
        { size: 1024, name: '1KB' },
        { size: 10240, name: '10KB' },
        { size: 102400, name: '100KB' },
        { size: 512000, name: '500KB' },
        { size: 1048576, name: '1MB' }
      ];

      for (const bufferTest of bufferSizes) {
        console.log(`  Testing ${bufferTest.name} buffer size...`);
        
        const beforeMemory = getMemoryUsage();
        
        // Create large text content
        const largeText = 'X'.repeat(bufferTest.size);
        
        const email = new Email({
          from: 'sender@buffermem.test',
          to: ['recipient@buffermem.test'],
          subject: `Buffer Memory Test - ${bufferTest.name}`,
          text: largeText,
          messageId: `large-attachment-${bufferTest.size}@buffermem.test`
        });

        try {
          const result = await smtpClient.sendMail(email);
          console.log(`    ✓ ${bufferTest.name} email sent successfully`);
        } catch (error) {
          console.log(`    ✗ ${bufferTest.name} email failed: ${error.message}`);
        }

        // Force cleanup
        forceGC();
        await new Promise(resolve => setTimeout(resolve, 100));

        const afterMemory = getMemoryUsage();
        const memoryDiff = afterMemory.heap - beforeMemory.heap;
        
        console.log(`    Memory impact: ${memoryDiff > 0 ? '+' : ''}${memoryDiff.toFixed(2)}MB`);
        console.log(`    Buffer efficiency: ${Math.abs(memoryDiff) < (bufferTest.size / 1024 / 1024) ? 'Good' : 'High memory usage'}`);
      }

      const finalMemory = getMemoryUsage();
      const totalMemoryIncrease = finalMemory.heap - initialMemory.heapUsed;
      
      console.log(`\n  Buffer memory management summary:`);
      console.log(`  Total memory increase: +${totalMemoryIncrease.toFixed(2)}MB`);
      console.log(`  Buffer management efficiency: ${totalMemoryIncrease < 5 ? 'Excellent' : 'Needs optimization'}`);

      smtpClient.close();
    } finally {
      testServer.close();
    }
  });

  // Scenario 5: Event Listener Memory Management
  await test.test('Scenario 5: Event Listener Memory Management', async () => {
    console.log('\n🎧 Testing event listener memory management...');
    
    const testServer = await createTestServer({
      responseDelay: 15
    });

    try {
      const initialMemory = getMemoryUsage();
      console.log(`  Initial memory: ${initialMemory.heapUsed}MB heap`);

      console.log('  Phase 1: Creating clients with many event listeners...');
      const clients = [];
      const memorySnapshots = [];

      for (let clientIndex = 0; clientIndex < 10; clientIndex++) {
        const smtpClient = createSmtpClient({
          host: testServer.hostname,
          port: testServer.port,
          secure: false,
          pool: true,
          maxConnections: 1
        });

        // Add multiple event listeners to test memory management
        const eventHandlers = [];
        
        for (let i = 0; i < 5; i++) {
          const handler = (data: any) => {
            // Event handler logic
          };
          eventHandlers.push(handler);
          
          // Simulate adding event listeners (using mock events)
          if (smtpClient.on) {
            smtpClient.on('connect', handler);
            smtpClient.on('error', handler);
            smtpClient.on('close', handler);
          }
        }

        clients.push({ client: smtpClient, handlers: eventHandlers });

        // Send a test email through each client
        const email = new Email({
          from: 'sender@eventmem.test',
          to: ['recipient@eventmem.test'],
          subject: `Event Memory Test ${clientIndex + 1}`,
          text: `Testing event listener memory management ${clientIndex + 1}`,
          messageId: `event-memory-${clientIndex}@eventmem.test`
        });

        try {
          await smtpClient.sendMail(email);
          console.log(`  Client ${clientIndex + 1}: Email sent`);
        } catch (error) {
          console.log(`  Client ${clientIndex + 1}: Failed - ${error.message}`);
        }

        // Measure memory after each client
        if ((clientIndex + 1) % 3 === 0) {
          forceGC();
          const currentMemory = getMemoryUsage();
          memorySnapshots.push({
            clientCount: clientIndex + 1,
            heap: currentMemory.heapUsed
          });
          console.log(`  Memory after ${clientIndex + 1} clients: ${currentMemory.heapUsed}MB`);
        }
      }

      console.log('  Phase 2: Closing all clients and removing listeners...');
      for (let i = 0; i < clients.length; i++) {
        const { client, handlers } = clients[i];
        
        // Remove event listeners
        if (client.removeAllListeners) {
          client.removeAllListeners();
        }
        
        // Close client
        client.close();
        
        if ((i + 1) % 3 === 0) {
          forceGC();
          const currentMemory = getMemoryUsage();
          console.log(`  Memory after closing ${i + 1} clients: ${currentMemory.heapUsed}MB`);
        }
      }

      // Final memory check
      forceGC();
      await new Promise(resolve => setTimeout(resolve, 200));
      const finalMemory = getMemoryUsage();
      
      console.log('\n  Event listener memory analysis:');
      memorySnapshots.forEach(snapshot => {
        const increase = snapshot.heap - initialMemory.heapUsed;
        console.log(`  ${snapshot.clientCount} clients: +${increase.toFixed(2)}MB`);
      });

      const finalIncrease = finalMemory.heap - initialMemory.heapUsed;
      console.log(`  Final memory after cleanup: +${finalIncrease.toFixed(2)}MB`);
      console.log(`  Event listener cleanup: ${finalIncrease < 1 ? 'Excellent' : 'Memory retained'}`);

    } finally {
      testServer.close();
    }
  });

  console.log('\n✅ CREL-05: Memory Leak Prevention Reliability Tests completed');
  console.log('🧠 All memory management scenarios tested successfully');
});