import { describe, it, expect, vi, beforeEach } from 'vitest'
import { usePhoneCard } from '../use-phone-card'
import { DepositMethodEnum } from '#lib/enums/deposit'
import { ref } from 'vue'
import type { PhoneCardDepositRequest } from '#lib/types/deposit'
import type { BaseNadalResponse } from '#lib/types/api'

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

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

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

const mockStore = {
  phoneCardProviders: [
    { providerId: '1', providerName: 'Provider A' },
    { providerId: '2', providerName: 'Provider B' },
  ],
}

const mockDepositData = {
  fetchPhoneCardProviders: vi.fn(),
}

// Mock dependencies
vi.mock('nuxt/app', () => ({
  useNuxtApp: vi.fn(),
}))

vi.mock('#lib/composables', () => ({
  usePromotion: () => mockPromotion,
  useDepositData:() => mockDepositData,
  useCancelPromotion: () => mockCancelPromotion,
  useNadal: () => mockNadal,
}))

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

describe('usePhoneCard', () => {

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

  it('should return card providers with correct metadata', () => {
    const { cardProviders } = usePhoneCard()

    expect(cardProviders.value).toEqual([
      {
        providerId: '1',
        providerName: 'Provider A',
        value: '1',
        label: 'Provider A',
      },
      {
        providerId: '2',
        providerName: 'Provider B',
        value: '2',
        label: 'Provider B',
      },
    ])
  })

  it('should call depositCard if not welcome type', async () => {
    const { onCreateDeposit } = usePhoneCard()
    const mockRequestData: PhoneCardDepositRequest = {
      cardNumber: '1234567890',
      cardSerial: '123456',
      amount: 100,
      providerId: '1',
    }

    const mockResponse: BaseNadalResponse = { success: true }

    mockNadal.payment.depositCard.mockResolvedValue(mockResponse)

    const result = await onCreateDeposit(mockRequestData)

    expect(mockCancelPromotion.openModalCancelPromotion).not.toHaveBeenCalled()
    expect(mockNadal.payment.depositCard).toHaveBeenCalledWith({
      ...mockRequestData,
      method: DepositMethodEnum.PhoneCard,
    })
    expect(result).toEqual(mockResponse)
  })

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

    const { onCreateDeposit } = usePhoneCard()
    const mockRequestData: PhoneCardDepositRequest = {
      cardNumber: '1234567890',
      cardSerial: '123456',
      amount: 100,
      providerId: '1',
    }

    const result = await onCreateDeposit(mockRequestData)

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

  it('should fetch phone card providers and promotion packages', async () => {
    const { fetchData } = usePhoneCard()

    await fetchData()

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