import { describe, it, expect, beforeAll, afterEach, afterAll } from 'vitest';
import { setupServer } from 'msw/node';
import { http, HttpResponse } from 'msw';
import { getStats } from '@/api/stats';

const mockStats = [
  {
    id: 1,
    provider_id: 'prov-1',
    model_name: 'gpt-4',
    request_count: 100,
    date: '2025-01-15',
  },
  {
    id: 2,
    provider_id: 'prov-2',
    model_name: 'claude-3',
    request_count: 50,
    date: '2025-01-16',
  },
];

describe('stats API', () => {
  const server = setupServer();

  beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }));
  afterEach(() => server.resetHandlers());
  afterAll(() => server.close());

  describe('getStats', () => {
    it('calls /api/stats without params', async () => {
      let receivedUrl: string | null = null;

      server.use(
        http.get('/api/stats', ({ request }) => {
          receivedUrl = request.url;
          return HttpResponse.json(mockStats);
        }),
      );

      const result = await getStats();

      expect(receivedUrl).toMatch(/\/api\/stats$/);
      expect(result).toEqual([
        {
          id: 1,
          providerId: 'prov-1',
          modelName: 'gpt-4',
          requestCount: 100,
          date: '2025-01-15',
        },
        {
          id: 2,
          providerId: 'prov-2',
          modelName: 'claude-3',
          requestCount: 50,
          date: '2025-01-16',
        },
      ]);
    });

    it('builds correct query string with snake_case keys when params are provided', async () => {
      let receivedUrl: string | null = null;

      server.use(
        http.get('/api/stats', ({ request }) => {
          receivedUrl = request.url;
          return HttpResponse.json([]);
        }),
      );

      await getStats({
        providerId: 'prov-1',
        modelName: 'gpt-4',
        startDate: '2025-01-01',
        endDate: '2025-01-31',
      });

      expect(receivedUrl).toContain('provider_id=prov-1');
      expect(receivedUrl).toContain('model_name=gpt-4');
      expect(receivedUrl).toContain('start_date=2025-01-01');
      expect(receivedUrl).toContain('end_date=2025-01-31');
    });

    it('omits undefined params from query string', async () => {
      let receivedUrl: string | null = null;

      server.use(
        http.get('/api/stats', ({ request }) => {
          receivedUrl = request.url;
          return HttpResponse.json([]);
        }),
      );

      await getStats({
        providerId: 'prov-1',
      });

      expect(receivedUrl).toContain('provider_id=prov-1');
      expect(receivedUrl).not.toContain('model_name');
      expect(receivedUrl).not.toContain('start_date');
      expect(receivedUrl).not.toContain('end_date');
    });

    it('returns UsageStats array with camelCase keys', async () => {
      server.use(
        http.get('/api/stats', () => {
          return HttpResponse.json(mockStats);
        }),
      );

      const result = await getStats();

      expect(result).toHaveLength(2);
      expect(result[0]).toEqual({
        id: 1,
        providerId: 'prov-1',
        modelName: 'gpt-4',
        requestCount: 100,
        date: '2025-01-15',
      });
      expect(result[1]).toEqual({
        id: 2,
        providerId: 'prov-2',
        modelName: 'claude-3',
        requestCount: 50,
        date: '2025-01-16',
      });
    });
  });
});