package kr.co.vividnext.sodalive.member

import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.common.CountryContext
import kr.co.vividnext.sodalive.i18n.LangContext
import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.member.auth.AuthRepository
import kr.co.vividnext.sodalive.member.block.BlockMember
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.block.MemberBlockRequest
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.cache.Cache
import org.springframework.cache.CacheManager
import java.util.Optional

class MemberServiceCacheEvictionTest {
    private lateinit var memberRepository: MemberRepository
    private lateinit var blockMemberRepository: BlockMemberRepository
    private lateinit var authRepository: AuthRepository
    private lateinit var cacheManager: CacheManager
    private lateinit var cache: Cache
    private lateinit var service: MemberService

    @BeforeEach
    fun setup() {
        memberRepository = mock()
        blockMemberRepository = mock()
        authRepository = mock()
        cacheManager = mock()
        cache = mock()

        Mockito.`when`(cacheManager.getCache("cache_ttl_3_hours")).thenReturn(cache)

        service = MemberService(
            repository = memberRepository,
            tokenRepository = mock(),
            stipulationRepository = mock(),
            stipulationAgreeRepository = mock(),
            creatorFollowingRepository = mock(),
            blockMemberRepository = blockMemberRepository,
            authRepository = authRepository,
            signOutRepository = mock(),
            nicknameChangeLogRepository = mock(),
            memberTagRepository = mock(),
            liveReservationRepository = mock(),
            chargeRepository = mock(),
            memberPointRepository = mock(),
            orderService = mock(),
            emailService = mock(),
            pushTokenService = mock(),
            canPaymentService = mock(),
            nicknameGenerateService = mock(),
            memberNotificationService = mock(),
            s3Uploader = mock(),
            validator = mock(),
            tokenProvider = mock(),
            passwordEncoder = mock(),
            authenticationManagerBuilder = mock(),
            messageSource = SodaMessageSource(),
            langContext = LangContext(),
            countryContext = CountryContext(),
            objectMapper = ObjectMapper(),
            cacheManager = cacheManager,
            s3Bucket = "test-bucket",
            cloudFrontHost = "https://cdn.test"
        )
    }

    @Test
    fun shouldEvictRecommendLiveCacheForRequesterAndTargetOnBlock() {
        val memberId = 100L
        val blockedMemberId = 200L
        val member = createMember(id = memberId, nickname = "requester")
        val blockedMember = createMember(id = blockedMemberId, nickname = "target")

        Mockito.`when`(memberRepository.findById(memberId)).thenReturn(Optional.of(member))
        Mockito.`when`(memberRepository.findById(blockedMemberId)).thenReturn(Optional.of(blockedMember))
        Mockito.`when`(
            blockMemberRepository.getBlockAccount(
                blockedMemberId = blockedMemberId,
                memberId = memberId
            )
        ).thenReturn(null)

        service.memberBlock(MemberBlockRequest(blockMemberId = blockedMemberId), memberId)

        Mockito.verify(cache).evict("getRecommendLive:$memberId")
        Mockito.verify(cache).evict("getRecommendLive:$blockedMemberId")
        Mockito.verifyNoInteractions(authRepository)
    }

    @Test
    fun shouldEvictRecommendLiveCacheForRequesterAndTargetOnUnblock() {
        val memberId = 300L
        val blockedMemberId = 400L
        val blockMember = BlockMember(isActive = true)

        Mockito.`when`(
            blockMemberRepository.getBlockAccount(
                blockedMemberId = blockedMemberId,
                memberId = memberId
            )
        ).thenReturn(blockMember)

        service.memberUnBlock(MemberBlockRequest(blockMemberId = blockedMemberId), memberId)

        assertEquals(false, blockMember.isActive)
        Mockito.verify(cache).evict("getRecommendLive:$memberId")
        Mockito.verify(cache).evict("getRecommendLive:$blockedMemberId")
    }

    private fun createMember(id: Long, nickname: String): Member {
        val member = Member(
            email = "$nickname@test.com",
            password = "password",
            nickname = nickname
        )
        member.id = id
        return member
    }

    private inline fun <reified T> mock(): T {
        return Mockito.mock(T::class.java)
    }
}