import { describe, it, expect, beforeEach } from 'vitest';
import { MediaTestContext } from '../MediaTestContext';
import { Media } from '@core/media/domain/entities/Media';
import type { MulterFile } from '@core/media/application/use-cases/UploadMediaUseCase';

describe('General Media Management: Upload, Retrieval, and Deletion', () => {
  let ctx: MediaTestContext;

  beforeEach(() => {
    ctx = MediaTestContext.create();
    ctx.reset();
  });

  const createMockFile = (filename: string, mimeType: string, content: Buffer): MulterFile => ({
    fieldname: 'file',
    originalname: filename,
    encoding: '7bit',
    mimetype: mimeType,
    size: content.length,
    buffer: content,
    stream: null as any,
    destination: '',
    filename: filename,
    path: '',
  });

  describe('UploadMediaUseCase', () => {
    it('should upload media successfully', async () => {
      const content = Buffer.from('test content');
      const file = createMockFile('test.png', 'image/png', content);

      const result = await ctx.uploadMediaUseCase.execute({
        file,
        uploadedBy: 'user-1',
      });

      expect(result.isOk()).toBe(true);
      const successResult = result.unwrap();
      expect(successResult.mediaId).toBeDefined();
      expect(successResult.url).toBeDefined();

      const media = await ctx.mediaRepository.findById(successResult.mediaId);
      expect(media).not.toBeNull();
      expect(media?.filename).toBe('test.png');
    });
  });

  describe('GetMediaUseCase', () => {
    it('should retrieve media by ID', async () => {
      const media = Media.create({
        id: 'media-1',
        filename: 'test.png',
        originalName: 'test.png',
        mimeType: 'image/png',
        size: 100,
        url: 'https://example.com/test.png',
        type: 'image',
        uploadedBy: 'user-1',
      });
      await ctx.mediaRepository.save(media);

      const result = await ctx.getMediaUseCase.execute({ mediaId: 'media-1' });

      expect(result.isOk()).toBe(true);
      const successResult = result.unwrap();
      expect(successResult.media.id).toBe('media-1');
    });

    it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
      const result = await ctx.getMediaUseCase.execute({ mediaId: 'non-existent' });

      expect(result.isErr()).toBe(true);
      expect(result.unwrapErr().code).toBe('MEDIA_NOT_FOUND');
    });
  });

  describe('GetUploadedMediaUseCase', () => {
    it('should retrieve uploaded media content', async () => {
      const uploadResult = await ctx.mediaStorage.uploadMedia(
        Buffer.from('test content'),
        { filename: 'test.png', mimeType: 'image/png' }
      );
      const storageKey = uploadResult.url!;

      const result = await ctx.getUploadedMediaUseCase.execute({ storageKey });

      expect(result.isOk()).toBe(true);
      const successResult = result.unwrap();
      expect(successResult?.bytes.toString()).toBe('test content');
      expect(successResult?.contentType).toBe('image/png');
    });

    it('should return null when media does not exist in storage', async () => {
      const result = await ctx.getUploadedMediaUseCase.execute({ storageKey: 'non-existent' });

      expect(result.isOk()).toBe(true);
      expect(result.unwrap()).toBeNull();
    });
  });

  describe('DeleteMediaUseCase', () => {
    it('should delete media file and repository entry', async () => {
      const uploadResult = await ctx.mediaStorage.uploadMedia(
        Buffer.from('test content'),
        { filename: 'test.png', mimeType: 'image/png' }
      );
      const storageKey = uploadResult.url!;

      const media = Media.create({
        id: 'media-1',
        filename: 'test.png',
        originalName: 'test.png',
        mimeType: 'image/png',
        size: 12,
        url: storageKey,
        type: 'image',
        uploadedBy: 'user-1',
      });
      await ctx.mediaRepository.save(media);

      const result = await ctx.deleteMediaUseCase.execute({ mediaId: 'media-1' });

      expect(result.isOk()).toBe(true);
      expect(result.unwrap().deleted).toBe(true);

      const deletedMedia = await ctx.mediaRepository.findById('media-1');
      expect(deletedMedia).toBeNull();

      const storageExists = ctx.mediaStorage.has(storageKey);
      expect(storageExists).toBe(false);
    });

    it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
      const result = await ctx.deleteMediaUseCase.execute({ mediaId: 'non-existent' });

      expect(result.isErr()).toBe(true);
      expect(result.unwrapErr().code).toBe('MEDIA_NOT_FOUND');
    });
  });
});