import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { compareDucksTool } from '../../src/tools/compare-ducks.js';
import { ProviderManager } from '../../src/providers/manager.js';

// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/providers/manager.js');

describe('compareDucksTool structured JSON', () => {
  let mockProviderManager: jest.Mocked<ProviderManager>;

  const mockResponses = [
    {
      provider: 'openai',
      nickname: 'OpenAI Duck',
      content: 'TypeScript is great!',
      model: 'gpt-4',
      latency: 150,

      usage: {
        prompt_tokens: 10,
        completion_tokens: 20,
        total_tokens: 30,
      },
    },
    {
      provider: 'groq',
      nickname: 'Groq Duck',
      content: 'TypeScript rocks!',
      model: 'llama-3.1-70b',
      latency: 80,

      usage: {
        prompt_tokens: 10,
        completion_tokens: 15,
        total_tokens: 25,
      },
    },
  ];

  beforeEach(() => {
    mockProviderManager = {
      compareDucks: jest.fn().mockResolvedValue(mockResponses),
    } as unknown as jest.Mocked<ProviderManager>;
  });

  it('should return two content items: text and JSON', async () => {
    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });

    expect(result.content).toHaveLength(2);
    expect(result.content[0].type).toBe('text');
    expect(result.content[1].type).toBe('text');
  });

  it('should have valid JSON in the second content item', async () => {
    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });

    const data = JSON.parse(result.content[1].text) as unknown[];
    expect(Array.isArray(data)).toBe(true);
  });

  it('should include all provider data in JSON', async () => {
    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });

    const data = JSON.parse(result.content[1].text) as {
      provider: string;
      nickname: string;
      model: string;
      content: string;
      latency: number;
      tokens: { prompt: number; completion: number; total: number } | null;
      error?: string;
    }[];

    expect(data).toHaveLength(2);
    expect(data[0].provider).toBe('openai');
    expect(data[0].nickname).toBe('OpenAI Duck');
    expect(data[0].model).toBe('gpt-4');
    expect(data[0].content).toBe('TypeScript is great!');
    expect(data[0].latency).toBe(150);
    expect(data[0].tokens).toEqual({ prompt: 10, completion: 20, total: 30 });

    expect(data[1].provider).toBe('groq');
  });

  it('should include error info for failed responses', async () => {
    mockProviderManager.compareDucks.mockResolvedValue([
      mockResponses[0],
      {
        provider: 'groq',
        nickname: 'Groq Duck',
        content: 'Error: API key invalid',
        model: '',
        latency: 0,
  
      },
    ]);

    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
    const data = JSON.parse(result.content[1].text) as { error?: string }[];

    expect(data[0].error).toBeUndefined();
    expect(data[1].error).toBe('Error: API key invalid');
  });

  it('should handle null tokens when usage is missing', async () => {
    mockProviderManager.compareDucks.mockResolvedValue([
      {
        provider: 'openai',
        nickname: 'OpenAI Duck',
        content: 'Response',
        model: 'gpt-4',
        latency: 100,
  
      },
    ]);

    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
    const data = JSON.parse(result.content[1].text) as { tokens: unknown }[];

    expect(data[0].tokens).toBeNull();
  });

  it('should preserve text content identical to before', async () => {
    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });

    // First item is text, should contain original format
    expect(result.content[0].text).toContain('OpenAI Duck');
    expect(result.content[0].text).toContain('Groq Duck');
    expect(result.content[0].text).toContain('2/2 ducks responded successfully');
  });
});