const CacheManager = require('../src/cache/cache-manager');
const path = require('path');
const fs = require('fs-extra');

describe('CacheManager', () => {
  let cacheManager;
  let testCacheDir;

  beforeEach(async () => {
    testCacheDir = path.join(global.TEST_DIR, 'cache');
    cacheManager = new CacheManager();
    cacheManager.cacheDir = testCacheDir;
    cacheManager.metadataFile = path.join(testCacheDir, 'metadata.json');
    await cacheManager.init();
  });

  describe('init', () => {
    test('should create cache directory', async () => {
      expect(await fs.pathExists(testCacheDir)).toBe(true);
    });

    test('should create metadata file', async () => {
      expect(await fs.pathExists(cacheManager.metadataFile)).toBe(true);
    });
  });

  describe('store and get', () => {
    test('should store and retrieve package data', async () => {
      const packageName = 'test-package';
      const version = '1.0.0';
      const data = Buffer.from('test package data');

      await cacheManager.store(packageName, version, data);
      const retrieved = await cacheManager.get(packageName, version);

      expect(retrieved).toEqual(data);
    });

    test('should return null for non-existent package', async () => {
      const retrieved = await cacheManager.get('non-existent', '1.0.0');
      expect(retrieved).toBeNull();
    });

    test('should handle binary data correctly', async () => {
      const packageName = 'binary-package';
      const version = '1.0.0';
      const binaryData = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);

      await cacheManager.store(packageName, version, binaryData);
      const retrieved = await cacheManager.get(packageName, version);

      expect(retrieved).toEqual(binaryData);
    });
  });

  describe('remove', () => {
    test('should remove package from cache', async () => {
      const packageName = 'test-package';
      const version = '1.0.0';
      const data = Buffer.from('test data');

      await cacheManager.store(packageName, version, data);
      expect(await cacheManager.get(packageName, version)).toEqual(data);

      const removed = await cacheManager.remove(packageName, version);
      expect(removed).toBe(true);
      expect(await cacheManager.get(packageName, version)).toBeNull();
    });

    test('should return false for non-existent package', async () => {
      const removed = await cacheManager.remove('non-existent', '1.0.0');
      expect(removed).toBe(false);
    });
  });

  describe('verify', () => {
    test('should verify cache integrity', async () => {
      const packageName = 'test-package';
      const version = '1.0.0';
      const data = Buffer.from('test data');

      await cacheManager.store(packageName, version, data);
      const result = await cacheManager.verify();

      expect(result.corrupted).toBe(0);
      expect(result.missing).toBe(0);
      expect(result.valid).toBe(1);
    });
  });

  describe('clean', () => {
    test('should clean entire cache', async () => {
      const packageName = 'test-package';
      const version = '1.0.0';
      const data = Buffer.from('test data');

      await cacheManager.store(packageName, version, data);
      expect(await cacheManager.get(packageName, version)).toEqual(data);

      const cleanedSize = await cacheManager.clean();
      expect(cleanedSize).toBeGreaterThan(0);
      expect(await cacheManager.get(packageName, version)).toBeNull();
    });
  });

  describe('getStats', () => {
    test('should return cache statistics', async () => {
      const stats = await cacheManager.getStats();

      expect(stats).toHaveProperty('totalEntries');
      expect(stats).toHaveProperty('totalSize');
      expect(stats).toHaveProperty('compressionRatio');
      expect(typeof stats.totalEntries).toBe('number');
      expect(typeof stats.totalSize).toBe('number');
    });

    test('should calculate compression ratio correctly', async () => {
      const packageName = 'test-package';
      const version = '1.0.0';
      const data = Buffer.from('test data '.repeat(100)); // Repeatable data for good compression

      await cacheManager.store(packageName, version, data);
      const stats = await cacheManager.getStats();

      expect(stats.totalEntries).toBe(1);
      expect(stats.compressionRatio).toBeLessThan(1); // Should be compressed
    });
  });
});