import { useAuthStore } from '@/stores/auth'
import axios from '@/utils/axios'

// Utilitaire pour convertir la clé VAPID
function urlBase64ToUint8Array(base64String) {
  const padding = '='.repeat((4 - base64String.length % 4) % 4)
  const base64 = (base64String + padding)
    .replace(/-/g, '+')
    .replace(/_/g, '/')

  const rawData = window.atob(base64)
  const outputArray = new Uint8Array(rawData.length)

  for (let i = 0; i < rawData.length; ++i) {
    outputArray[i] = rawData.charCodeAt(i)
  }
  return outputArray
}

class NotificationService {
  constructor() {
    this.pollingInterval = null
    this.pollInterval = 30000 // 30 secondes
    this.isPolling = false
    this.vapidPublicKey = null
  }

  // Détecter iOS
  isIOS() {
    return /iPhone|iPad|iPod/i.test(navigator.userAgent)
  }

  // Vérifier si la PWA est installée (nécessaire pour iOS)
  isPWAInstalled() {
    return window.matchMedia('(display-mode: standalone)').matches || 
           window.navigator.standalone === true ||
           document.referrer.includes('android-app://')
  }

  // Vérifier si les notifications sont supportées sur cette plateforme
  isNotificationSupported() {
    if (!('Notification' in window)) {
      console.warn('Notifications API not supported')
      return false
    }
    if (!('serviceWorker' in navigator)) {
      console.warn('Service Worker API not supported')
      return false
    }
    if (!('PushManager' in window)) {
      console.warn('Push API not supported')
      return false
    }

    // Sur iOS, les notifications push ne fonctionnent que si la PWA est installée (iOS 16.4+)
    if (this.isIOS()) {
      if (!this.isPWAInstalled()) {
        console.warn('iOS: Notifications push require PWA to be installed (added to home screen)')
        return false
      }
      
      // Vérifier la version iOS (approximatif via user agent)
      const iosVersion = navigator.userAgent.match(/OS (\d+)_(\d+)/)
      if (iosVersion) {
        const major = parseInt(iosVersion[1], 10)
        const minor = parseInt(iosVersion[2], 10)
        if (major < 16 || (major === 16 && minor < 4)) {
          console.warn('iOS: Push notifications require iOS 16.4 or later')
          return false
        }
      }
    }

    return true
  }

  startPolling() {
    // Le polling est conservé comme fallback pour les notifications in-app
    // ou si le push n'est pas supporté/activé
    if (this.isPolling) return
    
    const authStore = useAuthStore()
    if (!authStore.isAuthenticated) return

    this.isPolling = true
    
    // Récupérer immédiatement
    this.fetchNotifications()
    
    // Puis toutes les 30 secondes
    this.pollingInterval = setInterval(() => {
      this.fetchNotifications()
    }, this.pollInterval)
  }

  stopPolling() {
    if (this.pollingInterval) {
      clearInterval(this.pollingInterval)
      this.pollingInterval = null
    }
    this.isPolling = false
  }

  async fetchNotifications() {
    const authStore = useAuthStore()
    if (!authStore.isAuthenticated) {
      this.stopPolling()
      return
    }

    try {
      // Juste mettre à jour le store (compteur, liste)
      // Les notifications push sont gérées par le service worker
      await authStore.fetchNotifications()
    } catch (error) {
      console.error('Error polling notifications:', error)
    }
  }

  showNotificationBadge() {
    // Mettre à jour le badge du titre de la page
    if ('Notification' in window && Notification.permission === 'granted') {
      // La notification push sera gérée par le service worker
      return
    }
  }

  // Récupérer la clé publique VAPID depuis le backend
  async getVapidPublicKey() {
    if (this.vapidPublicKey) return this.vapidPublicKey
    
    try {
      const response = await axios.get('/api/push/vapid-public-key')
      this.vapidPublicKey = response.data.public_key
      return this.vapidPublicKey
    } catch (error) {
      console.error('Error fetching VAPID public key:', error)
      return null
    }
  }

  // S'abonner aux notifications push
  async subscribeToPush() {
    if (!this.isNotificationSupported()) return false
    
    try {
      const registration = await navigator.serviceWorker.ready
      const publicKey = await this.getVapidPublicKey()
      
      if (!publicKey) {
        console.error('No VAPID public key available')
        return false
      }
      
      const convertedVapidKey = urlBase64ToUint8Array(publicKey)
      
      const subscription = await registration.pushManager.subscribe({
        userVisibleOnly: true,
        applicationServerKey: convertedVapidKey
      })
      
      console.log('✅ Push subscription successful:', subscription)
      
      // Envoyer l'abonnement au backend
      await axios.post('/api/push/subscribe', {
        endpoint: subscription.endpoint,
        keys: {
          p256dh: btoa(String.fromCharCode.apply(null, new Uint8Array(subscription.getKey('p256dh')))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, ''),
          auth: btoa(String.fromCharCode.apply(null, new Uint8Array(subscription.getKey('auth')))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
        }
      })
      
      return true
    } catch (error) {
      console.error('Error subscribing to push:', error)
      return false
    }
  }

  // Gestion des notifications push PWA
  async requestNotificationPermission() {
    console.log('🔔 requestNotificationPermission appelée')
    
    if (!this.isNotificationSupported()) {
      return false
    }

    if (Notification.permission === 'granted') {
      console.log('✅ Notification permission already granted')
      // S'assurer qu'on est bien abonné au push
      this.subscribeToPush()
      return true
    }

    if (Notification.permission === 'denied') {
      console.warn('❌ Notification permission denied by user')
      return false
    }

    // Sur iOS, s'assurer que la PWA est installée avant de demander
    if (this.isIOS() && !this.isPWAInstalled()) {
      console.warn('⚠️ iOS: Cannot request notification permission - PWA must be installed first')
      return false
    }

    try {
      console.log('🔔 Demande de permission...')
      const permission = await Notification.requestPermission()
      const granted = permission === 'granted'
      
      if (granted) {
        console.log('✅ Notification permission granted')
        await this.subscribeToPush()
      } else {
        console.warn('❌ Notification permission denied:', permission)
      }
      
      return granted
    } catch (error) {
      console.error('❌ Error requesting notification permission:', error)
      return false
    }
  }

  async showPushNotification(title, options = {}) {
    // Cette méthode est maintenant principalement utilisée pour les tests
    // ou les notifications locales générées par le client
    
    if (!this.isNotificationSupported()) return null
    if (Notification.permission !== 'granted') return null

    // Toujours utiliser le service worker pour les notifications push
    if ('serviceWorker' in navigator) {
      try {
        const registration = await navigator.serviceWorker.ready
        if (!registration.active) return null
        
        await registration.showNotification(title, {
          icon: '/icon-192x192.png',
          badge: '/icon-96x96.png',
          tag: 'lediscord-notification',
          ...options
        })
        return true
      } catch (error) {
        console.error('Error showing notification:', error)
      }
    }
    return null
  }

  // Écouter les messages du service worker pour les notifications push
  setupServiceWorkerListener() {
    if ('serviceWorker' in navigator) {
      navigator.serviceWorker.addEventListener('message', (event) => {
        if (event.data && event.data.type === 'NOTIFICATION') {
          // Notification reçue via message (fallback)
          console.log('Notification message received:', event.data)
        }
      })
    }
  }

  // Fonction de test pour vérifier que les notifications fonctionnent
  async testNotification() {
    console.log('🧪 Test de notification...')
    const result = await this.showPushNotification('Test LeDiscord', {
      body: 'Si vous voyez cette notification, les notifications push fonctionnent !',
      link: '/'
    })
    
    if (result) {
      console.log('✅ Test réussi - notification affichée')
      return true
    } else {
      console.warn('⚠️ Test échoué - notification non affichée')
      return false
    }
  }
}

export default new NotificationService()

