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

/**
 * Hook for signing messages with the connected wallet
 * @returns Object containing signMessage function, loading state, and last signature
 * @throws Error if used outside of ConnectionProvider
 * @example
 * ```tsx
 * const { signMessage, isLoading, signature } = useSignMessage()
 *
 * const handleSign = async () => {
 *   try {
 *     const sig = await signMessage('Hello World')
 *     console.log('Signature:', sig)
 *     // signature state will also be updated with the result
 *   } catch (error) {
 *     console.error('Failed to sign:', error)
 *   }
 * }
 * ```
 */
export function useSignMessage(): UseSignMessageReturn {
  const context = useContext(ConnectionContext)

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

  const { connector, session } = context
  const [isLoading, setIsLoading] = useState(false)
  const [signature, setSignature] = useState<SignatureType | undefined>()
  const [error, setError] = useState<WalletError | undefined>()

  const signMessage = useCallback(
    async (message: string): Promise<SignatureType> => {
      if (!session.activeAddress) {
        throw new Error('No wallet connected')
      }

      if (!message) {
        throw new Error('Message is required')
      }

      setIsLoading(true)
      setError(undefined)
      try {
        const sig = await connector.signMessage(message)
        setSignature(sig)
        return sig
      } catch (err) {
        const walletError = err as WalletError
        setError(walletError)
        throw err
      } finally {
        setIsLoading(false)
      }
    },
    [connector, session.activeAddress]
  )

  return {
    signMessage,
    isLoading,
    signature,
    error
  }
}