feat(ranking): 조회 cold-start fallback을 추가한다

src/main/kotlin/kr/co/vividnext/sodalive/v2/ranking/application/CreatorRankingQueryService.kt

@@ -1,6 +1,11 @@
 package kr.co.vividnext.sodalive.v2.ranking.application
 
 import kr.co.vividnext.sodalive.v2.ranking.domain.CreatorRankingItem
+import kr.co.vividnext.sodalive.v2.ranking.domain.CreatorRankingPeriodPolicy
+import kr.co.vividnext.sodalive.v2.ranking.domain.CreatorRankingScorePolicy
+import kr.co.vividnext.sodalive.v2.ranking.domain.CreatorRankingSnapshotCandidate
+import kr.co.vividnext.sodalive.v2.ranking.domain.CreatorRankingUtcRange
+import kr.co.vividnext.sodalive.v2.ranking.port.out.CreatorRankingAggregationPort
 import kr.co.vividnext.sodalive.v2.ranking.port.out.CreatorRankingBlockPort
 import kr.co.vividnext.sodalive.v2.ranking.port.out.CreatorRankingSnapshotPort
 import kr.co.vividnext.sodalive.v2.ranking.port.out.CreatorRankingSnapshotRecord
@@ -8,15 +13,20 @@ import org.slf4j.LoggerFactory
 import org.springframework.beans.factory.annotation.Value
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
+import java.time.ZonedDateTime
 
 @Service
 class CreatorRankingQueryService(
     private val snapshotPort: CreatorRankingSnapshotPort,
     private val blockPort: CreatorRankingBlockPort,
+    private val aggregationPort: CreatorRankingAggregationPort,
+    private val nowProvider: () -> ZonedDateTime = { ZonedDateTime.now() },
     @Value("\${cloud.aws.cloud-front.host}")
     private val cloudFrontHost: String
 ) {
     private val log = LoggerFactory.getLogger(javaClass)
+    private val periodPolicy = CreatorRankingPeriodPolicy()
+    private val scorePolicy = CreatorRankingScorePolicy()
 
     @Transactional(readOnly = true)
     fun getCreatorRankings(viewerMemberId: Long?): CreatorRankingResult {
@@ -24,6 +34,17 @@ class CreatorRankingQueryService(
         return runCatching {
             val latestItems = snapshotPort.findLatestSnapshots().toRankedItems()
             if (latestItems.isEmpty()) {
+                if (snapshotPort.isSnapshotTableEmpty()) {
+                    val fallbackItems = aggregateColdStartFallback().toRankedItems()
+                    val blockedCreatorIds = findBlockedCreatorIds(viewerMemberId = viewerMemberId, items = fallbackItems)
+                    return@runCatching QueryLogResult(
+                        result = CreatorRankingResult(
+                            showRankChange = false,
+                            items = fallbackItems.map { it.maskIfBlocked(blockedCreatorIds) }
+                        ),
+                        blockedCreatorCount = blockedCreatorIds.size
+                    )
+                }
                 return@runCatching QueryLogResult(
                     result = CreatorRankingResult(showRankChange = false, items = emptyList()),
                     blockedCreatorCount = 0
@@ -69,6 +90,43 @@ class CreatorRankingQueryService(
         val blockedCreatorCount: Int
     )
 
+    private fun aggregateColdStartFallback(): List<CreatorRankingSnapshotRecord> {
+        val startedAt = System.currentTimeMillis()
+        val period = periodPolicy.resolveLastCompletedWeek(nowProvider())
+        val utcRange = periodPolicy.toUtcRange(period)
+        log.info(
+            "event=creator_ranking_query_cold_start_fallback_attempt " +
+                "aggregationStartAtUtc={} aggregationEndAtUtc={}",
+            utcRange.startInclusiveUtc,
+            utcRange.endExclusiveUtc
+        )
+        return runCatching {
+            aggregationPort.aggregateCandidates(
+                startInclusiveUtc = utcRange.startInclusiveUtc,
+                endExclusiveUtc = utcRange.endExclusiveUtc
+            ).map { it.toSnapshotRecord(utcRange) }
+        }.onSuccess { snapshots ->
+            log.info(
+                "event=creator_ranking_query_cold_start_fallback_success " +
+                    "aggregationStartAtUtc={} aggregationEndAtUtc={} itemCount={} elapsedMs={}",
+                utcRange.startInclusiveUtc,
+                utcRange.endExclusiveUtc,
+                snapshots.size.coerceAtMost(RANKING_LIMIT),
+                System.currentTimeMillis() - startedAt
+            )
+        }.onFailure { ex ->
+            log.warn(
+                "event=creator_ranking_query_cold_start_fallback_failure " +
+                    "aggregationStartAtUtc={} aggregationEndAtUtc={} elapsedMs={} error={}",
+                utcRange.startInclusiveUtc,
+                utcRange.endExclusiveUtc,
+                System.currentTimeMillis() - startedAt,
+                ex.message,
+                ex
+            )
+        }.getOrThrow()
+    }
+
     private fun List<CreatorRankingSnapshotRecord>.toRankedItems(): List<CreatorRankingItem> {
         return groupBy { it.finalScore }
             .toSortedMap(compareByDescending { it })
@@ -89,6 +147,54 @@ class CreatorRankingQueryService(
         )
     }
 
+    private fun CreatorRankingSnapshotCandidate.toSnapshotRecord(utcRange: CreatorRankingUtcRange): CreatorRankingSnapshotRecord {
+        val calculatedContentLiveScore = scorePolicy.calculateContentLiveScore(
+            liveCanAmount = liveCanAmount,
+            contentPurchaseCanAmount = contentPurchaseCanAmount
+        )
+        val calculatedEngagementScore = scorePolicy.calculateEngagementScore(
+            contentLikeCount = contentLikeCount,
+            contentCommentCount = contentCommentCount
+        )
+        val calculatedSupportScore = scorePolicy.calculateSupportScore(
+            channelDonationCanAmount = channelDonationCanAmount,
+            channelDonationCount = channelDonationCount,
+            fanTalkCount = fanTalkCount
+        )
+        val calculatedFanLoyaltyScore = scorePolicy.calculateFanLoyaltyScore(
+            finalFollowerCount = finalFollowerCount,
+            followIncrease = followIncrease
+        )
+        val calculatedFinalScore = scorePolicy.calculateFinalScore(
+            contentLiveScore = calculatedContentLiveScore,
+            engagementScore = calculatedEngagementScore,
+            supportScore = calculatedSupportScore,
+            fanLoyaltyScore = calculatedFanLoyaltyScore
+        )
+
+        return CreatorRankingSnapshotRecord(
+            aggregationStartAtUtc = utcRange.startInclusiveUtc,
+            aggregationEndAtUtc = utcRange.endExclusiveUtc,
+            creatorId = creatorId,
+            nickname = nickname,
+            profileImageUrl = profileImageUrl,
+            finalScore = calculatedFinalScore,
+            contentLiveScore = calculatedContentLiveScore,
+            engagementScore = calculatedEngagementScore,
+            supportScore = calculatedSupportScore,
+            fanLoyaltyScore = calculatedFanLoyaltyScore,
+            liveCanAmount = liveCanAmount,
+            contentPurchaseCanAmount = contentPurchaseCanAmount,
+            contentLikeCount = contentLikeCount,
+            contentCommentCount = contentCommentCount,
+            channelDonationCanAmount = channelDonationCanAmount,
+            channelDonationCount = channelDonationCount,
+            fanTalkCount = fanTalkCount,
+            finalFollowerCount = finalFollowerCount,
+            followIncrease = followIncrease
+        )
+    }
+
     private fun findBlockedCreatorIds(viewerMemberId: Long?, items: List<CreatorRankingItem>): Set<Long> {
         if (viewerMemberId == null) {
             return emptySet()