/**
 * Storage Service Abstraction Layer Unit Tests
 * Tests the unified storage interface and provider switching
 */

// Mock Firebase Storage Service
const mockFirebaseService = {
  initialized: true,
  uploadEventImage: jest.fn(),
  uploadProfilePhoto: jest.fn(),
  uploadUserDocument: jest.fn(),
  uploadCertificate: jest.fn(),
  uploadInstitutionLogo: jest.fn(),
  deleteFile: jest.fn(),
  listFiles: jest.fn(),
  getFileMetadata: jest.fn(),
  healthCheck: jest.fn()
};

// Mock logger
jest.mock('../../Middleware/errorHandler', () => ({
  logger: {
    info: jest.fn(),
    warn: jest.fn(),
    error: jest.fn()
  }
}));

// Mock Firebase Storage Service
jest.mock('../../Services/firebaseStorageService', () => ({
  firebaseStorageService: mockFirebaseService
}));

const { StorageService } = require('../../Services/storageService');

describe('Storage Service Abstraction Layer Unit Tests', () => {
  let service;
  let mockFileBuffer;

  beforeEach(() => {
    jest.clearAllMocks();
    service = new StorageService();
    mockFileBuffer = Buffer.from('test file content');
    
    // Setup default mock implementations
    mockFirebaseService.uploadEventImage.mockResolvedValue('https://firebase.com/event-image.jpg');
    mockFirebaseService.uploadProfilePhoto.mockResolvedValue('https://firebase.com/profile.jpg');
    mockFirebaseService.uploadUserDocument.mockResolvedValue('https://firebase.com/document.pdf');
    mockFirebaseService.uploadCertificate.mockResolvedValue('https://firebase.com/certificate.pdf');
    mockFirebaseService.uploadInstitutionLogo.mockResolvedValue('https://firebase.com/logo.png');
    mockFirebaseService.deleteFile.mockResolvedValue(true);
    mockFirebaseService.listFiles.mockResolvedValue([]);
    mockFirebaseService.getFileMetadata.mockResolvedValue({ name: 'test.jpg' });
    mockFirebaseService.healthCheck.mockResolvedValue({ status: 'healthy' });
  });

  describe('StorageService Initialization', () => {
    it('should initialize with Firebase as default provider', () => {
      expect(service.defaultProvider).toBe('firebase');
      expect(service.currentProvider).toBe(mockFirebaseService);
    });

    it('should get provider info correctly', () => {
      const info = service.getProviderInfo();
      
      expect(info).toEqual({
        current: 'firebase',
        available: ['firebase'],
        initialized: true
      });
    });
  });

  describe('Provider Switching', () => {
    it('should switch providers successfully', () => {
      expect(() => service.switchProvider('firebase')).not.toThrow();
      expect(service.defaultProvider).toBe('firebase');
    });

    it('should throw error for invalid provider', () => {
      expect(() => service.switchProvider('invalid-provider')).toThrow(
        'Storage provider \'invalid-provider\' not available'
      );
    });
  });

  describe('uploadEventImage', () => {
    it('should upload event image successfully', async () => {
      const result = await service.uploadEventImage(
        mockFileBuffer,
        'logo.jpg',
        'logo',
        'image/jpeg'
      );

      expect(mockFirebaseService.uploadEventImage).toHaveBeenCalledWith(
        mockFileBuffer,
        'logo.jpg',
        'logo',
        'image/jpeg'
      );
      expect(result).toBe('https://firebase.com/event-image.jpg');
    });

    it('should handle upload errors', async () => {
      mockFirebaseService.uploadEventImage.mockRejectedValue(new Error('Upload failed'));

      await expect(
        service.uploadEventImage(mockFileBuffer, 'logo.jpg', 'logo', 'image/jpeg')
      ).rejects.toThrow('Upload failed');
    });
  });

  describe('uploadProfilePhoto', () => {
    it('should upload profile photo successfully', async () => {
      const result = await service.uploadProfilePhoto(
        mockFileBuffer,
        'avatar.jpg',
        'user123',
        'image/jpeg'
      );

      expect(mockFirebaseService.uploadProfilePhoto).toHaveBeenCalledWith(
        mockFileBuffer,
        'avatar.jpg',
        'user123',
        'image/jpeg'
      );
      expect(result).toBe('https://firebase.com/profile.jpg');
    });
  });

  describe('deleteFile', () => {
    it('should delete file successfully', async () => {
      const result = await service.deleteFile('https://firebase.com/test.jpg');

      expect(mockFirebaseService.deleteFile).toHaveBeenCalledWith('https://firebase.com/test.jpg');
      expect(result).toBe(true);
    });
  });

  describe('healthCheck', () => {
    it('should return health status successfully', async () => {
      const mockHealth = { status: 'healthy', message: 'All good' };
      mockFirebaseService.healthCheck.mockResolvedValue(mockHealth);

      const result = await service.healthCheck();

      expect(result).toEqual({
        ...mockHealth,
        provider: 'firebase',
        availableProviders: ['firebase']
      });
    });
  });

  describe('Future Features', () => {
    it('should throw error for unimplemented migration feature', async () => {
      await expect(
        service.migrateFiles('firebase', 'googleDrive', 'events/logos')
      ).rejects.toThrow('File migration feature not yet implemented');
    });

    it('should throw error for unimplemented backup feature', async () => {
      await expect(
        service.backupFiles('events/logos', 'googleDrive')
      ).rejects.toThrow('File backup feature not yet implemented');
    });
  });

  describe('Singleton Instance', () => {
    it('should export singleton instance functions', async () => {
      const { 
        uploadEventImage,
        uploadProfilePhoto,
        deleteFile,
        listFiles,
        healthCheck
      } = require('../../Services/storageService');

      // Test that exported functions work
      await uploadEventImage(mockFileBuffer, 'test.jpg', 'logo', 'image/jpeg');
      expect(mockFirebaseService.uploadEventImage).toHaveBeenCalled();

      await uploadProfilePhoto(mockFileBuffer, 'avatar.jpg', 'user123', 'image/jpeg');
      expect(mockFirebaseService.uploadProfilePhoto).toHaveBeenCalled();

      await deleteFile('https://test.com/file.jpg');
      expect(mockFirebaseService.deleteFile).toHaveBeenCalled();

      await listFiles('events/logos');
      expect(mockFirebaseService.listFiles).toHaveBeenCalled();

      await healthCheck();
      expect(mockFirebaseService.healthCheck).toHaveBeenCalled();
    });
  });
});