import { describe, it, expect, vi, beforeEach } from 'vitest'
import { useBanking } from '../use-banking'
import { useUserBankStore } from '#lib/stores'
import { useCancelPromotion, usePromotion } from '#lib/composables'
import { ref } from 'vue'
import type {
  PaymentDepositBankRequestPayload,
  PaymentBankAccountResponseData,
} from '@kira-dancer/nadal'
import type { BankListItem } from '#lib/types'

const mockNadal = {
  payment: {
    bankList: vi.fn(),
    depositBank: vi.fn(),
    bankAccount: vi.fn(),
  },
  account: {
    addBankAccount: vi.fn(),
  },
}

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

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

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

vi.mock('lodash/cloneDeep', () => ({
  default: vi.fn(),
}))

describe('useBanking', () => {
  let mockNuxtApp: any
  let mockBankStore: any
  let mockPromotion: any
  let mockCancelPromotion: any

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

    mockBankStore = {
      banks: ref([]),
      setBanks: vi.fn(),
    }

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

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

    vi.mocked(useUserBankStore).mockReturnValue(mockBankStore)
    vi.mocked(usePromotion).mockReturnValue(mockPromotion)
    vi.mocked(useCancelPromotion).mockReturnValue(mockCancelPromotion)
  })

  it('should fetch and set bank list via fetchData', async () => {
    const { fetchData } = useBanking()
    const mockBankList: BankListItem[] = [
      { bank_name: 'Bank A', isMaintained: false, bank_code: 'A' },
    ]

    mockNadal.payment.bankList.mockResolvedValue(mockBankList)

    await fetchData()

    expect(mockNadal.payment.bankList).toHaveBeenCalled()
    expect(mockBankStore.setBanks).toHaveBeenCalledWith([
      {
        bank_name: 'Bank A',
        isMaintained: false,
        bank_code: 'A',
        name: 'Bank A',
        bankName: 'Bank A',
      },
    ])
  })

  it('should create a deposit request when not using promotion', async () => {
    const { onCreateDeposit } = useBanking()
    const mockRequestData: PaymentDepositBankRequestPayload = {
      amount: 1_000,
      bank_code: 'A',
    }
    const mockResponse = { success: true }
    mockNadal.payment.depositBank.mockResolvedValue(mockResponse)

    const result = await onCreateDeposit(mockRequestData)

    expect(mockCancelPromotion.openModalCancelPromotion).not.toHaveBeenCalled()
    expect(mockNadal.payment.depositBank).toHaveBeenCalledWith({
      ...mockRequestData,
      amount: 1_000_000,
    })
    expect(result).toEqual(mockResponse)
  })

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

    const { onCreateDeposit } = useBanking()
    const mockRequestData: PaymentDepositBankRequestPayload = {
      amount: 1_000,
      bank_code: 'A',
    }

    const result = await onCreateDeposit(mockRequestData)

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

  it('should fetch bank info by bank code', async () => {
    const { getBankInfoByBankCode } = useBanking()
    const mockBankInfo: PaymentBankAccountResponseData = {
      bank_code: 'A',
      account_name: 'John Doe',
      account_no: '123456789',
      branch_name: 'Main Branch',
      bank_name: 'Bank A',
      smartpay_code: 'smartpay_code A',
      thumbnail: 'thumbnail A',
    }
    mockNadal.payment.bankAccount.mockResolvedValue(mockBankInfo)

    const result = await getBankInfoByBankCode('A')

    expect(mockNadal.payment.bankAccount).toHaveBeenCalledWith({
      bank_code: 'A',
    })
    expect(result).toEqual({
      ...mockBankInfo,
      account_no: '123456789',
      branch_name: 'Bank A - Main Branch',
      qr_code: '',
    })
  })

  it('should add a new bank account', async () => {
    const { addBankAccount } = useBanking()
    const mockRequestData = {
      withdrawBankCode: 'A',
      accountName: 'John Doe',
      accountNumber: '123456789',
    }
    const mockResponse = { success: true }

    mockNadal.account.addBankAccount.mockResolvedValue(mockResponse)

    const result = await addBankAccount(mockRequestData)

    expect(mockNadal.account.addBankAccount).toHaveBeenCalledWith({
      bank_code: 'A',
      bank_account_name: 'John Doe',
      bank_account_no: '123456789',
    })
    expect(result).toEqual(mockResponse)
  })

  it('should fetch bank lists and promotion packages via fetchData', async () => {
    const { fetchData } = useBanking()

    await fetchData()

    expect(mockNadal.payment.bankList).toHaveBeenCalled()
    expect(mockPromotion.fetchPromotionPackages).toHaveBeenCalled()
  })
})