import { beforeEach, describe, expect, it, vi } from 'vitest';
import { ThrottleQueueManager } from './throttleQueueManager';
import type { ISbThrottledRequest } from './interfaces';

describe('throttleQueueManager', () => {
  let mockThrottledRequest: ISbThrottledRequest;
  let manager: ThrottleQueueManager;

  beforeEach(() => {
    mockThrottledRequest = vi.fn(async () => ({ data: 'test' }));
    manager = new ThrottleQueueManager(mockThrottledRequest, 1000);
  });

  describe('initialization', () => {
    it('should create a manager with no queues initially', () => {
      expect(manager.getQueueCount()).toBe(0);
    });

    it('should accept custom interval', () => {
      const customManager = new ThrottleQueueManager(mockThrottledRequest, 500);
      expect(customManager).toBeDefined();
      expect(customManager.getQueueCount()).toBe(0);
    });
  });

  describe('queue creation', () => {
    it('should create a queue on first request with specific rate limit', async () => {
      const promise = manager.execute(50, 'get', '/test', {});
      expect(manager.getQueueCount()).toBe(1);

      try {
        await promise;
      }
      catch {
        // Expected to fail with mock
      }
    });

    it('should reuse existing queue for same rate limit', async () => {
      const promise1 = manager.execute(50, 'get', '/test1', {});
      const promise2 = manager.execute(50, 'get', '/test2', {});

      expect(manager.getQueueCount()).toBe(1);

      try {
        await Promise.all([promise1, promise2]);
      }
      catch {
        // Expected to fail with mock
      }
    });

    it('should create separate queues for different rate limits', async () => {
      const promise1 = manager.execute(50, 'get', '/test1', {});
      const promise2 = manager.execute(1000, 'get', '/test2', {});
      const promise3 = manager.execute(15, 'get', '/test3', {});

      expect(manager.getQueueCount()).toBe(3);

      try {
        await Promise.all([promise1, promise2, promise3]);
      }
      catch {
        // Expected to fail with mock
      }
    });

    it('should maintain separate queues for different rate limits over multiple calls', async () => {
      // First batch
      await manager.execute(50, 'get', '/test1', {}).catch(() => {});
      await manager.execute(1000, 'get', '/test2', {}).catch(() => {});

      expect(manager.getQueueCount()).toBe(2);

      // Second batch - should reuse existing queues
      await manager.execute(50, 'get', '/test3', {}).catch(() => {});
      await manager.execute(1000, 'get', '/test4', {}).catch(() => {});

      expect(manager.getQueueCount()).toBe(2);
    });
  });

  describe('request execution', () => {
    it('should pass arguments to throttled request function', async () => {
      await manager.execute(50, 'get', '/test', { version: 'draft' }).catch(() => {});

      expect(mockThrottledRequest).toHaveBeenCalledWith(
        'get',
        '/test',
        { version: 'draft' },
      );
    });

    it('should pass all arguments including fetchOptions', async () => {
      const fetchOptions = { headers: { 'Custom-Header': 'value' } };
      await manager.execute(50, 'get', '/test', { version: 'draft' }, fetchOptions).catch(() => {});

      expect(mockThrottledRequest).toHaveBeenCalledWith(
        'get',
        '/test',
        { version: 'draft' },
        fetchOptions,
      );
    });

    it('should return promise from throttled request', async () => {
      const mockResponse = { data: 'response' };
      mockThrottledRequest = vi.fn(async () => mockResponse);
      manager = new ThrottleQueueManager(mockThrottledRequest, 1000);

      const result = await manager.execute(50, 'get', '/test', {});
      expect(result).toEqual(mockResponse);
    });

    it('should handle errors from throttled request', async () => {
      const error = new Error('Request failed');
      mockThrottledRequest = vi.fn(async () => {
        throw error;
      });
      manager = new ThrottleQueueManager(mockThrottledRequest, 1000);

      await expect(manager.execute(50, 'get', '/test', {})).rejects.toThrow('Request failed');
    });
  });

  describe('queue isolation', () => {
    it('should process requests with different rate limits independently', async () => {
      const calls: string[] = [];

      mockThrottledRequest = vi.fn(async (method, url) => {
        calls.push(url);
        await new Promise(resolve => setTimeout(resolve, 50));
        return { data: url };
      });

      manager = new ThrottleQueueManager(mockThrottledRequest, 100);

      // Start requests with different rate limits
      const promises = [
        manager.execute(1000, 'get', '/fast1', {}),
        manager.execute(1000, 'get', '/fast2', {}),
        manager.execute(1, 'get', '/slow1', {}),
        manager.execute(1, 'get', '/slow2', {}),
      ];

      await Promise.all(promises);

      // Fast requests should not be affected by slow rate limit
      expect(calls).toHaveLength(4);
      expect(calls).toContain('/fast1');
      expect(calls).toContain('/fast2');
      expect(calls).toContain('/slow1');
      expect(calls).toContain('/slow2');
    });
  });

  describe('abortAll', () => {
    it('should abort all queues', () => {
      manager.execute(50, 'get', '/test1', {}).catch(() => {});
      manager.execute(1000, 'get', '/test2', {}).catch(() => {});
      manager.execute(15, 'get', '/test3', {}).catch(() => {});

      expect(manager.getQueueCount()).toBe(3);

      manager.abortAll();

      expect(manager.getQueueCount()).toBe(0);
    });

    it('should clear all queues after abort', () => {
      manager.execute(50, 'get', '/test1', {}).catch(() => {});
      manager.execute(1000, 'get', '/test2', {}).catch(() => {});

      manager.abortAll();

      expect(manager.getQueueCount()).toBe(0);
    });

    it('should allow creating new queues after abort', async () => {
      manager.execute(50, 'get', '/test1', {}).catch(() => {});
      manager.abortAll();

      expect(manager.getQueueCount()).toBe(0);

      await manager.execute(100, 'get', '/test2', {}).catch(() => {});

      expect(manager.getQueueCount()).toBe(1);
    });
  });

  describe('common rate limit scenarios', () => {
    it('should handle typical cached request rate limit (1000 req/s)', async () => {
      await manager.execute(1000, 'get', '/cached', { version: 'published' }).catch(() => {});

      expect(manager.getQueueCount()).toBe(1);
      expect(mockThrottledRequest).toHaveBeenCalled();
    });

    it('should handle typical uncached request rate limits', async () => {
      // Small listing - 50 req/s
      await manager.execute(50, 'get', '/draft-small', { version: 'draft', per_page: 25 }).catch(() => {});

      // Medium listing - 15 req/s
      await manager.execute(15, 'get', '/draft-medium', { version: 'draft', per_page: 40 }).catch(() => {});

      // Large listing - 10 req/s
      await manager.execute(10, 'get', '/draft-large', { version: 'draft', per_page: 60 }).catch(() => {});

      // Very large listing - 6 req/s
      await manager.execute(6, 'get', '/draft-xlarge', { version: 'draft', per_page: 100 }).catch(() => {});

      expect(manager.getQueueCount()).toBe(4);
    });

    it('should handle mixed cached and uncached requests', async () => {
      const promises = [
        manager.execute(1000, 'get', '/cached1', { version: 'published' }),
        manager.execute(50, 'get', '/draft1', { version: 'draft' }),
        manager.execute(1000, 'get', '/cached2', { version: 'published' }),
        manager.execute(50, 'get', '/draft2', { version: 'draft' }),
      ];

      await Promise.allSettled(promises);

      // Should have 2 queues: one for 1000 req/s, one for 50 req/s
      expect(manager.getQueueCount()).toBe(2);
    });
  });
});