import { setupIntegrationTests, teardownIntegrationTests } from './setup';
import { IntegrationTestHelper, TestRedisSystem } from './test-helpers';
import { Result } from '@soapjs/soap';

describe('Redis Set Collection Integration Tests', () => {
  let redisSystem: TestRedisSystem;
  let redisUrl: string;

  beforeAll(async () => {
    redisUrl = await setupIntegrationTests();
    redisSystem = await IntegrationTestHelper.createTestRedisSystem(redisUrl, {
      collectionPrefix: 'set-test'
    });
    
    // Wait for connection to be established
    await IntegrationTestHelper.waitForConnection(redisSystem.redisSource);
  });

  afterAll(async () => {
    await IntegrationTestHelper.cleanupRedisSystem(redisSystem);
    await teardownIntegrationTests();
  });

  beforeEach(async () => {
    // Clear the collection before each test
    await redisSystem.setCollection.clear();
  });

  describe('Basic Operations', () => {
    it('should add items to set collection', async () => {
      // Arrange
      const testItems = ['item1', 'item2', 'item3'];

      // Act
      const result = await redisSystem.setCollection.add(testItems);

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(3);
        expect(result.content).toEqual(testItems);
      }
    });

    it('should find all items in set collection', async () => {
      // Arrange
      const testItems = ['item1', 'item2', 'item3'];
      await redisSystem.setCollection.add(testItems);

      // Act
      const result = await redisSystem.setCollection.find();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(3);
        expect(result.content).toEqual(expect.arrayContaining(testItems));
      }
    });

    it('should count items in set collection', async () => {
      // Arrange
      const testItems = ['item1', 'item2', 'item3'];
      await redisSystem.setCollection.add(testItems);

      // Act
      const result = await redisSystem.setCollection.count();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toBe(3);
      }
    });

    it('should remove items from set collection', async () => {
      // Arrange
      const testItems = ['item1', 'item2', 'item3'];
      await redisSystem.setCollection.add(testItems);

      // Act
      const result = await redisSystem.setCollection.remove({} as any);

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content.deletedCount).toBeGreaterThan(0);
      }
    });

    it('should clear all items from set collection', async () => {
      // Arrange
      const testItems = ['item1', 'item2', 'item3'];
      await redisSystem.setCollection.add(testItems);

      // Act
      const result = await redisSystem.setCollection.clear();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toBe('success');
      }
    });
  });

  describe('Set Uniqueness', () => {
    it('should not allow duplicate items in set', async () => {
      // Arrange
      const duplicateItems = ['item1', 'item1', 'item2', 'item2'];

      // Act
      const result = await redisSystem.setCollection.add(duplicateItems);

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(4); // Input array length
      }

      // Verify only unique items are stored
      const findResult = await redisSystem.setCollection.find();
      expect(findResult.isSuccess()).toBe(true);
      if (findResult.isSuccess()) {
        expect(findResult.content).toHaveLength(2); // Only unique items
        expect(findResult.content).toEqual(expect.arrayContaining(['item1', 'item2']));
      }
    });

    it('should handle adding same items multiple times', async () => {
      // Arrange
      const firstBatch = ['item1', 'item2'];
      const secondBatch = ['item1', 'item3']; // item1 is duplicate

      // Act
      await redisSystem.setCollection.add(firstBatch);
      await redisSystem.setCollection.add(secondBatch);
      const result = await redisSystem.setCollection.find();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(3); // item1, item2, item3
        expect(result.content).toEqual(expect.arrayContaining(['item1', 'item2', 'item3']));
      }
    });
  });

  describe('Error Handling', () => {
    it('should handle empty array when adding items', async () => {
      // Act
      const result = await redisSystem.setCollection.add([]);

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(0);
      }
    });

    it('should handle find operation on empty collection', async () => {
      // Act
      const result = await redisSystem.setCollection.find();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(0);
      }
    });

    it('should handle count operation on empty collection', async () => {
      // Act
      const result = await redisSystem.setCollection.count();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toBe(0);
      }
    });
  });

  describe('Performance Tests', () => {
    it('should handle large number of items efficiently', async () => {
      // Arrange
      const largeItemSet = Array.from({ length: 100 }, (_, i) => `item_${i + 1}`);

      // Act
      const startTime = Date.now();
      const result = await redisSystem.setCollection.add(largeItemSet);
      const endTime = Date.now();
      const duration = endTime - startTime;

      // Assert
      expect(result.isSuccess()).toBe(true);
      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
      console.log(`Added 100 items in ${duration}ms`);
    });

    it('should handle concurrent operations', async () => {
      // Arrange
      const itemSets = Array.from({ length: 5 }, (_, i) => 
        Array.from({ length: 10 }, (_, j) => `concurrent_${i}_${j}`)
      );

      // Act
      const startTime = Date.now();
      const promises = itemSets.map(items => redisSystem.setCollection.add(items));
      const results = await Promise.all(promises);
      const endTime = Date.now();

      // Assert
      results.forEach(result => {
        expect(result.isSuccess()).toBe(true);
      });
      expect(endTime - startTime).toBeLessThan(10000); // Should complete within 10 seconds
      console.log(`Completed 5 concurrent operations in ${endTime - startTime}ms`);
    });
  });

  describe('Data Types', () => {
    it('should handle different data types in set items', async () => {
      // Arrange
      const testItems = [
        'string item',
        '42',
        'true',
        '{"nested": "object"}'
      ];

      // Act
      const result = await redisSystem.setCollection.add(testItems);

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(4);
        expect(result.content).toEqual(expect.arrayContaining(testItems));
      }
    });
  });

  describe('Set Operations', () => {
    it('should maintain set properties (no order guarantee)', async () => {
      // Arrange
      const testItems = ['z', 'a', 'm', 'z', 'a']; // Duplicates and mixed order

      // Act
      await redisSystem.setCollection.add(testItems);
      const result = await redisSystem.setCollection.find();

      // Assert
      expect(result.isSuccess()).toBe(true);
      if (result.isSuccess()) {
        expect(result.content).toHaveLength(3); // Only unique items
        expect(result.content).toEqual(expect.arrayContaining(['z', 'a', 'm']));
        // Order is not guaranteed in sets
      }
    });
  });
});