/*!
 * @license
 * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
 */

import { Logger } from '@squiz/dx-logger-lib';
import fsp from 'fs/promises';
import { cleanupTmpDir } from './cleanup';

jest.mock('fs/promises', () => ({
  rm: jest.fn(),
}));

describe('cleanup', () => {
  let mockLogger: Logger;
  const mockRm = fsp.rm as jest.MockedFunction<typeof fsp.rm>;

  beforeEach(() => {
    jest.clearAllMocks();
    mockLogger = {
      error: jest.fn(),
      info: jest.fn(),
      warn: jest.fn(),
      debug: jest.fn(),
    } as any;
  });

  describe('cleanupTmpDir', () => {
    const testTmpDir = '/tmp/test-directory';

    it('should successfully remove directory', async () => {
      mockRm.mockResolvedValue(undefined);

      await cleanupTmpDir(testTmpDir, mockLogger);

      expect(mockRm).toHaveBeenCalledWith(testTmpDir, {
        force: true,
        recursive: true,
      });
      expect(mockLogger.error).not.toHaveBeenCalled();
    });

    it('should log error when directory removal fails', async () => {
      const mockError = new Error('Permission denied');
      mockRm.mockRejectedValue(mockError);

      await cleanupTmpDir(testTmpDir, mockLogger);

      expect(mockRm).toHaveBeenCalledWith(testTmpDir, {
        force: true,
        recursive: true,
      });
      expect(mockLogger.error).toHaveBeenCalledWith('failed to remove temp directory', mockError);
    });

    it('should handle ENOENT error gracefully', async () => {
      const enoentError = new Error('ENOENT: no such file or directory');
      (enoentError as any).code = 'ENOENT';
      mockRm.mockRejectedValue(enoentError);

      await cleanupTmpDir(testTmpDir, mockLogger);

      expect(mockRm).toHaveBeenCalledWith(testTmpDir, {
        force: true,
        recursive: true,
      });
      expect(mockLogger.error).toHaveBeenCalledWith('failed to remove temp directory', enoentError);
    });

    it('should handle system permission errors', async () => {
      const permissionError = new Error('EACCES: permission denied');
      (permissionError as any).code = 'EACCES';
      mockRm.mockRejectedValue(permissionError);

      await cleanupTmpDir(testTmpDir, mockLogger);

      expect(mockRm).toHaveBeenCalledWith(testTmpDir, {
        force: true,
        recursive: true,
      });
      expect(mockLogger.error).toHaveBeenCalledWith('failed to remove temp directory', permissionError);
    });

    it('should handle empty directory path', async () => {
      mockRm.mockResolvedValue(undefined);

      await cleanupTmpDir('', mockLogger);

      expect(mockRm).toHaveBeenCalledWith('', {
        force: true,
        recursive: true,
      });
      expect(mockLogger.error).not.toHaveBeenCalled();
    });

    it('should handle directory path with special characters', async () => {
      const specialPath = '/tmp/test dir with spaces & symbols!@#';
      mockRm.mockResolvedValue(undefined);

      await cleanupTmpDir(specialPath, mockLogger);

      expect(mockRm).toHaveBeenCalledWith(specialPath, {
        force: true,
        recursive: true,
      });
      expect(mockLogger.error).not.toHaveBeenCalled();
    });
  });
});