sodalive-backend-spring-boot/src/main/kotlin/kr/co/vividnext/sodalive/fcm/FcmEvent.kt

package kr.co.vividnext.sodalive.fcm

import kr.co.vividnext.sodalive.member.MemberRepository
import org.slf4j.LoggerFactory
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Component

enum class FcmEventType {
    ALL, INDIVIDUAL, CREATE_LIVE, START_LIVE, UPLOAD_CONTENT, SEND_MESSAGE
}

class FcmEvent(
    val type: FcmEventType,
    val title: String,
    val message: String,
    val container: String = "",
    val recipients: List<Long> = listOf(),
    val isAuth: Boolean = false,
    val roomId: Long? = null,
    val contentId: Long? = null,
    val messageId: Long? = null,
    val creatorId: Long? = null
)

@Component
class FcmSendListener(
    private val pushService: FcmService,
    private val memberRepository: MemberRepository
) {
    private val logger = LoggerFactory.getLogger(FcmSendListener::class.java)

    @EventListener
    fun send(fcmEvent: FcmEvent) {
        when (fcmEvent.type) {
            FcmEventType.ALL -> {
                if (fcmEvent.container.isNotBlank()) {
                    val pushTokens = memberRepository.getAllRecipientPushTokens(
                        fcmEvent.isAuth,
                        fcmEvent.container
                    )

                    logger.info("tokens::: $pushTokens")

                    for (tokens in pushTokens) {
                        pushService.send(
                            tokens = tokens,
                            title = fcmEvent.title,
                            message = fcmEvent.message,
                            container = fcmEvent.container
                        )
                    }
                }
            }

            FcmEventType.INDIVIDUAL -> {
                if (fcmEvent.recipients.isNotEmpty()) {
                    val pushTokens = memberRepository.getIndividualRecipientPushTokens(
                        recipients = fcmEvent.recipients,
                        isAuth = fcmEvent.isAuth
                    )

                    logger.info("tokens::: $pushTokens")

                    val iosPushTokens = pushTokens["ios"]
                    val aosPushToken = pushTokens["aos"]

                    if (iosPushTokens != null) {
                        for (tokens in iosPushTokens) {
                            pushService.send(
                                tokens = tokens,
                                title = fcmEvent.title,
                                message = fcmEvent.message,
                                container = fcmEvent.container
                            )
                        }
                    }

                    if (aosPushToken != null) {
                        for (tokens in aosPushToken) {
                            pushService.send(
                                tokens = tokens,
                                title = fcmEvent.title,
                                message = fcmEvent.message,
                                container = fcmEvent.container
                            )
                        }
                    }
                }
            }

            FcmEventType.CREATE_LIVE, FcmEventType.START_LIVE -> {
                if (fcmEvent.container.isNotBlank()) {
                    val pushTokens = memberRepository.getCreateLiveRoomNotificationRecipientPushTokens(
                        creatorId = fcmEvent.creatorId!!,
                        isAuth = fcmEvent.isAuth,
                        container = fcmEvent.container
                    )

                    logger.info("tokens::: $pushTokens")

                    for (tokens in pushTokens) {
                        pushService.send(
                            tokens = tokens,
                            title = fcmEvent.title,
                            message = fcmEvent.message,
                            container = fcmEvent.container,
                            roomId = fcmEvent.roomId
                        )
                    }
                }
            }

            FcmEventType.UPLOAD_CONTENT -> {
                if (fcmEvent.container.isNotBlank()) {
                    val pushTokens = memberRepository.getUploadContentNotificationRecipientPushTokens(
                        creatorId = fcmEvent.creatorId!!,
                        isAuth = fcmEvent.isAuth,
                        container = fcmEvent.container
                    )

                    logger.info("tokens::: $pushTokens")

                    for (tokens in pushTokens) {
                        pushService.send(
                            tokens = tokens,
                            title = fcmEvent.title,
                            message = fcmEvent.message,
                            container = fcmEvent.container,
                            contentId = fcmEvent.contentId
                        )
                    }
                }
            }

            FcmEventType.SEND_MESSAGE -> {
                val response = memberRepository.getMessageRecipientPushToken(messageId = fcmEvent.messageId!!)

                logger.info("tokens::: ${response.pushToken}")

                pushService.send(
                    tokens = listOf(response.pushToken),
                    title = fcmEvent.title,
                    message = fcmEvent.message,
                    container = response.container,
                    messageId = fcmEvent.messageId
                )
            }
        }
    }
}