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.member.Member
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) {
    fun getCans(): List<CanResponse> {
        return repository.findAllByStatus(status = CanStatus.SALE)
    }

    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> {
        return 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.GOOGLE_IAP
                        }
                    }

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

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

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

                    CanUsage.CHANGE_NICKNAME -> "닉네임 변경"
                    CanUsage.ORDER_CONTENT -> "[콘텐츠 구매] ${it.audioContent!!.title}"
                    CanUsage.PAID_COMMUNITY_POST -> "[게시글 보기] ${it.communityPost?.member?.nickname ?: ""}"
                }

                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
                )
            }
    }
}