// tests/transfer-action.test.ts
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { TransferAction } from '../actions/transfer';
import { PrexClient } from '../prex-client';
import { PrexSigner } from '../core/sign';
import { PrexApiService } from '../api';
import { PrexUser } from '../types';
import { Address } from 'viem';

const TOKEN_ADDRESS = '0x0000000000000000000000000000000000000001' as Address;
const USER_ADDRESS = '0x0000000000000000000000000000000000000002' as Address;

describe('TransferAction', () => {
  let transferAction: TransferAction;
  let mockClient: PrexClient;
  let mockSigner: PrexSigner;
  let mockApiService: PrexApiService;
  let mockUser: PrexUser;

  beforeEach(() => {
    mockClient = {
      updatePermit2Nonce: vi.fn(),
      getPermit2Nonce: vi.fn(() => 1n),
      fetchBalance: vi.fn(),
      evmChainClient: {
        estimateGas: vi.fn(() => 1000000n),
      },
      logger: {
        debug: vi.fn(),
      },
    } as unknown as PrexClient;
    mockSigner = {
      signTypedData: vi.fn(),
    } as unknown as PrexSigner;
    mockApiService = {
      chainId: 1337,
      transfer: vi.fn(),
    } as unknown as PrexApiService;

    mockUser = {
      id: 'user-id',
      name: 'Test User',
      address: USER_ADDRESS,
      walletId: 'wallet-id',
    } as unknown as PrexUser;

    transferAction = new TransferAction(
      mockClient,
      mockUser,
      mockSigner,
      mockApiService
    );
  });

  it('succeed to transfer', async () => {
    vi.mocked(mockSigner.signTypedData).mockResolvedValue('0x00');
    vi.mocked(mockApiService.transfer).mockResolvedValue({
      hash: '0x123',
    });

    await transferAction.transfer({
      token: TOKEN_ADDRESS as Address,
      recipient: USER_ADDRESS,
      amount: 1n,
    });

    expect(mockSigner.signTypedData).toHaveBeenCalled();
    expect(mockApiService.transfer).toHaveBeenCalled();
  });

  it('succeed to transfer with nonce', async () => {
    vi.mocked(mockSigner.signTypedData).mockResolvedValue('0x00');
    vi.mocked(mockApiService.transfer).mockResolvedValue({
      hash: '0x123',
    });

    await transferAction.transfer(
      {
        token: TOKEN_ADDRESS as Address,
        recipient: USER_ADDRESS,
        amount: 1n,
      },
      {
        nonce: 531n,
      }
    );

    expect(mockSigner.signTypedData).toHaveBeenCalledWith(
      {
        domain: {
          chainId: 1337,
          name: 'Permit2',
          verifyingContract: '0x000000000022d473030f116ddee9f6b43ac78ba3',
        },
        types: expect.anything(),
        message: {
          deadline: expect.anything(),
          nonce: 531n,
          permitted: expect.anything(),
          witness: expect.anything(),
          spender: expect.anything(),
        },
        primaryType: 'PermitWitnessTransferFrom',
      },
      USER_ADDRESS
    );
    expect(mockApiService.transfer).toHaveBeenCalled();
  });
});