use-send.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { renderHook, act, waitFor } from '@testing-library/react'
import { useSend } from './use-send'
import { Amount } from '@/types/amount'
import type { AssetInfo } from '@/types/asset'

const mockAsset: AssetInfo = {
  assetType: 'ETH',
  name: 'Ethereum',
  amount: Amount.fromRaw('1000000000000000000', 18, 'ETH'), // 1 ETH
  decimals: 18,
}

describe('useSend', () => {
  beforeEach(() => {
    vi.useFakeTimers()
  })

  afterEach(() => {
    vi.useRealTimers()
  })

  describe('Initial state', () => {
    it('starts with input step', () => {
      const { result } = renderHook(() => useSend())
      expect(result.current.state.step).toBe('input')
    })

    it('starts with empty values', () => {
      const { result } = renderHook(() => useSend())
      expect(result.current.state.toAddress).toBe('')
      expect(result.current.state.amount).toBeNull()
      expect(result.current.state.asset).toBeNull()
    })

    it('uses initial asset if provided', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      expect(result.current.state.asset).toEqual(mockAsset)
    })
  })

  describe('setToAddress', () => {
    it('updates address', () => {
      const { result } = renderHook(() => useSend())
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
      })
      expect(result.current.state.toAddress).toBe('0x1234567890abcdef1234567890abcdef12345678')
    })

    it('clears address error on change', () => {
      const { result } = renderHook(() => useSend())
      // Trigger validation error first
      act(() => {
        result.current.goToConfirm()
      })
      expect(result.current.state.addressError).not.toBeNull()

      // Now set valid address
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
      })
      expect(result.current.state.addressError).toBeNull()
    })
  })

  describe('setAmount', () => {
    it('updates amount', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('1.5', 18, 'ETH')
      act(() => {
        result.current.setAmount(amount)
      })
      expect(result.current.state.amount?.toFormatted()).toBe('1.5')
    })

    it('clears amount error on change', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      // Set valid address but empty amount
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.goToConfirm()
      })
      expect(result.current.state.amountError).not.toBeNull()

      // Now set amount
      const amount = Amount.fromFormatted('0.5', 18, 'ETH')
      act(() => {
        result.current.setAmount(amount)
      })
      expect(result.current.state.amountError).toBeNull()
    })
  })

  describe('setAsset', () => {
    it('updates asset without estimating fee before form completion', async () => {
      const { result } = renderHook(() => useSend())

      act(() => {
        result.current.setAsset(mockAsset)
      })
      expect(result.current.state.asset).toEqual(mockAsset)
      expect(result.current.state.feeLoading).toBe(false)
      expect(result.current.state.feeAmount).toBeNull()
      expect(result.current.state.feeSymbol).toBe('')
    })

    it('estimates fee after form becomes complete with debounce', async () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))

      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(Amount.fromFormatted('0.5', 18, 'ETH'))
      })

      act(() => {
        vi.advanceTimersByTime(299)
      })
      expect(result.current.state.feeAmount).toBeNull()
      expect(result.current.state.feeLoading).toBe(true)

      act(() => {
        vi.advanceTimersByTime(1)
      })

      expect(result.current.state.feeLoading).toBe(false)
      expect(result.current.state.feeAmount?.toFormatted()).toBe('0.002')
      expect(result.current.state.feeSymbol).toBe('ETH')
    })

    it('re-estimates fee after amount change with debounce', async () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))

      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(Amount.fromFormatted('0.5', 18, 'ETH'))
      })
      act(() => {
        vi.advanceTimersByTime(300)
      })
      expect(result.current.state.feeAmount?.toFormatted()).toBe('0.002')

      act(() => {
        result.current.setAmount(Amount.fromFormatted('0.6', 18, 'ETH'))
      })
      expect(result.current.state.feeLoading).toBe(true)

      act(() => {
        vi.advanceTimersByTime(299)
      })
      expect(result.current.state.feeAmount).toBeNull()

      act(() => {
        vi.advanceTimersByTime(1)
      })
      expect(result.current.state.feeLoading).toBe(false)
      expect(result.current.state.feeAmount?.toFormatted()).toBe('0.002')
    })
  })

  describe('canProceed', () => {
    it('returns false when address is empty', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('1', 18, 'ETH')
      act(() => {
        result.current.setAmount(amount)
      })
      expect(result.current.canProceed).toBe(false)
    })

    it('returns false when amount is empty', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
      })
      expect(result.current.canProceed).toBe(false)
    })

    it('returns false when asset is null', () => {
      const { result } = renderHook(() => useSend())
      const amount = Amount.fromFormatted('1', 18, 'ETH')
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
      })
      expect(result.current.canProceed).toBe(false)
    })

    it('returns true when all fields are valid', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('0.5', 18, 'ETH')
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
        result.current.setAsset(mockAsset)
      })
      act(() => {
        vi.advanceTimersByTime(300)
      })
      expect(result.current.canProceed).toBe(true)
    })
  })

  describe('goToConfirm', () => {
    it('returns false and sets error for empty address', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('1', 18, 'ETH')
      act(() => {
        result.current.setAmount(amount)
      })

      let success: boolean
      act(() => {
        success = result.current.goToConfirm()
      })

      expect(success!).toBe(false)
      expect(result.current.state.addressError).toBe('请输入收款地址')
      expect(result.current.state.step).toBe('input')
    })

    it('returns false and sets error for invalid address', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('1', 18, 'ETH')
      act(() => {
        result.current.setToAddress('invalid')
        result.current.setAmount(amount)
      })

      let success: boolean
      act(() => {
        success = result.current.goToConfirm()
      })

      expect(success!).toBe(false)
      expect(result.current.state.addressError).toBe('无效的地址格式')
    })

    it('returns false and sets error for empty amount', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
      })

      let success: boolean
      act(() => {
        success = result.current.goToConfirm()
      })

      expect(success!).toBe(false)
      expect(result.current.state.amountError).toBe('请输入金额')
    })

    it('returns false for insufficient balance', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('10', 18, 'ETH') // More than 1 ETH balance
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
      })

      let success: boolean
      act(() => {
        success = result.current.goToConfirm()
      })

      expect(success!).toBe(false)
      expect(result.current.state.amountError).toBe('余额不足')
    })

    it('returns true and goes to confirm for valid input', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('0.5', 18, 'ETH')
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
      })

      let success: boolean
      act(() => {
        success = result.current.goToConfirm()
      })

      expect(success!).toBe(true)
      expect(result.current.state.step).toBe('confirm')
    })
  })

  describe('goBack', () => {
    it('returns to input step', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('0.5', 18, 'ETH')
      // Go to confirm first
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
      })
      act(() => {
        result.current.goToConfirm()
      })
      expect(result.current.state.step).toBe('confirm')

      act(() => {
        result.current.goBack()
      })
      expect(result.current.state.step).toBe('input')
    })
  })

  describe('submit', () => {
    it('transitions to sending then result', async () => {
      vi.useRealTimers() // Need real timers for async

      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('0.5', 18, 'ETH')
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
        result.current.goToConfirm()
      })

      // Start submit
      act(() => {
        result.current.submit('password')
      })

      expect(result.current.state.step).toBe('sending')
      expect(result.current.state.isSubmitting).toBe(true)

      // Wait for completion
      await waitFor(() => {
        expect(result.current.state.step).toBe('result')
      }, { timeout: 3000 })

      expect(result.current.state.isSubmitting).toBe(false)
      expect(result.current.state.resultStatus).toBeDefined()
    })
  })

  describe('reset', () => {
    it('resets to initial state', () => {
      const { result } = renderHook(() => useSend({ initialAsset: mockAsset }))
      const amount = Amount.fromFormatted('0.5', 18, 'ETH')
      act(() => {
        result.current.setToAddress('0x1234567890abcdef1234567890abcdef12345678')
        result.current.setAmount(amount)
        result.current.goToConfirm()
      })

      act(() => {
        result.current.reset()
      })

      expect(result.current.state.step).toBe('input')
      expect(result.current.state.toAddress).toBe('')
      expect(result.current.state.amount).toBeNull()
      expect(result.current.state.asset).toEqual(mockAsset) // Keeps initial asset
    })
  })
})