// tests/transfer-action.test.ts
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { TransferByLinkAction } from '../actions/transfer-by-link';
import { PrexClient } from '../prex-client';
import { PrexSigner } from '../core/sign';
import { PrexApiService } from '../api';
import { PrexUser } from '../types';
import { Address } from 'viem';
import { PrexStorage } from '../storage/PrexStorage';
import { Logger } from '../utils/logger';
import { hexToBase64 } from '../utils/base64';

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

describe('TransferByLinkAction', () => {
  let transferByLinkAction: TransferByLinkAction;
  let mockClient: PrexClient;
  let mockSigner: PrexSigner;
  let mockApiService: PrexApiService;
  let mockUser: PrexUser;
  let mockStorage: PrexStorage;
  let mockLogger: Logger;

  beforeEach(() => {
    mockClient = {
      updatePermit2Nonce: vi.fn(() => 1n),
      getPermit2Nonce: vi.fn(() => 1n),
      fetchBalance: vi.fn(),
      evmChainClient: {
        readContract: vi
          .fn()
          .mockResolvedValue([
            1n,
            TOKEN_ADDRESS,
            USER_ADDRESS,
            USER_ADDRESS,
            1n,
            1n,
            1,
          ]),
        estimateGas: vi.fn(() => 1000000n),
      },
      logger: {
        debug: vi.fn(),
      },
    } as unknown as PrexClient;
    mockSigner = {
      chainId: 1337,
      signTypedData: vi.fn(),
    } as unknown as PrexSigner;
    mockApiService = {
      chainId: 1337,
      submitLinkTransfer: vi.fn(),
      getMessage: vi.fn(() => ({
        request: {
          nonce: 1n,
        },
      })),
      confirmLinkTransfer: vi.fn(),
    } as unknown as PrexApiService;
    mockStorage = {
      setItem: vi.fn(),
    } as unknown as PrexStorage;
    mockLogger = {
      debug: vi.fn(),
    } as unknown as Logger;

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

    transferByLinkAction = new TransferByLinkAction(
      mockClient,
      mockApiService,
      mockStorage,
      mockLogger,
      mockUser,
      mockSigner
    );
  });

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

    await transferByLinkAction.transferByLink({
      token: TOKEN_ADDRESS as Address,
      amount: 1n,
      expiration: 100,
    });

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

  it('receive link transfer', async () => {
    vi.mocked(mockApiService.confirmLinkTransfer).mockResolvedValue({
      hash: '0x123',
    });

    const secret = hexToBase64(
      '0x0000000000000000000000000000000000000000000000000000000000000005'
    );

    await transferByLinkAction.receiveLinkTransfer({
      secret,
    });

    expect(mockApiService.confirmLinkTransfer).toHaveBeenCalled();
  });
});