import React from 'react'
import { act, create } from 'react-test-renderer'

const mockResume = jest.fn()
const mockClearAll = jest.fn()
const mockClearUser = jest.fn()
const mockCancelRecorder = jest.fn()

jest.mock('../src/features/recording/durable-processing-queue', () => ({
  resumeQueuedAudioForUser: (...args: unknown[]) => mockResume(...args),
  clearAllQueuedAudio: (...args: unknown[]) => mockClearAll(...args),
  clearQueuedAudioForUser: (...args: unknown[]) => mockClearUser(...args),
}))
jest.mock('../src/lib/audio-recorder', () => ({
  audioRecorder: { cancel: (...args: unknown[]) => mockCancelRecorder(...args) },
}))

import { useRecordingProcessingQueue } from '../src/features/recording/use-recording-processing-queue'

function Harness({ userId, authReady }: { userId: string | null; authReady: boolean }): null {
  useRecordingProcessingQueue(userId, authReady)
  return null
}

describe('recording processing queue hook', () => {
  beforeEach(() => {
    mockResume.mockReset().mockResolvedValue(undefined)
    mockClearAll.mockReset().mockResolvedValue(undefined)
    mockClearUser.mockReset().mockResolvedValue(undefined)
    mockCancelRecorder.mockReset().mockResolvedValue(undefined)
  })

  it('only resumes the authenticated owner and delegates every privacy deletion to AuthContext', async () => {
    let renderer: ReturnType<typeof create>
    await act(async () => {
      renderer = create(<Harness userId="user-a" authReady />)
      await Promise.resolve()
    })
    await act(async () => {
      renderer!.update(<Harness userId={null} authReady={false} />)
      await Promise.resolve()
    })
    await act(async () => {
      renderer!.update(<Harness userId="user-b" authReady />)
      await Promise.resolve()
    })

    expect(mockResume.mock.calls).toEqual([['user-a'], ['user-b']])
    expect(mockClearAll).not.toHaveBeenCalled()
    expect(mockClearUser).not.toHaveBeenCalled()
    expect(mockCancelRecorder).not.toHaveBeenCalled()
  })
})