import { PriorityQueue } from '../PriorityQueue';

interface Edge {
  vertex: string;
  weight: number;
}

describe('PriorityQueue', () => {
  it('throws and error when comparator function is not provided', () => {
    expect(() => new PriorityQueue<number>()).toThrowError();
  });

  it('creates empty queue when initialized with a comparator', () => {
    const queue = new PriorityQueue<number>(
      (a: number, b: number): number => a - b
    );
    expect(queue.isEmpty()).toBe(true);
    expect(queue.size()).toBe(0);
  });

  it('return null for top element when queue is empty', () => {
    const queue = new PriorityQueue<number>(
      (a: number, b: number): number => a - b
    );
    expect(queue.peek()).toBeNull();
    expect(queue.dequeue()).toBeNull();
  });

  it('implements min heap correctly', () => {
    const queue = new PriorityQueue<number>(
      (a: number, b: number): number => a - b
    );
    queue.enqueue(3);
    queue.enqueue(2);
    queue.enqueue(1);
    expect(queue.isEmpty()).toBe(false);
    expect(queue.size()).toBe(3);
    expect(queue.peek()).toBe(1);
    expect(queue.dequeue()).toBe(1);
    expect(queue.size()).toBe(2);
  });

  it('implements max heap correctly', () => {
    const queue = new PriorityQueue<number>(
      (a: number, b: number): number => b - a
    );
    queue.enqueue(1);
    queue.enqueue(2);
    queue.enqueue(3);
    expect(queue.isEmpty()).toBe(false);
    expect(queue.size()).toBe(3);
    expect(queue.peek()).toBe(3);
    expect(queue.dequeue()).toBe(3);
    expect(queue.size()).toBe(2);
  });

  it('works properly with custom shapes', () => {
    const queue = new PriorityQueue<Edge>(
      (a: Edge, b: Edge): number => a.weight - b.weight
    );
    queue.enqueue({ vertex: 'A', weight: 2 });
    queue.enqueue({ vertex: 'B', weight: 6 });
    queue.enqueue({ vertex: 'C', weight: 1 });
    queue.enqueue({ vertex: 'D', weight: 3 });
    expect(queue.isEmpty()).toBe(false);
    expect(queue.size()).toBe(4);
    expect(queue.dequeue().vertex).toBe('C');
  });
});