import { QueryClientProvider } from '@tanstack/react-query'
import { act, renderHook, waitFor } from '@testing-library/react-native'
import React from 'react'
import { buildTestQueryClient } from '../../__utils__/query_client'
import { ChatContext, ChatContextValue } from '../../contexts/chat_context'
import { ApiClient, useApiClient } from '../../hooks/use_api_client'
import { currentPersonQueryKey } from '../../hooks/use_current_person'
import { useDirectMessagesEligible } from '../../hooks/use_direct_messages_eligible'
import { Session } from '../../utils'

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

const mockedUseApiClient = useApiClient as jest.MockedFunction<typeof useApiClient>

let get: jest.Mock

const session = new Session({ token: { access_token: 'a-real-token' } })

const renderUseDirectMessagesEligible = (queryClient = buildTestQueryClient()) => {
  const wrapper = ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={queryClient}>
      <ChatContext.Provider value={{ session } as unknown as ChatContextValue}>
        {children}
      </ChatContext.Provider>
    </QueryClientProvider>
  )

  return { ...renderHook(() => useDirectMessagesEligible(), { wrapper }), queryClient }
}

beforeEach(() => {
  get = jest.fn().mockResolvedValue({ data: { id: 1, directMessagesEligible: true } })
  mockedUseApiClient.mockReturnValue({ chat: { get } } as unknown as ApiClient)
})

afterEach(() => {
  jest.clearAllMocks()
})

describe('useDirectMessagesEligible', () => {
  it('returns true once the person is fetched as eligible', async () => {
    get.mockResolvedValue({
      data: { id: 1, directMessagesEligible: true, directMessagesDisabled: true },
    })

    const { result } = renderUseDirectMessagesEligible()

    await waitFor(() => expect(result.current).toBe(true))
  })

  it('returns false when the attribute is absent from the response', async () => {
    get.mockResolvedValue({ data: { id: 1 } })

    const { result } = renderUseDirectMessagesEligible()

    await waitFor(() => expect(get).toHaveBeenCalled())
    // false is also the hook's return value before the fetch resolves, so a plain check here
    // could pass by coincidence against that early state. react-query schedules its update via
    // a real setTimeout, so this waits for that timer to actually fire before asserting the
    // settled value.
    await act(() => new Promise(resolve => setTimeout(resolve, 0)))

    expect(result.current).toBe(false)
  })

  it('reads the same /me cache entry as useCurrentPerson', () => {
    const queryClient = buildTestQueryClient()
    queryClient.setQueryData(currentPersonQueryKey, {
      data: { id: 1, directMessagesEligible: true },
    })

    const { result } = renderUseDirectMessagesEligible(queryClient)

    expect(result.current).toBe(true)
  })
})