import { createAction } from '@reduxjs/toolkit'
import SeamlyBaseError from 'api/errors/seamly-base-error'
import SeamlyConfigurationError from 'api/errors/seamly-configuration-error'
import SeamlyGeneralError from 'api/errors/seamly-general-error'
import SeamlyOfflineError from 'api/errors/seamly-offline-error'
import SeamlySessionExpiredError from 'api/errors/seamly-session-expired-error'
import SeamlyUnauthorizedError from 'api/errors/seamly-unauthorized-error'
import SeamlyUnavailableError from 'api/errors/seamly-unavailable-error'
import { selectConfig } from 'domains/config/selectors'

const ErrorTypes = {
  SeamlyGeneralError,
  SeamlyConfigurationError,
  SeamlySessionExpiredError,
  SeamlyOfflineError,
  SeamlyUnauthorizedError,
  SeamlyUnavailableError,
}

export const catchError = createAction('catch-error', (error) => ({
  payload: error,
}))

export function createErrorsMiddleware({ api: seamlyApi }) {
  return ({ getState }) => {
    const handleError = (action) => {
      const { errorCallback, namespace, api, layoutMode } =
        selectConfig(getState())

      const { error, type } = action

      const errorType = ErrorTypes[error?.name]
        ? new ErrorTypes[error.name](error)
        : new SeamlyBaseError(error)

      errorCallback?.(errorType, {
        namespace,
        api,
        layoutMode,
        conversationUrl: seamlyApi.getConversationUrl(),
        action: type ? action : undefined,
      })
    }

    return (next) => (action) => {
      try {
        if (action.payload?.originalEvent?.payload) {
          handleError({
            error: action.payload,
            type: action.payload?.originalEvent?.payload?.type,
          })
        } else if (action.payload?.originalError) {
          handleError({
            error: action.payload,
            type: undefined,
          })
        }
        return next(action)
      } catch (error) {
        handleError({ error })
        throw error
      }
    }
  }
}