import SettingsPage from '@/features/Settings/SettingsPage'
import settingsReducer, {
  setIsBrowserDefaultTimeZone,
  setTimeZone
} from '@/features/Settings/SettingsSlice'
import userReducer, {
  getOpenPaasUserDataAsync,
  setTimezone as setUserTimeZone
} from '@/features/User/userSlice'
import { api } from '@/utils/apiUtils'
import { browserDefaultTimeZone } from '@/utils/timezone'
import { configureStore } from '@reduxjs/toolkit'
import { fireEvent, screen, waitFor } from '@testing-library/react'
import { renderWithProviders } from '../../utils/Renderwithproviders'

jest.mock('@/utils/apiUtils')

describe('Timezone synchronization after getOpenPaasUserDataAsync', () => {
  let apiGetSpy: jest.SpyInstance

  beforeEach(() => {
    jest.clearAllMocks()
    localStorage.clear()
    apiGetSpy = jest.spyOn(api, 'get')
  })

  afterEach(() => {
    apiGetSpy.mockRestore()
  })

  it('should sync timezone to both user and settings state after fetching user data', async () => {
    const mockUserData = {
      id: '667037022b752d0026472254',
      firstname: 'John',
      lastname: 'Doe',
      preferredEmail: ['test@test.com'],
      configurations: {
        modules: [
          {
            name: 'core',
            configurations: [
              { name: 'language', value: 'fr' },
              { name: 'datetime', value: { timeZone: 'Europe/Paris' } }
            ]
          }
        ]
      }
    }

    // Return a fake fetch-like response
    apiGetSpy.mockResolvedValue({
      json: async () => mockUserData
    })

    const store = configureStore({
      reducer: { user: userReducer, settings: settingsReducer },
      preloadedState: {
        user: {
          userData: {
            sub: 'test',
            email: 'test@test.com',
            family_name: 'Doe',
            name: 'John',
            sid: 'mockSid',
            openpaasId: '667037022b752d0026472254'
          },
          organiserData: null,
          tokens: null,
          coreConfig: { language: 'en', datetime: { timeZone: 'UTC' } },
          loading: false,
          error: null
        },
        settings: { language: 'en', timeZone: 'UTC', view: 'calendar' }
      }
    })

    const result = await store.dispatch(getOpenPaasUserDataAsync())

    expect(result.type).toBe('user/getOpenPaasUserData/fulfilled')

    const state = store.getState()
    expect(state.user.coreConfig.datetime.timeZone).toBe('Europe/Paris')
    expect(state.settings.timeZone).toBe('Europe/Paris')
    expect(localStorage.getItem('timeZone')).toBe('Europe/Paris')
  })

  it('should keep browser timezone if API response has no timezone configuration', async () => {
    const mockUserData = {
      id: '667037022b752d0026472254',
      firstname: 'John',
      lastname: 'Doe',
      preferredEmail: '[test@test.com](mailto:test@test.com)',
      configurations: {
        modules: [
          { name: 'core', configurations: [{ name: 'language', value: 'en' }] }
        ]
      }
    }

    apiGetSpy.mockResolvedValue({
      json: async () => mockUserData
    })

    const browserTimezone = browserDefaultTimeZone ?? 'UTC'

    const store = configureStore({
      reducer: { user: userReducer, settings: settingsReducer },
      preloadedState: {
        user: {
          userData: {
            sub: 'test',
            email: 'test@test.com',
            family_name: 'Doe',
            name: 'John',
            sid: 'mockSid',
            openpaasId: '667037022b752d0026472254'
          },
          organiserData: null,
          tokens: null,
          coreConfig: {
            language: 'en',
            datetime: { timeZone: browserTimezone }
          },
          loading: false,
          error: null
        },
        settings: {
          language: 'en',
          timeZone: browserTimezone,
          view: 'calendar'
        }
      }
    })

    const result = await store.dispatch(getOpenPaasUserDataAsync())

    expect(result.type).toBe('user/getOpenPaasUserData/fulfilled')

    const state = store.getState()
    expect(state.user.coreConfig.datetime.timeZone).toBe(null)
    expect(state.settings.timeZone).toBe(browserTimezone)
  })
})

// Mock localStorage
const localStorageMock = (() => {
  let store: Record<string, string> = {}
  return {
    getItem: (key: string) => store[key] || null,
    setItem: (key: string, value: string) => {
      store[key] = value
    },
    removeItem: (key: string) => {
      delete store[key]
    },
    clear: () => {
      store = {}
    }
  }
})()

Object.defineProperty(window, 'localStorage', {
  value: localStorageMock
})

describe('Timezone Logic - Backend to Frontend Flow', () => {
  let store: any

  beforeEach(() => {
    localStorageMock.clear()
    store = configureStore({
      reducer: {
        settings: settingsReducer,
        user: userReducer
      },
      preloadedState: {
        user: {
          userData: {
            sub: 'test',
            email: 'test@test.com',
            family_name: 'Doe',
            name: 'John',
            sid: 'mockSid',
            openpaasId: '667037022b752d0026472254'
          },
          organiserData: null,
          tokens: null,
          coreConfig: { language: 'en', datetime: { timeZone: 'UTC' } },
          loading: false,
          error: null
        },
        settings: { language: 'en', timeZone: 'UTC', view: 'calendar' }
      }
    })
  })

  describe('Backend Response Handling', () => {
    test('Backend returns NULL => Should use browser default timezone', async () => {
      const backendResponse = {
        firstname: 'John',
        lastname: 'Doe',
        id: '123',
        preferredEmail: 'john@example.com',
        configurations: {
          modules: [
            {
              name: 'core',
              configurations: [
                {
                  name: 'datetime',
                  value: {
                    timeZone: null
                  }
                }
              ]
            }
          ]
        }
      }

      await store.dispatch(
        getOpenPaasUserDataAsync.fulfilled(backendResponse, '', undefined)
      )

      const settingsState = store.getState().settings
      const userState = store.getState().user

      expect(settingsState.timeZone).toBe(browserDefaultTimeZone)
      expect(settingsState.isBrowserDefaultTimeZone).toBe(true)
      expect(userState.coreConfig.datetime.timeZone).toBe(null)
      expect(localStorage.getItem('timeZone')).toBe(browserDefaultTimeZone)
    })

    test('Backend returns SPECIFIC VALUE => Should use that value', async () => {
      const specificTimezone = 'America/New_York'
      const backendResponse = {
        firstname: 'Jane',
        lastname: 'Smith',
        id: '456',
        preferredEmail: 'jane@example.com',
        configurations: {
          modules: [
            {
              name: 'core',
              configurations: [
                {
                  name: 'datetime',
                  value: {
                    timeZone: specificTimezone
                  }
                }
              ]
            }
          ]
        }
      }

      await store.dispatch(
        getOpenPaasUserDataAsync.fulfilled(backendResponse, '', undefined)
      )

      const settingsState = store.getState().settings
      const userState = store.getState().user

      expect(settingsState.timeZone).toBe(specificTimezone)
      expect(settingsState.isBrowserDefaultTimeZone).toBe(false)
      expect(userState.coreConfig.datetime.timeZone).toBe(specificTimezone)
      expect(localStorage.getItem('timeZone')).toBe(specificTimezone)
    })

    test('Backend returns NO datetime config => Should use browser default', async () => {
      const backendResponse = {
        firstname: 'Bob',
        lastname: 'Johnson',
        id: '789',
        preferredEmail: 'bob@example.com',
        configurations: {
          modules: [
            {
              name: 'core',
              configurations: [
                // No datetime config
              ]
            }
          ]
        }
      }

      await store.dispatch(
        getOpenPaasUserDataAsync.fulfilled(backendResponse, '', undefined)
      )

      const settingsState = store.getState().settings
      const userState = store.getState().user

      expect(settingsState.timeZone).toBe(browserDefaultTimeZone)
      expect(settingsState.isBrowserDefaultTimeZone).toBe(true)
      expect(userState.coreConfig.datetime.timeZone).toBe(null)
      expect(localStorage.getItem('timeZone')).toBe(browserDefaultTimeZone)
    })
  })

  test('Settings state ALWAYS has a concrete value (never null)', () => {
    // Test 1: Browser default scenario
    store.dispatch(setIsBrowserDefaultTimeZone(true))
    let settingsState = store.getState().settings

    expect(settingsState.timeZone).toBe(browserDefaultTimeZone)
    expect(settingsState.timeZone).not.toBe(null)

    // Test 2: Specific timezone scenario
    store.dispatch(setTimeZone('Europe/Paris'))
    settingsState = store.getState().settings

    expect(settingsState.timeZone).toBe('Europe/Paris')
    expect(settingsState.timeZone).not.toBe(null)
  })

  describe('User Actions - Changing Timezone', () => {
    beforeEach(() => {
      ;(api.patch as jest.Mock).mockResolvedValue({ status: 204 })
    })
    test('User enables browser default => Settings gets browser TZ, User gets null', async () => {
      const { store } = renderWithProviders(<SettingsPage />, {
        user: {
          userData: { sub: 'test' },
          organiserData: null,
          tokens: null,
          coreConfig: {
            language: 'en',
            datetime: { timeZone: 'America/Los_Angeles' }
          },
          loading: false,
          error: null
        },
        settings: {
          language: 'en',
          timeZone: 'America/Los_Angeles',
          isBrowserDefaultTimeZone: false,
          view: 'settings'
        }
      })

      const browserDefaultSwitch = screen.getAllByLabelText(
        'settings.timeZoneBrowserDefault'
      )[0]
      expect(browserDefaultSwitch).toBeInTheDocument()

      // Enable browser default
      fireEvent.click(browserDefaultSwitch)

      await waitFor(() => {
        const state = store.getState()
        expect(state.settings.isBrowserDefaultTimeZone).toBe(true)
      })
      await waitFor(() => {
        const state = store.getState()
        expect(state.settings.timeZone).toBe(browserDefaultTimeZone)
      })
      await waitFor(() => {
        const state = store.getState()
        expect(state.user.coreConfig.datetime.timeZone).toBe(null)
      })
    })

    test('User selects specific timezone => Both states get the value', async () => {
      const { store } = renderWithProviders(<SettingsPage />, {
        user: {
          userData: { sub: 'test' },
          organiserData: null,
          tokens: null,
          coreConfig: { language: 'en', datetime: { timeZone: null } },
          loading: false,
          error: null
        },
        settings: {
          language: 'en',
          timeZone: browserDefaultTimeZone,
          isBrowserDefaultTimeZone: true,
          view: 'settings'
        }
      })

      const browserDefaultSwitch = screen.getAllByLabelText(
        'settings.timeZoneBrowserDefault'
      )[0]

      // Disable browser default so manual selector appears
      fireEvent.click(browserDefaultSwitch)

      // Now timezone combobox is visible
      const timezoneInput = screen.getAllByRole('combobox')[1]

      // Type to filter options
      fireEvent.change(timezoneInput, {
        target: { value: 'Australia/Sydney' }
      })

      // Select from autocomplete dropdown
      const option = await screen.findByText(/Australia\/Sydney/i)
      fireEvent.click(option)

      await waitFor(() => {
        const state = store.getState()
        expect(state.settings.isBrowserDefaultTimeZone).toBe(false)
      })
      await waitFor(() => {
        const state = store.getState()
        expect(state.settings.timeZone).toBe('Australia/Sydney')
      })
      await waitFor(() => {
        const state = store.getState()
        expect(state.user.coreConfig.datetime.timeZone).toBe('Australia/Sydney')
      })
    })
  })

  describe('LocalStorage Persistence', () => {
    test('LocalStorage always stores concrete values (browser TZ or specific TZ)', () => {
      // Scenario 1: Browser default
      store.dispatch(setTimeZone(browserDefaultTimeZone))
      expect(localStorage.getItem('timeZone')).toBe(browserDefaultTimeZone)
      expect(localStorage.getItem('timeZone')).not.toBe('null')

      // Scenario 2: Specific timezone
      store.dispatch(setTimeZone('Africa/Cairo'))
      expect(localStorage.getItem('timeZone')).toBe('Africa/Cairo')
    })
  })

  test('Full user journey: Backend null -> User changes -> Backend saves', async () => {
    // Step 1: Backend returns null
    const backendResponseNull = {
      firstname: 'Test',
      lastname: 'User',
      id: '999',
      preferredEmail: 'test@example.com',
      configurations: {
        modules: [
          {
            name: 'core',
            configurations: [
              {
                name: 'datetime',
                value: { timeZone: null }
              }
            ]
          }
        ]
      }
    }

    await store.dispatch(
      getOpenPaasUserDataAsync.fulfilled(backendResponseNull, '', undefined)
    )

    // Verify initial state
    expect(store.getState().settings.timeZone).toBe(browserDefaultTimeZone)
    expect(store.getState().user.coreConfig.datetime.timeZone).toBe(null)

    // Step 2: User changes to specific timezone
    const userSelectedTZ = 'Europe/London'
    store.dispatch(setIsBrowserDefaultTimeZone(false))
    store.dispatch(setTimeZone(userSelectedTZ))
    store.dispatch(setUserTimeZone(userSelectedTZ))

    expect(store.getState().settings.timeZone).toBe(userSelectedTZ)
    expect(store.getState().user.coreConfig.datetime.timeZone).toBe(
      userSelectedTZ
    )

    // Step 3: User switches back to browser default
    store.dispatch(setIsBrowserDefaultTimeZone(true))
    store.dispatch(setUserTimeZone(null))
    store.dispatch(setTimeZone(browserDefaultTimeZone))

    expect(store.getState().settings.timeZone).toBe(browserDefaultTimeZone)
    expect(store.getState().user.coreConfig.datetime.timeZone).toBe(null)
  })
})