import { describe, it, expect, jest } from '@jest/globals'
import {
  PacificaAccountAdapter,
  LeveragePayload,
  SubaccountPayload,
} from '../../../src/exchanges/pacifica/AccountAdapter'

describe('PacificaAccountAdapter', () => {
  const baseEndpoints = {
    accountInfo: '/api/v1/account/info',
    balances: '/api/v1/account/balance',
    positions: '/api/v1/account/positions',
    leverage: '/api/v1/account/leverage',
    subaccountCreate: '/api/v1/account/subaccount/create',
  } as const

  const createClientMock = () => {
    type SignResult = { timestamp: number; expiryWindow: number; signature: string }
    const signOperation =
      jest.fn<(type: string, data: Record<string, any>, expiryWindow?: number) => Promise<SignResult>>()
    const post = jest.fn<(path: string, body: any) => Promise<any>>()
    const get = jest.fn<(path: string, query?: Record<string, any>) => Promise<any>>()
    const requireAccount = jest.fn((acct?: string) => acct ?? 'mock-account')
    const client = {
      endpoints: baseEndpoints,
      signOperation,
      post,
      get,
      requireAccount,
    } as any
    return { client, signOperation, post, get, requireAccount }
  }

  it('updateLeverage signs payload and posts request body according to docs', async () => {
    const { client, signOperation, post } = createClientMock()
    signOperation.mockResolvedValue({ timestamp: 1716200000000, expiryWindow: 30000, signature: 'signed-value' })
    post.mockResolvedValue({ success: true })

    const adapter = new PacificaAccountAdapter(client)
    const payload: LeveragePayload = {
      account: '42trU9A5',
      symbol: 'BTC',
      leverage: 10,
      agentWallet: '69trU9A5',
      expiryWindow: 45000,
    }

    const result = await adapter.updateLeverage(payload)

    expect(signOperation).toHaveBeenCalledWith(
      'update_leverage',
      {
        account: payload.account,
        symbol: payload.symbol,
        leverage: payload.leverage,
        agent_wallet: payload.agentWallet,
      },
      payload.expiryWindow,
    )

    expect(post).toHaveBeenCalledWith(
      baseEndpoints.leverage,
      {
        account: payload.account,
        symbol: payload.symbol,
        leverage: payload.leverage,
        agent_wallet: payload.agentWallet,
        timestamp: 1716200000000,
        expiry_window: 30000,
        signature: 'signed-value',
      },
      { skipHeaderSig: true },
    )

    expect(result).toEqual({ success: true })
  })

  it('createSubaccount signs with both main and sub accounts', async () => {
    const { client, signOperation, post } = createClientMock()
    signOperation
      .mockResolvedValueOnce({ timestamp: 1000, expiryWindow: 30000, signature: 'main-sign' })
      .mockResolvedValueOnce({ timestamp: 2000, expiryWindow: 30000, signature: 'sub-sign' })
    post.mockResolvedValue({ success: true })

    const adapter = new PacificaAccountAdapter(client)
    const payload: SubaccountPayload = {
      mainAccount: 'main-account',
      subAccount: 'child-account',
      expiryWindow: 60000,
    }

    const result = await adapter.createSubaccount(payload)

    expect(signOperation).toHaveBeenNthCalledWith(
      1,
      'subaccount_initiate',
      {
        account: payload.mainAccount,
      },
      payload.expiryWindow,
    )
    expect(signOperation).toHaveBeenNthCalledWith(
      2,
      'subaccount_confirm',
      {
        signature: 'main-sign',
      },
      payload.expiryWindow,
    )

    expect(post).toHaveBeenCalledWith(
      baseEndpoints.subaccountCreate,
      expect.objectContaining({
        main_account: payload.mainAccount,
        subaccount: payload.subAccount,
        expiry_window: 30000,
        main_signature: 'sub-sign',
        sub_signature: 'main-sign',
      }),
      { skipHeaderSig: true },
    )

    expect(result).toEqual({ success: true })
  })
})