/**
 * Tests for the shared queryRAG utility.
 */

import { describe, it, expect, beforeEach, vi } from 'vitest'

// Mock fetch globally
const mockFetch = vi.fn()
vi.stubGlobal('fetch', mockFetch)

describe('queryRAG', () => {
  let queryRAG: (query: string, topK?: number, collection?: string) => Promise<string>

  beforeEach(async () => {
    vi.resetModules()
    mockFetch.mockReset()
    // Dynamic import to pick up fresh env
    const mod = await import('../rag-query')
    queryRAG = mod.queryRAG
  })

  it('should return formatted results on success', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        results: [
          { source_name: 'DSGVO', content: 'Art. 35 regelt die DSFA...' },
          { source_code: 'EU_2016_679', content: 'Risikobewertung erforderlich' },
        ],
      }),
    })

    const result = await queryRAG('DSFA Art. 35')

    expect(result).toContain('[Quelle 1: DSGVO]')
    expect(result).toContain('Art. 35 regelt die DSFA...')
    expect(result).toContain('[Quelle 2: EU_2016_679]')
    expect(mockFetch).toHaveBeenCalledTimes(1)
  })

  it('should send POST request to RAG_SERVICE_URL', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({ results: [] }),
    })

    await queryRAG('test query')

    expect(mockFetch).toHaveBeenCalledWith(
      expect.stringContaining('/api/v1/search'),
      expect.objectContaining({
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
      })
    )
  })

  it('should include collection in request body when provided', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({ results: [] }),
    })

    await queryRAG('test query', 3, 'bp_dsfa_corpus')

    const callArgs = mockFetch.mock.calls[0]
    const body = JSON.parse(callArgs[1].body)
    expect(body.collection).toBe('bp_dsfa_corpus')
    expect(body.query).toBe('test query')
    expect(body.top_k).toBe(3)
  })

  it('should omit collection from body when not provided', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({ results: [] }),
    })

    await queryRAG('test query')

    const callArgs = mockFetch.mock.calls[0]
    const body = JSON.parse(callArgs[1].body)
    expect(body.collection).toBeUndefined()
    expect(body.query).toBe('test query')
    expect(body.top_k).toBe(3)
  })

  it('should pass custom topK in request body', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({ results: [] }),
    })

    await queryRAG('test query', 7)

    const callArgs = mockFetch.mock.calls[0]
    const body = JSON.parse(callArgs[1].body)
    expect(body.top_k).toBe(7)
  })

  it('should return empty string on HTTP error', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: false,
      status: 500,
    })

    const result = await queryRAG('test query')

    expect(result).toBe('')
  })

  it('should return empty string on network error', async () => {
    mockFetch.mockRejectedValueOnce(new Error('Connection refused'))

    const result = await queryRAG('test query')

    expect(result).toBe('')
  })

  it('should return empty string when no results', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({ results: [] }),
    })

    const result = await queryRAG('test query')

    expect(result).toBe('')
  })

  it('should handle results with missing fields gracefully', async () => {
    mockFetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({
        results: [
          { content: 'Some content without source' },
        ],
      }),
    })

    const result = await queryRAG('test')

    expect(result).toContain('[Quelle 1: Unbekannt]')
    expect(result).toContain('Some content without source')
  })
})