import { MediaGenerationService } from './MediaGenerationService';

describe('MediaGenerationService', () => {
  let service: MediaGenerationService;

  beforeEach(() => {
    service = new MediaGenerationService();
  });

  describe('generateTeamLogo', () => {
    it('generates a deterministic logo URL for a team', () => {
      const url1 = service.generateTeamLogo('team-123');
      const url2 = service.generateTeamLogo('team-123');

      expect(url1).toBe(url2);
      expect(url1).toContain('https://picsum.photos/seed/team-123/200/200');
    });

    it('generates different URLs for different team IDs', () => {
      const url1 = service.generateTeamLogo('team-123');
      const url2 = service.generateTeamLogo('team-456');

      expect(url1).not.toBe(url2);
    });

    it('generates URL with correct format', () => {
      const url = service.generateTeamLogo('team-123');

      expect(url).toMatch(/^https:\/\/picsum\.photos\/seed\/team-123\/200\/200$/);
    });
  });

  describe('generateLeagueLogo', () => {
    it('generates a deterministic logo URL for a league', () => {
      const url1 = service.generateLeagueLogo('league-123');
      const url2 = service.generateLeagueLogo('league-123');

      expect(url1).toBe(url2);
      expect(url1).toContain('https://picsum.photos/seed/l-league-123/200/200');
    });

    it('generates different URLs for different league IDs', () => {
      const url1 = service.generateLeagueLogo('league-123');
      const url2 = service.generateLeagueLogo('league-456');

      expect(url1).not.toBe(url2);
    });

    it('generates URL with correct format', () => {
      const url = service.generateLeagueLogo('league-123');

      expect(url).toMatch(/^https:\/\/picsum\.photos\/seed\/l-league-123\/200\/200$/);
    });
  });

  describe('generateDriverAvatar', () => {
    it('generates a deterministic avatar URL for a driver', () => {
      const url1 = service.generateDriverAvatar('driver-123');
      const url2 = service.generateDriverAvatar('driver-123');

      expect(url1).toBe(url2);
      expect(url1).toContain('https://i.pravatar.cc/150?u=driver-123');
    });

    it('generates different URLs for different driver IDs', () => {
      const url1 = service.generateDriverAvatar('driver-123');
      const url2 = service.generateDriverAvatar('driver-456');

      expect(url1).not.toBe(url2);
    });

    it('generates URL with correct format', () => {
      const url = service.generateDriverAvatar('driver-123');

      expect(url).toMatch(/^https:\/\/i\.pravatar\.cc\/150\?u=driver-123$/);
    });
  });

  describe('generateLeagueCover', () => {
    it('generates a deterministic cover URL for a league', () => {
      const url1 = service.generateLeagueCover('league-123');
      const url2 = service.generateLeagueCover('league-123');

      expect(url1).toBe(url2);
      expect(url1).toContain('https://picsum.photos/seed/c-league-123/800/200');
    });

    it('generates different URLs for different league IDs', () => {
      const url1 = service.generateLeagueCover('league-123');
      const url2 = service.generateLeagueCover('league-456');

      expect(url1).not.toBe(url2);
    });

    it('generates URL with correct format', () => {
      const url = service.generateLeagueCover('league-123');

      expect(url).toMatch(/^https:\/\/picsum\.photos\/seed\/c-league-123\/800\/200$/);
    });
  });

  describe('generateDefaultPNG', () => {
    it('generates a PNG buffer for a variant', () => {
      const buffer = service.generateDefaultPNG('test-variant');

      expect(buffer).toBeInstanceOf(Buffer);
      expect(buffer.length).toBeGreaterThan(0);
    });

    it('generates deterministic PNG for same variant', () => {
      const buffer1 = service.generateDefaultPNG('test-variant');
      const buffer2 = service.generateDefaultPNG('test-variant');

      expect(buffer1.equals(buffer2)).toBe(true);
    });

    it('generates different PNGs for different variants', () => {
      const buffer1 = service.generateDefaultPNG('variant-1');
      const buffer2 = service.generateDefaultPNG('variant-2');

      expect(buffer1.equals(buffer2)).toBe(false);
    });

    it('generates valid PNG header', () => {
      const buffer = service.generateDefaultPNG('test-variant');

      // PNG signature: 89 50 4E 47 0D 0A 1A 0A
      expect(buffer[0]).toBe(0x89);
      expect(buffer[1]).toBe(0x50); // 'P'
      expect(buffer[2]).toBe(0x4E); // 'N'
      expect(buffer[3]).toBe(0x47); // 'G'
      expect(buffer[4]).toBe(0x0D);
      expect(buffer[5]).toBe(0x0A);
      expect(buffer[6]).toBe(0x1A);
      expect(buffer[7]).toBe(0x0A);
    });

    it('generates PNG with IHDR chunk', () => {
      const buffer = service.generateDefaultPNG('test-variant');

      // IHDR chunk starts at byte 8
      // Length: 13 (0x00 0x00 0x00 0x0D)
      expect(buffer[8]).toBe(0x00);
      expect(buffer[9]).toBe(0x00);
      expect(buffer[10]).toBe(0x00);
      expect(buffer[11]).toBe(0x0D);
      // Type: IHDR (0x49 0x48 0x44 0x52)
      expect(buffer[12]).toBe(0x49); // 'I'
      expect(buffer[13]).toBe(0x48); // 'H'
      expect(buffer[14]).toBe(0x44); // 'D'
      expect(buffer[15]).toBe(0x52); // 'R'
    });

    it('generates PNG with 1x1 dimensions', () => {
      const buffer = service.generateDefaultPNG('test-variant');

      // Width: 1 (0x00 0x00 0x00 0x01) at byte 16
      expect(buffer[16]).toBe(0x00);
      expect(buffer[17]).toBe(0x00);
      expect(buffer[18]).toBe(0x00);
      expect(buffer[19]).toBe(0x01);
      // Height: 1 (0x00 0x00 0x00 0x01) at byte 20
      expect(buffer[20]).toBe(0x00);
      expect(buffer[21]).toBe(0x00);
      expect(buffer[22]).toBe(0x00);
      expect(buffer[23]).toBe(0x01);
    });

    it('generates PNG with RGB color type', () => {
      const buffer = service.generateDefaultPNG('test-variant');

      // Color type: RGB (0x02) at byte 25
      expect(buffer[25]).toBe(0x02);
    });

    it('generates PNG with RGB pixel data', () => {
      const buffer = service.generateDefaultPNG('test-variant');

      // RGB pixel data should be present in IDAT chunk
      // IDAT chunk starts after IHDR (byte 37)
      // We should find RGB values somewhere in the buffer
      const hasRGB = buffer.some((byte, index) => {
        // Check if we have a sequence that looks like RGB data
        // This is a simplified check
        return index > 37 && index < buffer.length - 10;
      });

      expect(hasRGB).toBe(true);
    });
  });

  describe('deterministic generation', () => {
    it('generates same team logo for same team ID across different instances', () => {
      const service1 = new MediaGenerationService();
      const service2 = new MediaGenerationService();

      const url1 = service1.generateTeamLogo('team-123');
      const url2 = service2.generateTeamLogo('team-123');

      expect(url1).toBe(url2);
    });

    it('generates same driver avatar for same driver ID across different instances', () => {
      const service1 = new MediaGenerationService();
      const service2 = new MediaGenerationService();

      const url1 = service1.generateDriverAvatar('driver-123');
      const url2 = service2.generateDriverAvatar('driver-123');

      expect(url1).toBe(url2);
    });

    it('generates same PNG for same variant across different instances', () => {
      const service1 = new MediaGenerationService();
      const service2 = new MediaGenerationService();

      const buffer1 = service1.generateDefaultPNG('test-variant');
      const buffer2 = service2.generateDefaultPNG('test-variant');

      expect(buffer1.equals(buffer2)).toBe(true);
    });
  });
});