import { QueryClientProvider } from '@tanstack/react-query'
import { renderHook, waitFor } from '@testing-library/react-native'
import React from 'react'
import { buildTestQueryClient } from '../../__utils__/query_client'
import { useApiClient } from '../../hooks/use_api_client'
import { useEnrichPeople } from '../../hooks/use_enrich_people'

jest.mock('../../hooks/use_api_client')

const mockedUseApiClient = useApiClient as jest.MockedFunction<typeof useApiClient>
const mockPost = jest.fn()

beforeEach(() => {
  mockPost.mockReset()
  mockedUseApiClient.mockReturnValue({ chat: { post: mockPost } } as any)
})

const createWrapper = () => {
  const queryClient = buildTestQueryClient()
  return ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
  )
}

test('returns empty map and skips the request when personIds is empty', () => {
  const { result } = renderHook(() => useEnrichPeople({ personIds: [] }), {
    wrapper: createWrapper(),
  })

  expect(result.current.size).toBe(0)
  expect(mockPost).not.toHaveBeenCalled()
})

test('returns enrichment data keyed by person id', async () => {
  mockPost.mockResolvedValue({
    data: [
      { id: '1', type: 'PersonEnrichment', badges: [{ title: 'Leader' }] },
      { id: '2', type: 'PersonEnrichment', badges: [] },
    ],
  })

  const { result } = renderHook(() => useEnrichPeople({ personIds: [1, 2] }), {
    wrapper: createWrapper(),
  })

  await waitFor(() => expect(result.current.size).toBe(2))

  expect(result.current.get(1)?.badges).toEqual([{ title: 'Leader' }])
  expect(result.current.get(2)?.badges).toEqual([])
})

test('includes group_id in the request when provided', async () => {
  mockPost.mockResolvedValue({ data: [] })

  renderHook(() => useEnrichPeople({ personIds: [1], groupId: 42 }), {
    wrapper: createWrapper(),
  })

  await waitFor(() => expect(mockPost).toHaveBeenCalled())

  expect(mockPost).toHaveBeenCalledWith(
    expect.objectContaining({
      data: expect.objectContaining({
        data: expect.objectContaining({
          attributes: expect.objectContaining({ group_id: 42 }),
        }),
      }),
    })
  )
})

test('omits group_id from the request when not provided', async () => {
  mockPost.mockResolvedValue({ data: [] })

  renderHook(() => useEnrichPeople({ personIds: [1] }), {
    wrapper: createWrapper(),
  })

  await waitFor(() => expect(mockPost).toHaveBeenCalled())

  const attributes = mockPost.mock.calls[0][0].data.data.attributes
  expect(attributes).not.toHaveProperty('group_id')
})

test('returns empty map when the request fails', async () => {
  mockPost.mockRejectedValue(new Error('network error'))

  const { result } = renderHook(() => useEnrichPeople({ personIds: [1] }), {
    wrapper: createWrapper(),
  })

  await waitFor(() => expect(mockPost).toHaveBeenCalled())

  expect(result.current.size).toBe(0)
})