// @ts-nocheck
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { usePromotion } from '../use-promotion'
import { PromotionPlanEnum } from '#lib/enums'
import dayjs from 'dayjs'
import * as utils from '#lib/utils'
import { useNadal } from '#lib/composables'

// Mock dependencies
const mockPromotionStore = {
  promotionUser: {},
  getUserPlan: vi.fn(),
  getPackageId: vi.fn(),
  setPromotionUser: vi.fn(),
}

const mockPackageStore = {
  packages: [],
  setPackages: vi.fn(),
}

const mockNadal = {
  promotion: {
    promotion: vi.fn(),
    packages: vi.fn(),
    cancel: vi.fn(),
  },
}

vi.mock('#lib/stores', () => ({
  usePromotionStore: () => mockPromotionStore,
  usePackageStore: () => mockPackageStore,
  useUserPromotionStore: () => mockPromotionStore,
}))

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

vi.mock('#lib/utils', () => ({
  getWeekday: vi.fn(),
  formatDate: vi.fn(),
  formatUnitTime: vi.fn(),
  toUTCDate: vi.fn(),
  checkIsToday: vi.fn(),
  toDate: vi.fn(),
  checkIsTomorrow: vi.fn(),
  checkTimeUpcoming: vi.fn(),
  formatAmountUnit: vi.fn(),
}))

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

describe('usePromotion composable', () => {
  beforeEach(() => {
    // Reset the mocks before each test
    mockPromotionStore.getUserPlan.mockReset()
    mockPromotionStore.getPackageId.mockReset()
    mockNadal.promotion.promotion.mockReset()
    mockNadal.promotion.packages.mockReset()
    mockNadal.promotion.cancel.mockReset()
    vi.clearAllMocks()
  })

  it('should return default values when no promotion plan is available', () => {
    mockPromotionStore.getUserPlan.mockReturnValue(null)
    mockPromotionStore.getPackageId.mockReturnValue(null)

    const promotion = usePromotion()

    expect(promotion.isPromotionPlan.value).toBe(false)
    expect(promotion.timePromoteText.value).toBeNull()
  })

  it('should compute correct promotion percent', () => {
    mockPromotionStore.promotionUser = {
      calculated_turnover: 1000,
      multiplier: 10,
    }

    const { promotionPercent } = usePromotion()

    expect(promotionPercent.value).toBe(10000)
  })

  it('should fetch and set promotion user data', async () => {
    const mockPromotionData = { turnover: 1000 }
    mockNadal.promotion.promotion.mockResolvedValue(mockPromotionData)

    const promotion = usePromotion()
    await promotion.fetchUserPromotion()

    expect(mockPromotionStore.setPromotionUser).toHaveBeenCalledWith(
      mockPromotionData,
    )
  })

  it('should correctly cancel promotion', async () => {
    const mockPlanId = 'test-plan-id'
    mockPromotionStore.getUserPlan.mockReturnValue({ id: mockPlanId })
    mockNadal.promotion.cancel.mockResolvedValue()

    const promotion = usePromotion()
    await promotion.onCancelPromotion()

    expect(mockNadal.promotion.cancel).toHaveBeenCalledWith({
      plan_id: mockPlanId,
    })
  })

  it('should format promotion time period correctly', () => {
    const createdTime = '2024-01-01T00:00:00Z'
    const formattedStartDate = '01/01/2024'
    const formattedEndDate = '31/01/2024'

    // Assuming DATE_TIME_FORMAT.DATE_FORMAT = 'MM/DD/YYYY'
    const mockDateFormat = 'DD/MM/YYYY'

    mockPromotionStore.getUserPlan.mockReturnValue({
      created_time: createdTime,
    })

    // Mock the implementation of formatDate
    vi.mocked(utils.formatDate).mockImplementation((date) => {
      // Format the date using dayjs with the given format
      const formattedDate = dayjs(date).format(mockDateFormat)

      // Return the mocked formatted date values
      if (formattedDate === dayjs(createdTime).format(mockDateFormat)) {
        return formattedStartDate
      }

      if (
        formattedDate ===
        dayjs(createdTime).add(30, 'day').format(mockDateFormat)
      ) {
        return formattedEndDate
      }

      return ''
    })

    const promotion = usePromotion()

    expect(promotion.timePromoteText.value).toBe(
      `${formattedStartDate} - ${formattedEndDate}`,
    )
  })

  describe('usePromotion composable additional tests', () => {
    beforeEach(() => {
      // Reset the mocks before each test
      mockPromotionStore.getUserPlan.mockReset()
      mockPromotionStore.getPackageId.mockReset()
      mockNadal.promotion.promotion.mockReset()
      mockNadal.promotion.packages.mockReset()
      mockNadal.promotion.cancel.mockReset()
      vi.clearAllMocks()
    })

    it('should determine if rolling chart is visible based on promotion plan', () => {
      mockPromotionStore.getUserPlan.mockReturnValue({
        id: PromotionPlanEnum.WELCOME,
      })
      mockPromotionStore.getPackageId.mockReturnValue(PromotionPlanEnum.WELCOME)

      const promotion = usePromotion()

      expect(promotion.visibleRollingChart.value).toBe(true)
    })

    it('should determine if using promotion based on package ID', () => {
      mockPromotionStore.getPackageId.mockReturnValue(PromotionPlanEnum.BONUS)

      const promotion = usePromotion()

      expect(promotion.isUsingPromotion.value).toBe(true)
    })

    it('should determine if promotion type is welcome', () => {
      mockPromotionStore.getUserPlan.mockReturnValue({
        id: PromotionPlanEnum.WELCOME,
      })
      mockPromotionStore.getPackageId.mockReturnValue(PromotionPlanEnum.WELCOME)

      const promotion = usePromotion()

      expect(promotion.isWelcomeType.value).toBe(true)
    })

    it('should calculate and format deposit amount correctly', () => {
      mockPromotionStore.getUserPlan.mockReturnValue({
        deposit_amount: '10000',
      })

      vi.mocked(utils.formatAmountUnit).mockImplementation((amount) => {
        return amount.toString()
      })

      const promotion = usePromotion()

      expect(promotion.depositAmount.value).toBe('10') // Assuming the amount is divided by 1000
    })

    it('should open withdraw using promotion modal', () => {
      const promotion = usePromotion()

      promotion.openModalWithdrawUsingPromotion()

      expect(promotion.isOpenWithdrawUsingPromotionModal.value).toBe(true)
    })

    it('should open using promotion modal', () => {
      const promotion = usePromotion()

      promotion.openModalUsingPromotion()

      expect(promotion.isOpenUsingPromotionModal.value).toBe(true)
    })
  })
  describe('usePromotion composable additional tests for coverage', () => {
    beforeEach(() => {
      // Reset the mocks before each test
      mockPromotionStore.getUserPlan.mockReset()
      mockPromotionStore.getPackageId.mockReset()
      mockNadal.promotion.promotion.mockReset()
      mockNadal.promotion.packages.mockReset()
      mockNadal.promotion.cancel.mockReset()
      vi.clearAllMocks()
    })

    it('should calculate and format turnoverPromotionUser correctly', () => {
      mockPromotionStore.promotionUser = {
        turnover: 5000,
      }

      const promotion = usePromotion()

      expect(promotion.turnoverPromotionUser.value).toBe('5')
    })

    it('should calculate and format rollingPromotionUser correctly', () => {
      mockPromotionStore.promotionUser = {
        rolling: 2500,
      }

      const promotion = usePromotion()

      expect(promotion.rollingPromotionUser.value).toBe('2.5')
    })

    it('should calculate and format totalAmount correctly', () => {
      mockPromotionStore.getUserPlan.mockReturnValue({
        deposit_amount: '5000',
        promotion_amount: '1000',
      })

      vi.mocked(utils.formatAmountUnit).mockImplementation((amount) => {
        return amount.toString()
      })

      const promotion = usePromotion()

      expect(promotion.totalAmount.value).toBe('6') // Assuming both amounts are summed and divided by 1000
    })

    it('should fetch and set promotion packages correctly', async () => {
      const mockPackagesData = [
        { id: PromotionPlanEnum.WELCOME },
        { id: PromotionPlanEnum.SATURDAY },
      ]
      mockNadal.promotion.packages.mockResolvedValue(mockPackagesData)

      const promotion = usePromotion()
      await promotion.fetchPromotionPackages()

      expect(mockPackageStore.setPackages).toHaveBeenCalledWith(
        mockPackagesData,
      )
    })

    it('should correctly determine if bank note should be shown', () => {
      const mockPackageId = PromotionPlanEnum.BONUS
      mockPromotionStore.getUserPlan.mockReturnValue({
        id: PromotionPlanEnum.WELCOME,
      })

      // Mock promotion packages to include a package with the BONUS id
      mockPackageStore.packages = [
        { id: PromotionPlanEnum.BONUS },
        { id: PromotionPlanEnum.SATURDAY },
      ]

      const promotion = usePromotion()

      expect(promotion.isShowBankNote(mockPackageId.toString())).toBe(true)
    })

    it('should return false if bank note should not be shown', () => {
      const mockPackageId = PromotionPlanEnum.COMMISSION
      mockPromotionStore.getUserPlan.mockReturnValue({
        id: PromotionPlanEnum.WELCOME,
      })

      const promotion = usePromotion()

      // Mock promotion packages to exclude a package with the COMMISSION id
      promotion.promotionPackages.value = [
        { id: PromotionPlanEnum.BONUS },
        { id: PromotionPlanEnum.SATURDAY },
      ]

      expect(promotion.isShowBankNote(mockPackageId.toString())).toBe(false)
    })
  })

  describe('usePromotion composable additional tests for error handling and edge cases', () => {
    beforeEach(() => {
      mockPromotionStore.getUserPlan.mockReset()
      mockPromotionStore.getPackageId.mockReset()
      mockNadal.promotion.promotion.mockReset()
      mockNadal.promotion.packages.mockReset()
      mockNadal.promotion.cancel.mockReset()
      vi.clearAllMocks()
    })

    it('should handle errors in fetchUserPromotion gracefully', async () => {
      mockNadal.promotion.promotion.mockRejectedValue(new Error('API Error'))

      const promotion = usePromotion()
      await promotion.fetchUserPromotion()

      expect(mockPromotionStore.setPromotionUser).not.toHaveBeenCalled()
    })

    it('should handle errors in fetchPromotionPackages gracefully', async () => {
      mockNadal.promotion.packages.mockRejectedValue(new Error('API Error'))

      const promotion = usePromotion()
      await promotion.fetchPromotionPackages()

      expect(mockPackageStore.setPackages).not.toHaveBeenCalled()
    })

    it('should handle zero multiplier in promotionPercent', () => {
      mockPromotionStore.promotionUser = {
        calculated_turnover: 1000,
        multiplier: 0,
      }

      const promotion = usePromotion()

      expect(promotion.promotionPercent.value).toBe(0)
    })

    it('should handle missing promotion_amount in totalAmount', () => {
      mockPromotionStore.getUserPlan.mockReturnValue({
        deposit_amount: '5000',
        promotion_amount: null,
      })

      vi.mocked(utils.formatAmountUnit).mockImplementation((amount) => {
        return amount.toString()
      })

      const promotion = usePromotion()

      expect(promotion.totalAmount.value).toBe('5')
    })

    it('should handle null promotionUser in computed properties', () => {
      mockPromotionStore.promotionUser = null

      const promotion = usePromotion()

      expect(promotion.turnoverPromotionUser.value).toBe('0')
      expect(promotion.rollingPromotionUser.value).toBe('0')
    })

    it('should reset modal state after closing', () => {
      const promotion = usePromotion()

      promotion.openModalWithdrawUsingPromotion()
      expect(promotion.isOpenWithdrawUsingPromotionModal.value).toBe(true)

      promotion.isOpenWithdrawUsingPromotionModal.value = false
      expect(promotion.isOpenWithdrawUsingPromotionModal.value).toBe(false)
    })
  })

  describe('usePromotion composable - specific lines', () => {
    beforeEach(() => {
      mockPromotionStore.getUserPlan.mockReset()
      mockPromotionStore.getPackageId.mockReset()
      mockNadal.promotion.promotion.mockReset()
      mockNadal.promotion.packages.mockReset()
      mockNadal.promotion.cancel.mockReset()
      vi.clearAllMocks()
    })

    it('should correctly return promotionUser, promotionPlan, and packageId from the store', () => {
      const mockPromotionUser = { turnover: 5000 }
      const mockPromotionPlan = {
        id: 'plan-id',
        created_time: '2024-01-01T00:00:00Z',
      }
      const mockPackageId = PromotionPlanEnum.WELCOME

      mockPromotionStore.promotionUser = mockPromotionUser
      mockPromotionStore.getUserPlan.mockReturnValue(mockPromotionPlan)
      mockPromotionStore.getPackageId.mockReturnValue(mockPackageId)

      const promotion = usePromotion()

      expect(promotion.promotionUser.value).toEqual(mockPromotionUser)
      expect(promotion.promotionPlan.value).toEqual(mockPromotionPlan)
      expect(promotion.packageId.value).toBe(mockPackageId)
    })

    it('should correctly format timePromoteText', () => {
      const createdTime = '2024-01-01T00:00:00Z'
      const formattedStartDate = '01/01/2024'
      const formattedEndDate = '31/01/2024'

      vi.mocked(utils.formatDate).mockImplementation((date) => {
        return dayjs(date).format('DD/MM/YYYY')
      })

      mockPromotionStore.getUserPlan.mockReturnValue({
        created_time: createdTime,
      })

      const promotion = usePromotion()
      expect(promotion.timePromoteText.value).toBe(
        `${formattedStartDate} - ${formattedEndDate}`,
      )
    })

    it('should correctly format turnoverPromotionUser, rollingPromotionUser, depositAmount, and totalAmount', () => {
      const mockTurnover = 5000
      const mockRolling = 2500
      const mockDepositAmount = 10000
      const mockPromotionAmount = 2000

      mockPromotionStore.promotionUser = {
        turnover: mockTurnover,
        rolling: mockRolling,
      }
      mockPromotionStore.getUserPlan.mockReturnValue({
        deposit_amount: mockDepositAmount,
        promotion_amount: mockPromotionAmount,
      })

      vi.mocked(utils.formatAmountUnit).mockImplementation((amount) =>
        (amount / 1000).toString(),
      )

      const promotion = usePromotion()

      expect(promotion.turnoverPromotionUser.value).toBe('5')
      expect(promotion.rollingPromotionUser.value).toBe('2.5')
      expect(promotion.depositAmount.value).toBe('10')
      expect(promotion.totalAmount.value).toBe('12')
    })
  })
})