import { useState, useEffect, useCallback } from 'react'
import { 
  isPermissionGranted, 
  requestPermission, 
  sendNotification,
  createChannel,
  type Options as NotificationOptions,
  type PermissionState 
} from '@tauri-apps/plugin-notification'
import { platform } from '@tauri-apps/plugin-os'

interface NotificationHookReturn {
  permission: PermissionState | null
  isInitialized: boolean
  isLoading: boolean
  error: Error | null
  requestPermission: () => Promise<boolean>
  notify: (title: string, body?: string, options?: Partial<NotificationOptions>) => Promise<boolean>
  notifyWithChannel: (channelId: string, title: string, body?: string, options?: Partial<NotificationOptions>) => Promise<boolean>
}

export function useNotifications(): NotificationHookReturn {
  const [permission, setPermission] = useState<PermissionState | null>(null)
  const [isInitialized, setIsInitialized] = useState(false)
  const [isLoading, setIsLoading] = useState(true)
  const [error, setError] = useState<Error | null>(null)

  useEffect(() => {
    let mounted = true

    async function init() {
      try {
        setIsLoading(true)
        
        // Check initial permission
        const granted = await isPermissionGranted()
        if (mounted) {
          setPermission(granted ? 'granted' : 'denied')
        }

        // Get current platform
        const currentPlatform = await platform()

        // Android: Create default channel
        if (currentPlatform === 'android') {
          try {
            await createChannel({
              id: 'default',
              name: 'General',
              description: 'Default notification channel'
            })
          } catch (err) {
            console.warn('Failed to create notification channels:', err)
          }
        }

        // Note: Advanced notification actions are available but not implemented in this demo
        // See Tauri notification plugin documentation for action types and listeners

        if (mounted) {
          setIsInitialized(true)
          setError(null)
        }
      } catch (err) {
        console.error('Failed to initialize notifications:', err)
        if (mounted) {
          setError(err as Error)
        }
      } finally {
        if (mounted) {
          setIsLoading(false)
        }
      }
    }

    init()

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

  const requestNotificationPermission = useCallback(async (): Promise<boolean> => {
    try {
      setIsLoading(true)
      const result = await requestPermission()
      // Map NotificationPermission to PermissionState
      const mappedPermission: PermissionState = result === 'granted' ? 'granted' : 
                                               result === 'denied' ? 'denied' : 'prompt'
      setPermission(mappedPermission)
      return result === 'granted'
    } catch (err) {
      console.error('Failed to request permission:', err)
      setError(err as Error)
      return false
    } finally {
      setIsLoading(false)
    }
  }, [])

  const notify = useCallback(async (
    title: string, 
    body?: string, 
    options?: Partial<NotificationOptions>
  ): Promise<boolean> => {
    try {
      // Check permission first
      if (permission !== 'granted') {
        const granted = await requestNotificationPermission()
        if (!granted) {
          console.warn('Notification permission denied')
          return false
        }
      }

      // Send notification
      await sendNotification({
        title,
        body: body || '',
        ...options
      })
      
      return true
    } catch (err) {
      console.error('Failed to send notification:', err)
      setError(err as Error)
      return false
    }
  }, [permission, requestNotificationPermission])

  const notifyWithChannel = useCallback(async (
    channelId: string,
    title: string, 
    body?: string, 
    options?: Partial<NotificationOptions>
  ): Promise<boolean> => {
    return notify(title, body, { ...options, channelId })
  }, [notify])

  return {
    permission,
    isInitialized,
    isLoading,
    error,
    requestPermission: requestNotificationPermission,
    notify,
    notifyWithChannel
  }
}