/**
 * Import types from Nadal.
 */
import type {
  TransactionHistoriesRequestPayload,
  TransactionHistoriesResponseData,
} from '@kira-dancer/nadal'

import type {
  TransactionCardItem,
  TransactionParams,
  TransactionHistoriesResponseDataExtend,
} from '#lib/types'
import {
  CURRENT_PAGE_DEFAULT,
  INVOICE_STATUS,
  KEY_ITEM,
  TOTAL_PAGE_DEFAULT,
  TRANSACTION_ACTION,
  WALLET,
  BANK_CODE_MAPPING,
} from '#lib/constants'
import { DepositMethodEnum } from '#lib/enums'
import { formatMoney, roundNumber } from '#lib/utils'
import { useRuntimeConfig } from 'nuxt/app'
import { ref, computed } from 'vue'
import { useNadal } from '#lib/composables'

/**
 * Custom composable function for managing transaction history.
 * @namespace
 */
export function useTransactionHistory() {
  const { transaction } = useNadal()

  /**
   * Runtime configuration.
   */
  const runtimeConfig = useRuntimeConfig()

  /**
   * Main credit unit.
   */
  const MAIN_CREDIT_UNIT = runtimeConfig.public.MAIN_CREDIT_UNIT

  /**
   * Agency credit unit.
   */
  const AGENCY_CREDIT_UNIT = runtimeConfig.public.AGENCY_CREDIT_UNIT

  /**
   * Loading state.
   */
  const isLoading = ref(false)

  /**
   * Total number of posts.
   */
  const totalPost = ref(TOTAL_PAGE_DEFAULT)

  /**
   * Limit of transactions per page.
   */
  const limit = ref(0)

  /**
   * Current page number.
   */
  const currentPage = ref(CURRENT_PAGE_DEFAULT)

  /**
   * List of transaction histories.
   */
  const historyList = ref<TransactionHistoriesResponseData[]>([])

  /**
   * Checks if there is a next page.
   */
  const isNextPage = computed(() => {
    return totalPost.value > limit.value * currentPage.value
  })

  /**
   * Retrieves transaction histories based on the provided payload.
   *
   * TransactionBetHistoriesRequestPayload type is imported from the Nadal module.
   *
   * TransactionBetHistoriesResponseData type is imported from the Nadal module.
   * @param payload - The transaction parameters.
   * @returns A promise that resolves to an array of transaction histories.
   */
  const fetchTransaction = async (
    payload: TransactionParams,
  ): Promise<TransactionHistoriesResponseData[]> => {
    isLoading.value = true
    limit.value = payload.limit

    try {
      const response = await transaction.histories<
        TransactionHistoriesRequestPayload,
        TransactionHistoriesResponseData[]
      >(payload)

      isLoading.value = false

      if (response?.data) {
        totalPost.value = Number(response.total)
        const { data } = response
        historyList.value = data
        return data
      }

      return []
    } catch (ex) {
      console.error(' ~ fetchTransaction ~ ex:', ex)
      return []
    } finally {
      isLoading.value = false
    }
  }

  /**
   * Handles pagination change and retrieves transactions for the new page.
   * @param data - The new page number.
   * @param payload - The transaction parameters.
   * @returns A promise that resolves when the transaction retrieval is complete.
   */
  const onChangePagination = async (
    data: number,
    payload: TransactionParams,
  ): Promise<void> => {
    currentPage.value = data
    void fetchTransaction(payload)
  }

  /**
   * Retrieves the amount for a transaction item.
   * @param transactionItem - The transaction item.
   * @returns The formatted amount string.
   */
  const getAmount = (
    transactionItem: TransactionHistoriesResponseDataExtend,
  ): string => {
    const { wallet, method, status, amount, card_amount, creditRate } =
      transactionItem
    let currencyName = MAIN_CREDIT_UNIT

    if (wallet === WALLET.AGENCY_WALLET) {
      currencyName = AGENCY_CREDIT_UNIT
    }

    let totalAmount =
      method !== DepositMethodEnum.PhoneCard ||
      (method === DepositMethodEnum.PhoneCard &&
        status === INVOICE_STATUS.FINISHED)
        ? amount.toString()
        : card_amount.toString()

    if (creditRate) {
      totalAmount = roundNumber(Number(totalAmount) / creditRate, 2).toString()
    } else if (
      method === DepositMethodEnum.CryptoPay ||
      method === DepositMethodEnum.Crypto
    ) {
      totalAmount = roundNumber(Number(totalAmount), 2).toString()
    }

    return totalAmount && totalAmount !== KEY_ITEM.ZERO
      ? formatMoney(totalAmount) + ` ${currencyName}`
      : '-'
  }

  /**
   * Retrieves the note for a transaction item.
   * @param transactionItem - The transaction item.
   * @returns An array of transaction card items.
   */
  const getNote = (
    transactionItem: TransactionHistoriesResponseData,
  ): TransactionCardItem[] => {
    const { method, action, card_serial } = transactionItem

    if (
      method !== DepositMethodEnum.PhoneCard ||
      action !== TRANSACTION_ACTION.WITHDRAW ||
      !card_serial
    ) {
      return []
    }

    try {
      return JSON.parse(card_serial)
    } catch (e) {
      console.error(' ~ getNote ~ e:', e)
      return []
    }
  }

  /**
   * Retrieves the bank code for a transaction item.
   * @param transactionItem - The transaction item.
   * @returns The bank code string.
   */
  const getToBankCode = (
    transactionItem: TransactionHistoriesResponseData,
  ): string => {
    const { method, card_provider = '', to_bank_code = '' } = transactionItem
    switch (method) {
      case DepositMethodEnum.SmartPay:
        return (
          BANK_CODE_MAPPING[to_bank_code.toLowerCase()] ?? ''
        ).toUpperCase()
      case DepositMethodEnum.PhoneCard:
        return card_provider?.toUpperCase()
      default:
        return to_bank_code.toUpperCase()
    }
  }

  return {
    limit,
    isLoading,
    isNextPage,
    currentPage,
    historyList,
    totalPost,
    fetchTransaction,
    onChangePagination,
    getAmount,
    getToBankCode,
    getNote,
  }
}