import * as appHooks from '@/app/hooks'
import { AppDispatch, setupStore } from '@/app/store'
import HandleLogin from '@/features/User/HandleLogin'
import * as oidcAuth from '@/features/User/oidcAuth'
import { clientConfig } from '@/features/User/oidcAuth'
import { useInitializeApp } from '@/features/User/useInitializeApp'
import * as apiUtils from '@/utils/apiUtils'
import { renderHook, screen, waitFor } from '@testing-library/react'
import { Provider } from 'react-redux'
import { push } from 'redux-first-history'
import { renderWithProviders } from '../../utils/Renderwithproviders'

clientConfig.url = 'https://example.com'

describe('HandleLogin', () => {
  beforeEach(() => {
    jest.clearAllMocks()
    jest.spyOn(apiUtils, 'redirectTo').mockImplementation(() => {})
    const dispatch = jest.fn() as AppDispatch
    jest.spyOn(appHooks, 'useAppDispatch').mockReturnValue(dispatch)
    sessionStorage.clear()
    Object.defineProperty(window, 'matchMedia', {
      writable: true,
      value: jest.fn().mockImplementation(query => ({
        matches: false,
        media: query,
        onchange: null,
        addEventListener: jest.fn(),
        removeEventListener: jest.fn(),
        dispatchEvent: jest.fn()
      }))
    })
  })

  test('redirects and sets sessionStorage when no userData', async () => {
    const loginUrlMock = {
      code_verifier: 'verifier123',
      state: 'state123',
      redirectTo: new URL('http://login.url')
    }

    jest.spyOn(oidcAuth, 'Auth').mockResolvedValue(loginUrlMock)

    const { result } = renderHook(() => useInitializeApp(), {
      wrapper: ({ children }) => (
        <Provider
          store={setupStore({
            user: {
              userData: null,
              tokens: null,
              loading: false,
              error: null,
              coreConfig: { language: 'en' }
            },
            calendars: { list: {}, pending: false, error: null }
          })}
        >
          {children}
        </Provider>
      )
    })

    await waitFor(
      () => {
        expect(oidcAuth.Auth).toHaveBeenCalled()
      },
      { timeout: 3000 }
    )

    await waitFor(
      () => {
        expect(sessionStorage.getItem('redirectState')).toEqual(
          JSON.stringify({
            code_verifier: 'verifier123',
            state: 'state123'
          })
        )
      },
      { timeout: 3000 }
    )

    await waitFor(
      () => {
        expect(apiUtils.redirectTo).toHaveBeenCalledWith(
          loginUrlMock.redirectTo
        )
      },
      { timeout: 3000 }
    )
  })

  test('does not render loading element when userData exists and calendars pending is true', () => {
    const preloadedState = {
      user: {
        userData: {
          sub: 'test',
          email: 'test@test.com',
          sid: 'aiYbWZSk2g0F+LrQeD7Dg4QcUMR8R/zTZdZBiA7N6Ro',
          openpaasId: '667037022b752d0026472254'
        },
        tokens: { access_token: 'test' },
        loading: false
      },
      calendars: { list: {}, pending: true },
      loading: { isLoading: true }
    }

    renderWithProviders(<HandleLogin />, preloadedState)
    // HandleLogin now returns null, loading is shown at App level via appLoading state
    expect(screen.queryByTestId('loading')).not.toBeInTheDocument()
  })
  test('does not render loading element when userData exists and calendars pending is false', () => {
    const preloadedState = {
      user: {
        userData: {
          sub: 'cmoussu',
          email: 'cmoussu@linagora.com',
          sid: 'aiYbWZSk2g0F+LrQeD7Dg4QcUMR8R/zTZdZBiA7N6Ro',
          openpaasId: '667037022b752d0026472254'
        },
        tokens: { access_token: 'test' },
        loading: false
      },
      calendars: { list: {}, pending: false },
      loading: { isLoading: false }
    }
    renderWithProviders(<HandleLogin />, preloadedState)

    // HandleLogin now returns null, loading is shown at App level via appLoading state
    expect(screen.queryByTestId('loading')).not.toBeInTheDocument()
  })
  test('goes to error page when there is error in user data', async () => {
    const mockDispatch = jest.fn()
    jest.spyOn(appHooks, 'useAppDispatch').mockReturnValue(mockDispatch)
    jest.spyOn(oidcAuth, 'Auth').mockResolvedValue({
      code_verifier: 'verifier123',
      state: 'state123',
      redirectTo: new URL('http://login.url')
    })

    renderWithProviders(<HandleLogin />, {
      user: {
        error: true,
        loading: false,
        userData: {
          sub: 'test',
          email: 'test@test.com',
          sid: 'testSid',
          openpaasId: 'testId'
        },
        tokens: { access_token: 'test' }
      },
      calendars: {
        list: {},
        pending: false,
        error: null
      }
    })

    await waitFor(
      () => {
        expect(mockDispatch).toHaveBeenCalledWith(push('/error'))
      },
      { timeout: 3000 }
    )
  })
})