import { describe, it, expect, vi, beforeEach } from 'vitest'
import { useFastPay } from '../use-fastpay'
import { usePaymentStore } from '#lib/stores/payment'
import { usePromotion, useCancelPromotion } from '#lib/composables/promotion'
import { useDepositData } from '#lib/composables/deposit/use-deposit-data'
import { valueToNumber } from '#lib/utils'
import { ref } from 'vue'
import type { GetFastPayRequest, FastPayInfoResponse } from '#lib/types'

const mockNadal = {
  payment: {
    codePayQrcode: vi.fn(),
    requestNicepayInvoice: vi.fn(),
  },
}

vi.mock('#lib/stores/payment', () => ({
  usePaymentStore: vi.fn(),
}))

vi.mock('#lib/composables', () => ({
  useNadal: () => mockNadal,
}))

vi.mock('#lib/composables/promotion', () => ({
  usePromotion: vi.fn(),
  useCancelPromotion: vi.fn(),
}))

vi.mock('#lib/composables/deposit/use-deposit-data', () => ({
  useDepositData: vi.fn(),
}))

vi.mock('#lib/utils', () => ({
  valueToNumber: vi.fn(),
}))

describe('useFastPay', () => {
  let mockPromotion: any
  let mockDepositStore: any
  let mockCancelPromotion: any
  let mockDepositData: any

  beforeEach(() => {
    vi.clearAllMocks()

    mockPromotion = {
      isUsingPromotion: ref(false),
      isWelcomeType: ref(false),
      promotionPackages: ref([]),
      fetchPromotionPackages: vi.fn(),
    }

    mockDepositStore = {
      depositFastPays: ref([]),
      fastpayCode: ref('FASTPAY123'),
    }

    mockCancelPromotion = {
      openModalCancelPromotion: vi.fn(),
    }

    mockDepositData = {
      formatBankList: vi.fn(),
      fetchFastpays: vi.fn(),
    }

    vi.mocked(usePromotion).mockReturnValue(mockPromotion)
    vi.mocked(usePaymentStore).mockReturnValue(mockDepositStore)
    vi.mocked(useCancelPromotion).mockReturnValue(mockCancelPromotion)
    vi.mocked(useDepositData).mockReturnValue(mockDepositData)
  })

  it('should return depositFastPays with additional metadata', () => {
    const formattedBanks = [
      { bank_code: '001', bankName: 'Bank A' },
      { bank_code: '002', bankName: 'Bank B' },
    ]
    mockDepositData.formatBankList.mockReturnValue(formattedBanks)
    mockDepositStore.depositFastPays = formattedBanks

    const { depositFastPays } = useFastPay()

    expect(depositFastPays.value).toEqual([
      { bank_code: '001', bankName: 'Bank A', value: '001', label: 'Bank A' },
      { bank_code: '002', bankName: 'Bank B', value: '002', label: 'Bank B' },
    ])
  })

  it('should return fastpayCode from the store', () => {
    mockDepositStore.fastpayCode = 'FASTPAY123'
    const { fastpayCode } = useFastPay()

    expect(fastpayCode.value).toBe('FASTPAY123')
  })

  it('should retrieve FastPay transfer info and generate QR code', async () => {
    const { fetchFastPayTransferInfo } = useFastPay()
    const mockRequestData: GetFastPayRequest = {
      amount: 1000,
      otherParam: 'value',
    }
    const mockResponseData: FastPayInfoResponse = {
      bank_code: '001',
      bank_account_no: '1234567890',
      content: 'Payment content',
    }
    const mockQRCodeURL = 'https://qrcode.example.com/qr.png'

    vi.mocked(valueToNumber).mockReturnValue(1)
    mockNadal.payment.requestNicepayInvoice.mockResolvedValue(
      mockResponseData,
    )
    mockNadal.payment.codePayQrcode.mockResolvedValue(mockQRCodeURL)

    const result = await fetchFastPayTransferInfo(mockRequestData)

    expect(mockNadal.payment.requestNicepayInvoice).toHaveBeenCalledWith({
      ...mockRequestData,
      amount: 1,
    })
    expect(mockNadal.payment.codePayQrcode).toHaveBeenCalledWith({
      bank_code: '001',
      bank_no: '1234567890',
      amount: 1,
      memo: 'Payment content',
    })
    expect(result).toEqual({
      ...mockResponseData,
      qrImage: mockQRCodeURL,
      amount: 1,
    })
  })

  it('should retrieve FastPay transfer info and generate QR code', async () => {
    const { fetchFastPayTransferInfo } = useFastPay()
    const mockRequestData: GetFastPayRequest = {
      amount: 1000,
      otherParam: 'value',
    }
    const mockResponseData: FastPayInfoResponse = {
      bank_code: '001',
      bank_account_no: '1234567890',
      content: 'Payment content',
    }
    const mockQRCodeURL = 'https://qrcode.example.com/qr.png'

    vi.mocked(valueToNumber).mockReturnValue(1)
    mockNadal.payment.requestNicepayInvoice.mockResolvedValue(
      mockResponseData,
    )
    mockNadal.payment.codePayQrcode.mockResolvedValue(mockQRCodeURL)

    const result = await fetchFastPayTransferInfo(mockRequestData)

    expect(mockNadal.payment.requestNicepayInvoice).toHaveBeenCalledWith({
      ...mockRequestData,
      amount: 1,
    })
    expect(mockNadal.payment.codePayQrcode).toHaveBeenCalledWith({
      bank_code: '001',
      bank_no: '1234567890',
      amount: 1,
      memo: 'Payment content',
    })
    expect(result).toEqual({
      ...mockResponseData,
      qrImage: mockQRCodeURL,
      amount: 1,
    })
  })

  it('should open cancel promotion modal if welcome type is true', async () => {
    mockPromotion.isUsingPromotion.value = true

    const { fetchFastPayTransferInfo } = useFastPay()
    const mockRequestData: GetFastPayRequest = {
      amount: 1000,
      otherParam: 'value',
    }

    const result = await fetchFastPayTransferInfo(mockRequestData)

    expect(mockCancelPromotion.openModalCancelPromotion).toHaveBeenCalled()
    expect(mockNadal.payment.requestNicepayInvoice).not.toHaveBeenCalled()
    expect(result).toBeUndefined()
  })

  it('should fetch FastPay data and promotion packages', async () => {
    const { fetchData } = useFastPay()

    await fetchData()

    expect(mockDepositData.fetchFastpays).toHaveBeenCalled()
    expect(mockPromotion.fetchPromotionPackages).toHaveBeenCalled()
  })
})