import { GoogleSignin, statusCodes } from '@react-native-google-signin/google-signin'
import * as AppleAuthentication from 'expo-apple-authentication'
import { useRouter, usePathname } from 'expo-router'
import * as Google from 'expo-auth-session/providers/google'
import Constants from 'expo-constants'
import * as WebBrowser from 'expo-web-browser'
import { useCallback, useEffect, useMemo, useState } from 'react'
import { Platform } from 'react-native'

import { GOOGLE_CLIENT_IDS } from '../config/keys'
import { useAuth } from '../providers/auth-context'
import { useLoading } from '../providers/loading-context'
import { useTooltip } from '../providers/tooltip-context'

WebBrowser.maybeCompleteAuthSession()

const PLACEHOLDER_CLIENT_IDS = {
  android: 'placeholder-android-client-id',
  ios: 'placeholder-ios-client-id',
  web: 'placeholder-web-client-id',
  expo: 'placeholder-expo-client-id',
}

const GOOGLE_CLIENT_ID_ENV_KEYS = {
  androidClientId: 'EXPO_PUBLIC_GOOGLE_ANDROID_CLIENT_ID',
  iosClientId: 'EXPO_PUBLIC_GOOGLE_IOS_CLIENT_ID',
  webClientId: 'EXPO_PUBLIC_GOOGLE_WEB_CLIENT_ID',
  expoClientId: 'EXPO_PUBLIC_GOOGLE_EXPO_CLIENT_ID',
}

const isMeaningfulValue = (value) => {
  if (!value) {
    return false
  }

  const normalized = value.toLowerCase()
  if (
    normalized.startsWith('your-') ||
    normalized.includes('example') ||
    normalized.includes('placeholder')
  ) {
    return false
  }

  return true
}

const readGoogleClientIds = () => ({
  androidClientId: GOOGLE_CLIENT_IDS.android,
  iosClientId: GOOGLE_CLIENT_IDS.ios,
  webClientId: GOOGLE_CLIENT_IDS.web,
  expoClientId: GOOGLE_CLIENT_IDS.expo,
})

const buildAuthSessionConfig = (ids) => ({
  androidClientId: ids.androidClientId || PLACEHOLDER_CLIENT_IDS.android,
  iosClientId: ids.iosClientId || PLACEHOLDER_CLIENT_IDS.ios,
  webClientId: ids.webClientId || PLACEHOLDER_CLIENT_IDS.web,
  expoClientId: ids.expoClientId || PLACEHOLDER_CLIENT_IDS.expo,
})

const getRequiredGoogleKeys = ({ isNativePlatform, isExpoGo }) => {
  if (Platform.OS === 'web') {
    return ['webClientId']
  }

  if (isExpoGo) {
    if (Platform.OS === 'android') {
      return ['expoClientId', 'androidClientId']
    }
    if (Platform.OS === 'ios') {
      return ['expoClientId', 'iosClientId']
    }
    return ['expoClientId']
  }

  if (isNativePlatform) {
    const keys = ['webClientId']
    if (Platform.OS === 'android') {
      keys.push('androidClientId')
    }
    if (Platform.OS === 'ios') {
      keys.push('iosClientId')
    }
    return keys
  }

  return ['webClientId']
}

const findMissingGoogleKeys = (ids, options) =>
  getRequiredGoogleKeys(options).filter((key) => !isMeaningfulValue(ids?.[key]))

const formatMissingGoogleKeys = (keys) =>
  keys.map((key) => GOOGLE_CLIENT_ID_ENV_KEYS[key] || key).join(', ')

const useSocialAuth = ({ defaultAction = 'login' } = {}) => {
  const router = useRouter()
  const pathname = usePathname()
  const { authenticateWithGoogle, authenticateWithApple, redirectUser } = useAuth()
  const { withLoading, isLoading } = useLoading()
  const { showTooltip } = useTooltip()

  const [isAppleSignInAvailable, setIsAppleSignInAvailable] = useState(false)

  useEffect(() => {
    let mounted = true

    AppleAuthentication.isAvailableAsync()
      .then((isAvailable) => {
        if (mounted) {
          setIsAppleSignInAvailable(isAvailable)
        }
      })
      .catch(() => {
        if (mounted) {
          setIsAppleSignInAvailable(false)
        }
      })

    return () => {
      mounted = false
    }
  }, [])

  const googleClientIds = useMemo(() => readGoogleClientIds(), [])
  const authSessionConfig = useMemo(
    () => buildAuthSessionConfig(googleClientIds),
    [googleClientIds]
  )

  const isNativePlatform = Platform.OS === 'ios' || Platform.OS === 'android'
  const appOwnership = Constants?.appOwnership || null
  const isExpoGo = appOwnership === 'expo'
  const shouldUseAuthSession = !isNativePlatform || isExpoGo

  useEffect(() => {
    if (!isNativePlatform || shouldUseAuthSession) {
      return
    }

    if (!isMeaningfulValue(googleClientIds.webClientId)) {
      return
    }

    try {
      GoogleSignin.configure({
        webClientId: googleClientIds.webClientId,
        iosClientId: googleClientIds.iosClientId,
        offlineAccess: true,
      })
    } catch (error) {
      console.warn('Failed to configure Google Sign-In', error)
    }
  }, [googleClientIds, isNativePlatform, shouldUseAuthSession])

  const [, , promptAsync] = Google.useAuthRequest(authSessionConfig)

  const handleMissingGoogleConfig = useCallback(
    (missingKeys) => {
      if (!missingKeys.length) {
        return false
      }

      showTooltip({
        message: `La configuration Google est incomplète. Variables manquantes : ${formatMissingGoogleKeys(
          missingKeys
        )}.`,
        type: 'error',
      })

      return true
    },
    [showTooltip]
  )

  const signInWithGoogle = useCallback(
    async (actionOverride = undefined) => {
      if (isLoading) {
        return
      }

      const missingKeys = findMissingGoogleKeys(googleClientIds, {
        isNativePlatform,
        isExpoGo,
      })
      if (handleMissingGoogleConfig(missingKeys)) {
        return
      }

      if (isNativePlatform && !shouldUseAuthSession) {
        try {
          await withLoading(async () => {
            await GoogleSignin.hasPlayServices({
              showPlayServicesUpdateDialog: true,
            })

            const account = await GoogleSignin.signIn()
            let idToken = account?.idToken
            let accessToken = account?.accessToken

            try {
              const tokens = await GoogleSignin.getTokens()
              idToken = idToken || tokens?.idToken
              accessToken = accessToken || tokens?.accessToken
            } catch (_) {
              // no-op: continue with whatever tokens we already have
            }

            if (!idToken) {
              throw new Error('Impossible de récupérer le jeton Google.')
            }

            await authenticateWithGoogle({
              idToken,
              accessToken,
              action: actionOverride || defaultAction,
            })
            await redirectUser({ router, pathname, isInitial: false })
          })
        } catch (error) {
          if (error?.code === statusCodes.SIGN_IN_CANCELLED) {
            return
          }

          if (error?.code === statusCodes.IN_PROGRESS) {
            return
          }

          if (error?.code === statusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
            showTooltip({
              message:
                'Les services Google Play ne sont pas disponibles ou nécessitent une mise à jour.',
              type: 'error',
            })
            return
          }

          const message =
            error?.message || 'Impossible de terminer la connexion Google pour le moment.'
          showTooltip({
            message,
            type: 'error',
          })
        }

        return
      }

      if (!promptAsync) {
        showTooltip({
          message:
            'La configuration Google est incomplète. Merci de vérifier vos identifiants client.',
          type: 'error',
        })
        return
      }

      try {
        await withLoading(async () => {
          const response = await promptAsync({
            useProxy: Platform.OS !== 'web',
            showInRecents: true,
          })

          if (!response || response.type !== 'success') {
            if (response?.type && response.type !== 'dismiss') {
              showTooltip({
                message: 'Connexion Google annulée.',
                type: 'warning',
              })
            }
            return
          }

          const { authentication } = response
          if (!authentication?.idToken) {
            throw new Error('Jeton Google introuvable.')
          }

          await authenticateWithGoogle({
            idToken: authentication.idToken,
            accessToken: authentication.accessToken,
            action: actionOverride || defaultAction,
          })
          await redirectUser({ router, pathname, isInitial: false })
        })
      } catch (error) {
        const message =
          error?.message || 'Impossible de terminer la connexion Google pour le moment.'
        showTooltip({
          message,
          type: 'error',
        })
      }
    },
    [
      authenticateWithGoogle,
      defaultAction,
      googleClientIds,
      handleMissingGoogleConfig,
      isExpoGo,
      isLoading,
      isNativePlatform,
      pathname,
      promptAsync,
      redirectUser,
      router,
      shouldUseAuthSession,
      showTooltip,
      withLoading,
    ]
  )

  const signInWithApple = useCallback(
    async (actionOverride = undefined) => {
      if (isLoading) {
        return
      }

      if (!isAppleSignInAvailable) {
        showTooltip({
          message: 'La connexion avec Apple n’est pas disponible sur cet appareil.',
          type: 'warning',
        })
        return
      }

      try {
        await withLoading(async () => {
          const appleCredential = await AppleAuthentication.signInAsync({
            requestedScopes: [
              AppleAuthentication.AppleAuthenticationScope.EMAIL,
              AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
            ],
          })

          if (!appleCredential?.identityToken) {
            throw new Error('Impossible de récupérer le jeton Apple.')
          }

          await authenticateWithApple({
            idToken: appleCredential.identityToken,
            rawNonce: appleCredential.nonce,
            action: actionOverride || defaultAction,
          })
          await redirectUser({ router, pathname, isInitial: false })
        })
      } catch (error) {
        if (error?.code === 'ERR_CANCELED') {
          return
        }
        const message =
          error?.message || 'Impossible de terminer la connexion avec Apple pour le moment.'
        showTooltip({
          message,
          type: 'error',
        })
      }
    },
    [
      authenticateWithApple,
      defaultAction,
      isAppleSignInAvailable,
      isLoading,
      pathname,
      redirectUser,
      router,
      showTooltip,
      withLoading,
    ]
  )

  return {
    isAppleSignInAvailable,
    signInWithGoogle,
    signInWithApple,
  }
}

export default useSocialAuth