sodalive-backend-spring-boot/src/main/kotlin/kr/co/vividnext/sodalive/can/CanService.kt

package kr.co.vividnext.sodalive.can

import kr.co.vividnext.sodalive.can.charge.ChargeStatus
import kr.co.vividnext.sodalive.can.payment.PaymentGateway
import kr.co.vividnext.sodalive.can.use.CanUsage
import kr.co.vividnext.sodalive.common.CountryContext
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRepository
import org.springframework.data.domain.Pageable
import org.springframework.stereotype.Service
import java.time.ZoneId
import java.time.format.DateTimeFormatter

@Service
class CanService(
    private val repository: CanRepository,
    private val countryContext: CountryContext,
    private val memberRepository: MemberRepository
) {
    fun getCans(isNotSelectedCurrency: Boolean): List<CanResponse> {
        val currency = if (isNotSelectedCurrency) {
            null
        } else {
            when (countryContext.countryCode) {
                "KR" -> "KRW"
                else -> "USD"
            }
        }
        return repository.findAllByStatusAndCurrency(status = CanStatus.SALE, currency = currency)
    }

    fun getCanStatus(member: Member, container: String): GetCanStatusResponse {
        return GetCanStatusResponse(
            chargeCan = member.getChargeCan(container),
            rewardCan = member.getRewardCan(container)
        )
    }

    fun getCanUseStatus(
        member: Member,
        pageable: Pageable,
        timezone: String,
        container: String
    ): List<GetCanUseStatusResponseItem> {
        val useCanList = repository.getCanUseStatus(member, pageable)
            .filter { (it.can + it.rewardCan) > 0 }
            .filter {
                when (container) {
                    "aos" -> {
                        it.useCanCalculates.any { useCanCalculate ->
                            useCanCalculate.paymentGateway == PaymentGateway.PG ||
                                useCanCalculate.paymentGateway == PaymentGateway.PAYVERSE ||
                                useCanCalculate.paymentGateway == PaymentGateway.GOOGLE_IAP
                        }
                    }

                    "ios" -> {
                        it.useCanCalculates.any { useCanCalculate ->
                            useCanCalculate.paymentGateway == PaymentGateway.PG ||
                                useCanCalculate.paymentGateway == PaymentGateway.PAYVERSE ||
                                useCanCalculate.paymentGateway == PaymentGateway.APPLE_IAP
                        }
                    }

                    else -> it.useCanCalculates.any { useCanCalculate ->
                        useCanCalculate.paymentGateway == PaymentGateway.PG ||
                            useCanCalculate.paymentGateway == PaymentGateway.PAYVERSE
                    }
                }
            }

        val channelDonationCreatorIds = useCanList
            .asSequence()
            .filter { it.canUsage == CanUsage.CHANNEL_DONATION }
            .mapNotNull { it.useCanCalculates.firstOrNull()?.recipientCreatorId }
            .distinct()
            .toList()

        val channelDonationCreatorNicknameMap = if (channelDonationCreatorIds.isEmpty()) {
            emptyMap()
        } else {
            memberRepository.findAllById(channelDonationCreatorIds).associate { it.id!! to it.nickname }
        }

        return useCanList
            .map {
                val title: String = when (it.canUsage) {
                    CanUsage.HEART, CanUsage.DONATION, CanUsage.SPIN_ROULETTE -> {
                        if (it.room != null) {
                            "[라이브 후원] ${it.room!!.member!!.nickname}"
                        } else if (it.audioContent != null) {
                            "[콘텐츠 후원] ${it.audioContent!!.member!!.nickname}"
                        } else {
                            "[후원]"
                        }
                    }

                    CanUsage.CHANNEL_DONATION -> {
                        val creatorId = it.useCanCalculates.firstOrNull()?.recipientCreatorId
                        val creatorNickname = creatorId?.let { id -> channelDonationCreatorNicknameMap[id] }

                        if (creatorNickname.isNullOrBlank()) {
                            "[채널 후원]"
                        } else {
                            "[채널 후원] $creatorNickname"
                        }
                    }

                    CanUsage.LIVE -> {
                        "[라이브] ${it.room!!.title}"
                    }

                    CanUsage.CHANGE_NICKNAME -> "닉네임 변경"
                    CanUsage.ALARM_SLOT -> "알람 슬롯 구매"
                    CanUsage.ORDER_CONTENT -> "[콘텐츠 구매] ${it.audioContent!!.title}"
                    CanUsage.PAID_COMMUNITY_POST -> "[게시글 보기] ${it.communityPost?.member?.nickname ?: ""}"
                    CanUsage.AUDITION_VOTE -> "[오디션 투표] ${it.auditionApplicant?.role?.audition?.title ?: ""}"
                    CanUsage.CHAT_MESSAGE_PURCHASE -> "[메시지 구매] ${it.characterImage?.chatCharacter?.name ?: ""}"
                    CanUsage.CHARACTER_IMAGE_PURCHASE -> "[캐릭터 이미지 구매] ${it.characterImage?.chatCharacter?.name ?: ""}"
                    CanUsage.CHAT_QUOTA_PURCHASE -> "캐릭터 톡 이용권 구매"
                    CanUsage.CHAT_ROOM_RESET -> "캐릭터 톡 초기화"
                }

                val createdAt = it.createdAt!!
                    .atZone(ZoneId.of("UTC"))
                    .withZoneSameInstant(ZoneId.of(timezone))

                GetCanUseStatusResponseItem(
                    title = title,
                    date = createdAt.format(
                        DateTimeFormatter.ofPattern("yyyy-MM-dd | HH:mm:ss")
                    ),
                    can = it.can + it.rewardCan
                )
            }
    }

    fun getCanChargeStatus(
        member: Member,
        pageable: Pageable,
        timezone: String,
        container: String
    ): List<GetCanChargeStatusResponseItem> {
        return repository.getCanChargeStatus(member, pageable, container)
            .map {
                val canTitle = it.title ?: ""
                val chargeMethod = when (it.status) {
                    ChargeStatus.CHARGE, ChargeStatus.EVENT -> {
                        it.payment!!.method ?: ""
                    }

                    ChargeStatus.REFUND_CHARGE -> {
                        "환불"
                    }

                    ChargeStatus.ADMIN -> {
                        "관리자 지급"
                    }

                    ChargeStatus.ADS -> {
                        "제휴보상"
                    }

                    ChargeStatus.COUPON -> {
                        it.payment!!.method ?: "쿠폰충전"
                    }

                    else -> {
                        "환불"
                    }
                }

                val createdAt = it.createdAt!!
                    .atZone(ZoneId.of("UTC"))
                    .withZoneSameInstant(ZoneId.of(timezone))

                GetCanChargeStatusResponseItem(
                    canTitle = canTitle,
                    date = createdAt.format(
                        DateTimeFormatter.ofPattern("yyyy-MM-dd | HH:mm:ss")
                    ),
                    chargeMethod = chargeMethod
                )
            }
    }
}