Stirling-PDF/frontend/src/saas/hooks/useAutoAnonymousAuth.ts

import { useState, useEffect, useCallback } from 'react'
import { useLocation } from 'react-router-dom'
import { useAuth } from '@app/auth/UseSession'
import { signInAnonymously, supabase } from '@app/auth/supabase'
import { isAuthRoute, isHomeRoute, isToolRoute } from '@app/utils/pathUtils'

interface AutoAnonymousAuthState {
  isAutoAuthenticating: boolean
  autoAuthError: string | null
  shouldTriggerAutoAuth: boolean
}

/**
 * Automatically signs in users anonymously on direct tool access when not authenticated.
 */
export function useAutoAnonymousAuth() {
  const { session, loading } = useAuth()
  const location = useLocation()
  const [state, setState] = useState<AutoAnonymousAuthState>({
    isAutoAuthenticating: false,
    autoAuthError: null,
    shouldTriggerAutoAuth: false
  })

  const shouldAutoAuthenticate = useCallback((): boolean => {
    const currentPath = location.pathname
    if (isAuthRoute(currentPath)) return false
    if (isHomeRoute(currentPath)) return false
    return isToolRoute(currentPath)
  }, [location.pathname])

  const waitForToken = useCallback(async (timeoutMs = 7000) => {
    // Prefer event-driven approach; fallback to polling if needed
    let resolved = false
    const done = (ok: boolean) => {
      resolved = true
      return ok
    }

    const hasToken = async () => {
      const { data: { session } } = await supabase.auth.getSession()
      return !!session?.access_token
    }

    if (await hasToken()) return true

    const unsub = supabase.auth.onAuthStateChange(async (_evt, _session) => {
      if (!resolved && (await hasToken())) {
        unsub.data.subscription.unsubscribe()
        done(true)
      }
    })

    const started = Date.now()
    while (!resolved && Date.now() - started < timeoutMs) {
      if (await hasToken()) {
        unsub.data.subscription.unsubscribe()
        return done(true)
      }
      // gentle backoff
      await new Promise(r => setTimeout(r, 120))
    }

    try { unsub.data.subscription.unsubscribe() } catch (err) {
      // Ignore unsubscribe errors during cleanup
      console.debug('[useAutoAnonymousAuth] Unsubscribe cleanup error:', err)
    }
    return done(false)
  }, [])

  const triggerAnonymousAuth = useCallback(async () => {
    if (state.isAutoAuthenticating) return

    setState(prev => ({ ...prev, isAutoAuthenticating: true, autoAuthError: null }))
    try {
      console.log('[useAutoAnonymousAuth] anonymous auth starting')

      const { error } = await signInAnonymously()
      if (error) throw error

      // Wait for a usable token so first API calls won't 401/redirect
      const ok = await waitForToken(7000)
      if (!ok) {
        throw new Error('Timed out waiting for anonymous session token')
      }

      console.log('[useAutoAnonymousAuth] anonymous auth complete')
      setState(prev => ({ ...prev, isAutoAuthenticating: false, shouldTriggerAutoAuth: false }))
    } catch (e) {
      console.error('[useAutoAnonymousAuth] anonymous auth failed', e)
      setState(prev => ({
        ...prev,
        isAutoAuthenticating: false,
        autoAuthError: e instanceof Error ? e.message : 'Anonymous authentication failed'
      }))
    }
  }, [state.isAutoAuthenticating, waitForToken])

  // Decide whether to auto-auth on mount & whenever location/auth changes
  useEffect(() => {
    if (loading) return
    if (session) return
    if (state.isAutoAuthenticating) return

    const shouldAuth = shouldAutoAuthenticate()
    if (state.shouldTriggerAutoAuth !== shouldAuth) {
      setState(prev => ({ ...prev, shouldTriggerAutoAuth: shouldAuth }))
    }

    if (shouldAuth) {
      console.log('[useAutoAnonymousAuth] tool route detected, auto-auth')
      triggerAnonymousAuth()
    }
  }, [loading, session, state.isAutoAuthenticating, state.shouldTriggerAutoAuth, shouldAutoAuthenticate, triggerAnonymousAuth])

  // Clear error if route is no longer a tool route, or once authenticated
  useEffect(() => {
    if (session || !shouldAutoAuthenticate()) {
      setState(prev => ({ ...prev, autoAuthError: null, shouldTriggerAutoAuth: false }))
    }
  }, [session, shouldAutoAuthenticate])

  return {
    isAutoAuthenticating: state.isAutoAuthenticating,
    autoAuthError: state.autoAuthError,
    shouldTriggerAutoAuth: state.shouldTriggerAutoAuth,
    triggerAnonymousAuth
  }
}