import Meld from '.'
import Mpc from '../../../mpc'

const mockMeldCreateCustomerResponse = {
  data: { id: 'cust-1', accountId: 'acc-1', externalId: 'ext-1' },
}
const mockMeldSearchCustomerResponse = {
  data: { customers: [], count: 0, remaining: 0 },
}
const mockMeldGetRetailQuoteResponse = {
  data: { quotes: [] },
}
const mockMeldCreateRetailWidgetResponse = {
  data: { id: 'sess-1', token: 'tok-1', customerId: 'cust-1', externalCustomerId: 'ext-1', externalSessionId: 'ses-1', widgetUrl: 'https://widget.meld.io' },
}
const mockMeldSearchRetailTransactionsResponse = {
  data: { transactions: [], count: 0, remaining: 0, totalCount: 0 },
}
const mockMeldGetRetailTransactionResponse = {
  data: { transaction: { id: 'tx-1', sessionId: 'ses-1', status: 'COMPLETED', transactionType: 'BUY', serviceProvider: 'STRIPE', createdAt: '2024-01-01', updatedAt: '2024-01-01' } },
}
const mockMeldDiscoveryResponse = { data: [] }

const buildMpcMock = () =>
  ({
    meldCreateCustomer: jest.fn().mockResolvedValue(mockMeldCreateCustomerResponse),
    meldSearchCustomer: jest.fn().mockResolvedValue(mockMeldSearchCustomerResponse),
    meldGetRetailQuote: jest.fn().mockResolvedValue(mockMeldGetRetailQuoteResponse),
    meldCreateRetailWidget: jest.fn().mockResolvedValue(mockMeldCreateRetailWidgetResponse),
    meldSearchRetailTransactions: jest.fn().mockResolvedValue(mockMeldSearchRetailTransactionsResponse),
    meldGetRetailTransactionBySession: jest.fn().mockResolvedValue(mockMeldGetRetailTransactionResponse),
    meldGetRetailTransaction: jest.fn().mockResolvedValue(mockMeldGetRetailTransactionResponse),
    meldGetServiceProviders: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetCountries: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetFiatCurrencies: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetCryptoCurrencies: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetPaymentMethods: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetDefaults: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetBuyLimits: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetSellLimits: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
    meldGetKycLimits: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
  }) as unknown as Mpc

describe('Meld', () => {
  let mpcMock: Mpc
  let meld: Meld

  beforeEach(() => {
    mpcMock = buildMpcMock()
    meld = new Meld({ mpc: mpcMock })
  })

  it('createCustomer delegates to mpc.meldCreateCustomer', async () => {
    const req = { email: 'user@example.com', type: 'INDIVIDUAL' as const }
    const result = await meld.createCustomer(req)

    expect(mpcMock.meldCreateCustomer).toHaveBeenCalledWith(req)
    expect(result).toEqual(mockMeldCreateCustomerResponse)
  })

  it('searchCustomer delegates to mpc.meldSearchCustomer', async () => {
    const result = await meld.searchCustomer()

    expect(mpcMock.meldSearchCustomer).toHaveBeenCalled()
    expect(result).toEqual(mockMeldSearchCustomerResponse)
  })

  it('getRetailQuote delegates to mpc.meldGetRetailQuote', async () => {
    const req = { countryCode: 'US', sourceCurrencyCode: 'USD', destinationCurrencyCode: 'ETH', sourceAmount: 100 }
    const result = await meld.getRetailQuote(req)

    expect(mpcMock.meldGetRetailQuote).toHaveBeenCalledWith(req)
    expect(result).toEqual(mockMeldGetRetailQuoteResponse)
  })

  it('createRetailWidget delegates to mpc.meldCreateRetailWidget', async () => {
    const req = {
      sessionType: 'BUY' as const,
      sessionData: {
        countryCode: 'US',
        serviceProvider: 'STRIPE',
        sourceCurrencyCode: 'USD',
        sourceAmount: '100',
        destinationCurrencyCode: 'ETH',
      },
    }
    const result = await meld.createRetailWidget(req)

    expect(mpcMock.meldCreateRetailWidget).toHaveBeenCalledWith(req)
    expect(result).toEqual(mockMeldCreateRetailWidgetResponse)
  })

  it('searchRetailTransactions delegates to mpc.meldSearchRetailTransactions without params', async () => {
    const result = await meld.searchRetailTransactions()

    expect(mpcMock.meldSearchRetailTransactions).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldSearchRetailTransactionsResponse)
  })

  it('searchRetailTransactions delegates with params when provided', async () => {
    const params = { status: 'COMPLETED' }
    await meld.searchRetailTransactions(params)

    expect(mpcMock.meldSearchRetailTransactions).toHaveBeenCalledWith(params)
  })

  it('getRetailTransactionBySession delegates to mpc.meldGetRetailTransactionBySession', async () => {
    const result = await meld.getRetailTransactionBySession('ses-1')

    expect(mpcMock.meldGetRetailTransactionBySession).toHaveBeenCalledWith('ses-1')
    expect(result).toEqual(mockMeldGetRetailTransactionResponse)
  })

  it('getRetailTransaction delegates to mpc.meldGetRetailTransaction', async () => {
    const result = await meld.getRetailTransaction('tx-1')

    expect(mpcMock.meldGetRetailTransaction).toHaveBeenCalledWith('tx-1')
    expect(result).toEqual(mockMeldGetRetailTransactionResponse)
  })

  it('getServiceProviders delegates to mpc.meldGetServiceProviders', async () => {
    const params = { countries: 'US' }
    const result = await meld.getServiceProviders(params)

    expect(mpcMock.meldGetServiceProviders).toHaveBeenCalledWith(params)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getServiceProviders without params delegates undefined', async () => {
    await meld.getServiceProviders()
    expect(mpcMock.meldGetServiceProviders).toHaveBeenCalledWith(undefined)
  })

  it('getCountries delegates to mpc.meldGetCountries', async () => {
    const result = await meld.getCountries()

    expect(mpcMock.meldGetCountries).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getFiatCurrencies delegates to mpc.meldGetFiatCurrencies', async () => {
    const result = await meld.getFiatCurrencies()

    expect(mpcMock.meldGetFiatCurrencies).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getCryptoCurrencies delegates to mpc.meldGetCryptoCurrencies', async () => {
    const result = await meld.getCryptoCurrencies()

    expect(mpcMock.meldGetCryptoCurrencies).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getPaymentMethods delegates to mpc.meldGetPaymentMethods', async () => {
    const result = await meld.getPaymentMethods()

    expect(mpcMock.meldGetPaymentMethods).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getDefaults delegates to mpc.meldGetDefaults', async () => {
    const result = await meld.getDefaults()

    expect(mpcMock.meldGetDefaults).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getBuyLimits delegates to mpc.meldGetBuyLimits', async () => {
    const result = await meld.getBuyLimits()

    expect(mpcMock.meldGetBuyLimits).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getSellLimits delegates to mpc.meldGetSellLimits', async () => {
    const result = await meld.getSellLimits()

    expect(mpcMock.meldGetSellLimits).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })

  it('getKycLimits delegates to mpc.meldGetKycLimits', async () => {
    const result = await meld.getKycLimits()

    expect(mpcMock.meldGetKycLimits).toHaveBeenCalledWith(undefined)
    expect(result).toEqual(mockMeldDiscoveryResponse)
  })
})