import { describe, it, expect, vi, beforeEach } from 'vitest'
import { useUserBank } from '../use-user-bank'
import type { BankResponseData } from '@kira-dancer/nadal'
import type { UserBankItem } from '#lib/types'

// Mock dependencies
const mockNuxtApp = {
  $account: {
    banks: vi.fn(),
    addBankAccount: vi.fn(),
  },
}

const mockNadal = {
  account: {
    banks: vi.fn(),
    addBankAccount: vi.fn(),
  },
}

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

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

describe('useUserBank', () => {
  beforeEach(() => {
    vi.clearAllMocks()
  })

  it('should fetch user banks and filter out disabled banks', async () => {
    // Arrange
    const mockBankResponse: UserBankItem[] = [
      { bank_name: 'bank1', is_disable: true },
      { bank_name: 'bank2', is_disable: false, last_updated_time: '2021-01-02 00:00:01' },
      { bank_name: 'bank3', is_disable: false, last_updated_time: '2021-01-02 00:00:03' },
      { bank_name: 'bank4', is_disable: false, last_updated_time: '2021-01-02 00:00:02' },
    ]

    const expectResult: UserBankItem[] = [
      { bank_name: 'bank3', is_disable: false, last_updated_time: '2021-01-02 00:00:03' },
      { bank_name: 'bank4', is_disable: false, last_updated_time: '2021-01-02 00:00:02' },
      { bank_name: 'bank2', is_disable: false, last_updated_time: '2021-01-02 00:00:01' },
    ]

    mockNadal.account.banks.mockResolvedValueOnce(mockBankResponse)

    const { fetchUserBanks } = useUserBank()

    // Act
    const result = await fetchUserBanks()

    // Assert
    expect(result).toEqual(expectResult)
    expect(mockNadal.account.banks).toHaveBeenCalledTimes(1)
  })

  it('should return an empty array when no banks are returned', async () => {
    // Arrange
    mockNadal.account.banks.mockResolvedValueOnce([])

    const { fetchUserBanks } = useUserBank()

    // Act
    const result = await fetchUserBanks()

    // Assert
    expect(result).toEqual([])
    expect(mockNadal.account.banks).toHaveBeenCalledTimes(1)
  })

  it('should add a new bank and refresh the user banks', async () => {
    // Arrange
    const mockUserBank: UserBankItem = { id: 1, is_disable: false }

    mockNadal.account.addBankAccount.mockResolvedValueOnce(undefined)

    const { onAddBank } = useUserBank()

    // Act
    await onAddBank(mockUserBank)

    // Assert
    expect(mockNadal.account.addBankAccount).toHaveBeenCalledWith(
      mockUserBank,
    )
  })

  it('should correctly set loading status while fetching user banks', async () => {
    // Arrange
    mockNadal.account.banks.mockResolvedValueOnce([])

    const { fetchUserBanks, isLoading } = useUserBank()

    // Act
    await fetchUserBanks()
    expect(isLoading.value).toBe(false)
  })

  it('should update userBanks correctly after fetching data', async () => {
    // Arrange
    const mockBankResponse: BankResponseData[] = [
      { bank_name: 'bank1', is_disable: false },
      { bank_name: 'bank2', is_disable: true },
    ]
    mockNadal.account.banks.mockResolvedValueOnce(mockBankResponse)

    const { fetchUserBanks, userBanks } = useUserBank()

    // Act
    const result = await fetchUserBanks()

    // Assert
    expect(result).toEqual([{ bank_name: 'bank1', is_disable: false }])
    expect(userBanks.value).toEqual([{ bank_name: 'bank1', is_disable: false }])
    expect(mockNadal.account.banks).toHaveBeenCalledTimes(1)
  })
  
})