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

/**
 * Hook for sending transactions with the connected wallet
 * @returns Object containing sendTransaction function, loading state, and transaction result
 * @throws Error if used outside of ConnectionProvider
 * @example
 * ```tsx
 * const { sendTransaction, isLoading, transactionResult } = useTransaction()
 *
 * const handleSend = async () => {
 *   try {
 *     const result = await sendTransaction({
 *       to: '0x...',
 *       amount: BigInt('1000000000000000000'),
 *       from: session.activeAddress
 *     })
 *     console.log('Transaction hash:', result.hash)
 *   } catch (error) {
 *     console.error('Transaction failed:', error)
 *   }
 * }
 * ```
 */
export function useTransaction(): UseTransactionReturn {
  const context = useContext(ConnectionContext)

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

  const { connector, session } = context
  const [isLoading, setIsLoading] = useState(false)
  const [transactionResult, setTransactionResult] = useState<
    TransactionResult | undefined
  >()
  const [error, setError] = useState<WalletError | undefined>()

  const sendTransaction = useCallback(
    async (request: TransactionRequest): Promise<TransactionResult> => {
      if (!session.activeAddress) {
        throw new Error('No wallet connected')
      }

      if (!request) {
        throw new Error('Transaction request is required')
      }

      setIsLoading(true)
      setError(undefined)
      try {
        const result = await connector.sendTransaction(request)
        setTransactionResult(result)
        return result
      } catch (err) {
        const walletError = err as WalletError
        setError(walletError)
        throw err
      } finally {
        setIsLoading(false)
      }
    },
    [connector, session.activeAddress]
  )

  return {
    sendTransaction,
    isLoading,
    transactionResult,
    error
  }
}