import { useContext, useCallback, useState } from 'react'
import { ConnectionContext } from '../providers/ConnectionProvider'
import type {
  UseWalletCapabilitiesReturn,
  WalletError
} from '@meshconnect/uwc-types'

/**
 * Hook for managing wallet capabilities
 * @returns Wallet capabilities state and a fetch function to manually fetch capabilities
 * @throws Error if used outside of ConnectionProvider
 * @example
 * ```tsx
 * const { capabilities, networkCapabilities, isLoading, error, fetchCapabilities } = useWalletCapabilities()
 *
 * const handleFetchCapabilities = async () => {
 *   await fetchCapabilities()
 * }
 *
 * if (isLoading) {
 *   return <div>Loading capabilities...</div>
 * }
 *
 * if (capabilities?.['eip155:1']?.atomicBatching.supported) {
 *   console.log('Atomic batching is supported')
 * }
 * ```
 */
export function useWalletCapabilities(): UseWalletCapabilitiesReturn {
  const context = useContext(ConnectionContext)

  if (!context) {
    throw new Error(
      'useWalletCapabilities must be used within a ConnectionProvider'
    )
  }

  const { connector, session } = context

  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState<WalletError | undefined>()

  // Manual fetch function to be called from the app
  const fetchCapabilities = useCallback(async () => {
    // If no active session or address, clear capabilities
    if (!session?.activeAddress || !session?.connectionMode) {
      return
    }

    setIsLoading(true)
    setError(undefined)

    try {
      // Use provided network or find the active network from session
      const networkToUse = connector
        .getNetworks()
        .find(n => n.id === session.activeNetwork?.id)

      await connector.getWalletCapabilities(session.activeAddress, networkToUse)
    } catch (err) {
      const walletError = err as WalletError
      setError(walletError)
    } finally {
      setIsLoading(false)
    }
  }, [
    session?.activeAddress,
    session?.connectionMode,
    session?.activeNetwork,
    connector
  ])

  return {
    isLoading,
    error,
    fetchCapabilities
  }
}