'use client'

import { useCallback, useEffect, useState } from 'react'
import {
  getVapidPublicKey,
  isPushSupported,
  registerServiceWorker,
  requestNotificationPermission,
  urlBase64ToUint8Array,
} from '@/lib/pwa'

type PushStatus = 'idle' | 'unsupported' | 'denied' | 'granted' | 'registering' | 'subscribed' | 'error'

// Hook personnalisé pour gérer l'inscription des notifications push
export function usePushNotifications() {
  const [status, setStatus] = useState<PushStatus>('idle')
  const [registration, setRegistration] = useState<ServiceWorkerRegistration | null>(null)

  // Enregistrer le service worker au montage et vérifier si déjà abonné
  useEffect(() => {
    if (!isPushSupported()) {
      setStatus('unsupported')
      return
    }

    let cancelled = false

    const initializeServiceWorker = async () => {
      try {
        const reg = await registerServiceWorker()
        
        if (cancelled || !reg) return

        setRegistration(reg)

        // Vérifier si une souscription existe déjà
        const existingSubscription = await reg.pushManager.getSubscription()
        
        if (cancelled) return

        if (existingSubscription) {
          // Une souscription active existe déjà
          setStatus('subscribed')
        } else {
          // Pas encore abonné, vérifier la permission
          if (typeof Notification !== 'undefined') {
            if (Notification.permission === 'denied') {
              setStatus('denied')
            } else if (Notification.permission === 'granted') {
              setStatus('granted')
            } else {
              setStatus('idle')
            }
          }
        }
      } catch (error) {
        if (!cancelled) {
          setStatus('error')
        }
      }
    }

    initializeServiceWorker()

    return () => {
      cancelled = true
    }
  }, [])

  const subscribe = useCallback(async () => {
    if (!registration) {
      return { success: false, error: 'Service worker unavailable' }
    }

    setStatus('registering')

    const permission = await requestNotificationPermission()

    if (permission !== 'granted') {
      setStatus(permission === 'denied' ? 'denied' : 'idle')
      return { success: false, error: 'Notification permission is required' }
    }

    const vapidPublicKey = getVapidPublicKey()

    if (!vapidPublicKey) {
      setStatus('error')
      return { success: false, error: 'Missing VAPID public key' }
    }

    try {
      console.log('[CLIENT] Attempting to subscribe to push...')
      console.log('[CLIENT] Registration state:', registration.active ? 'active' : 'not active')
      
      const subscription = await registration.pushManager.subscribe({
        userVisibleOnly: true,
        applicationServerKey: urlBase64ToUint8Array(vapidPublicKey),
      })

      console.log('[CLIENT] Push subscription successful!', subscription.endpoint)

      const response = await fetch('/api/push/subscribe', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        credentials: 'include',
        body: JSON.stringify({ subscription, platform: navigator.userAgent }),
      })

      if (!response.ok) {
        console.error('[CLIENT] Failed to save subscription to server:', response.status)
        setStatus('error')
        return { success: false, error: 'Failed to save push subscription' }
      }

      console.log('[CLIENT] Subscription saved to server successfully!')
      setStatus('subscribed')
      return { success: true }
    } catch (error) {
      console.error('[CLIENT] Error during push subscription:', error)
      console.error('[CLIENT] Error details:', {
        name: error instanceof Error ? error.name : 'unknown',
        message: error instanceof Error ? error.message : String(error),
      })
      setStatus('error')
      return { success: false, error: 'Error during push subscription' }
    }
  }, [registration])

  return {
    status,
    registration,
    isSupported: status !== 'unsupported',
    subscribe,
  }
}