import CalendarResources from '@/components/Calendar/CalendarResources'
import { getCalendars } from '@/features/Calendars/CalendarApi'
import { addCalendarResourceAsync } from '@/features/Calendars/api/addCalendarResourceAsync'
import { act, fireEvent, screen, waitFor } from '@testing-library/react'
import { renderWithProviders } from '../utils/Renderwithproviders'

jest.mock('@/features/Calendars/CalendarApi')
jest.mock('@/features/Calendars/api/addCalendarResourceAsync')
jest.mock('@/components/Attendees/ResourceSearch', () => ({
  ResourceSearch: ({
    onChange
  }: {
    onChange: (
      event: null,
      value: { displayName: string; openpaasId: string }[]
    ) => void
  }) => (
    <div data-testid="resource-search">
      <button
        data-testid="mock-resource-search-select"
        onClick={() =>
          onChange(null, [
            { displayName: 'Room A', openpaasId: 'room-a-id' },
            { displayName: 'Room B', openpaasId: 'room-b-id' }
          ])
        }
      >
        Select Resources
      </button>
    </div>
  )
}))

const mockedGetCalendars = getCalendars as jest.Mock
const mockedAddCalendarResourceAsync =
  addCalendarResourceAsync as unknown as jest.Mock

describe('CalendarResources', () => {
  beforeEach(() => {
    jest.clearAllMocks()
  })

  const baseUser = {
    userData: {
      sub: 'test',
      email: 'test@test.com',
      sid: 'mockSid',
      openpaasId: 'user1'
    },
    tokens: { accessToken: 'token' }
  }

  const setup = (isOpen = true) => {
    const onClose = jest.fn()
    renderWithProviders(<CalendarResources onClose={onClose} open={isOpen} />, {
      user: baseUser
    })
    return { onClose }
  }

  it('renders correctly and closes on cancel', () => {
    const { onClose } = setup()

    expect(screen.getByText('calendar.browseResources')).toBeInTheDocument()

    const cancelButton = screen.getByRole('button', {
      name: 'common.cancel'
    })
    fireEvent.click(cancelButton)

    expect(onClose).toHaveBeenCalled()
  })

  it('does not render when isOpen is false', () => {
    setup(false)
    expect(
      screen.queryByText('calendar.browseResources')
    ).not.toBeInTheDocument()
  })

  it('fetches resource calendars and adds them using Promise.allSettled logic', async () => {
    const mockCalendarDataA = {
      _embedded: {
        'dav:calendar': [
          {
            _links: { self: { href: '/calendars/room-a-id/cal-a.json' } },
            'dav:name': 'Room A Calendar',
            'caldav:description': 'Main room A calendar',
            color: 'red'
          }
        ]
      }
    }

    mockedGetCalendars.mockImplementation(userId => {
      if (userId === 'room-a-id') return Promise.resolve(mockCalendarDataA)
      // Simulate failure for room-b
      if (userId === 'room-b-id')
        return Promise.reject(new Error('Failed fetching Room B'))
      return Promise.resolve([])
    })

    const mockDispatchResult = {
      unwrap: () => Promise.resolve({ type: 'success' })
    }
    mockedAddCalendarResourceAsync.mockReturnValue(() => mockDispatchResult)

    const { onClose } = setup()

    // Trigger resource selection
    const mockSelectBtn = screen.getByTestId('mock-resource-search-select')
    await act(async () => {
      fireEvent.click(mockSelectBtn)
    })

    // After selection, the button should be enabled and say Add
    const addButton = await screen.findByRole('button', {
      name: 'actions.add'
    })
    expect(addButton).not.toBeDisabled()

    // Click add to trigger addCalendarResourceAsync
    await act(async () => {
      fireEvent.click(addButton)
    })

    await waitFor(() => {
      // It should only have been called for Room A because Room B failed (Promise.allSettled)
      expect(mockedAddCalendarResourceAsync).toHaveBeenCalledTimes(1)

      const payload = mockedAddCalendarResourceAsync.mock.calls[0][0]
      expect(payload).toEqual(
        expect.objectContaining({
          userId: 'user1',
          calId: expect.any(String),
          cal: expect.objectContaining({
            cal: mockCalendarDataA._embedded['dav:calendar'][0]
          })
        })
      )
    })

    expect(onClose).toHaveBeenCalled()
  })

  it('adds existing user details fallback logic within submit handler', async () => {
    const mockCalendarDataA = {
      _embedded: {
        'dav:calendar': [
          {
            _links: { self: { href: '/calendars/room-a-id/cal-a.json' } },
            'dav:name': 'Room A Calendar',
            'caldav:description': 'Main room A calendar',
            color: 'red'
          }
        ]
      }
    }

    mockedGetCalendars.mockResolvedValueOnce(mockCalendarDataA)
    mockedGetCalendars.mockResolvedValueOnce([]) // Mock array of size 2 (for both A and B but second resolves empty)

    // Simulate successful API response
    const mockDispatchResult = {
      unwrap: () => Promise.resolve()
    }
    mockedAddCalendarResourceAsync.mockReturnValue(() => mockDispatchResult)

    const { onClose } = setup()

    // Trigger resource selection
    const mockSelectBtn = screen.getByTestId('mock-resource-search-select')
    await act(async () => {
      fireEvent.click(mockSelectBtn)
    })

    const addButton = await screen.findByRole('button', {
      name: 'actions.add'
    })
    await act(async () => {
      fireEvent.click(addButton)
    })

    await waitFor(() => {
      expect(onClose).toHaveBeenCalled()
    })
  })
})