package com.contentsquare.rn.csq

import com.contentsquare.CSQ
import com.contentsquare.rn.utils.ReactNativeUiThreadUtil
import io.mockk.every
import io.mockk.mockk
import io.mockk.mockkStatic
import io.mockk.slot
import io.mockk.unmockkAll
import io.mockk.verify
import org.junit.After
import org.junit.Before
import org.junit.Test

class CSQPropertyTrackingTest {
    private val mockReactNativeUiThreadUtil: ReactNativeUiThreadUtil =
        mockk<ReactNativeUiThreadUtil>()

    private lateinit var underTest: CSQPropertyTracking

    @Before
    fun setup() {
        val slot = slot<Runnable>()
        every { mockReactNativeUiThreadUtil.runOnUiThread(capture(slot)) } answers {
            slot.captured.run()
            Unit
        }

        underTest = CSQPropertyTracking(mockReactNativeUiThreadUtil)

        // Common mock setup for CSQ
        mockkStatic(CSQ::class)
        every { CSQ.addEventProperties(any()) } returns Unit
        every { CSQ.removeEventProperty(any()) } returns Unit
        every { CSQ.clearEventProperties() } returns Unit
        every { CSQ.addUserProperties(any()) } returns Unit
    }

    @After
    fun tearDown() {
        unmockkAll()
    }

    @Test
    fun `addEventProperties should call CSQ addEventProperties and run on UI thread`() {
        // Given
        val properties = mapOf("key" to "value")

        // When
        underTest.addEventProperties(properties)

        // Then
        verify { CSQ.addEventProperties(properties) }
        verify { mockReactNativeUiThreadUtil.runOnUiThread(any()) }
    }

    @Test
    fun `addEventProperties should call CSQ addEventProperties with mixed type properties`() {
        // Given
        val properties = mapOf(
            "name" to "test",
            "count" to 101,
            "float" to 50.5,
            "active" to true
        )

        // When
        underTest.addEventProperties(properties)

        // Then
        verify { CSQ.addEventProperties(properties) }
    }

    @Test
    fun `addEventProperties should call CSQ addEventProperties with empty properties`() {
        // Given
        val properties = emptyMap<String, Any>()

        // When
        underTest.addEventProperties(properties)

        // Then
        verify { CSQ.addEventProperties(properties) }
    }

    @Test
    fun `addEventProperties should handle multiple sequential calls`() {
        // Given
        val properties1 = mapOf("step" to 1)
        val properties2 = mapOf("step" to 2, "action" to "update")

        // When
        underTest.addEventProperties(properties1)
        underTest.addEventProperties(properties2)

        // Then
        verify { CSQ.addEventProperties(properties1) }
        verify { CSQ.addEventProperties(properties2) }
        verify(exactly = 2) { mockReactNativeUiThreadUtil.runOnUiThread(any()) }
    }

    @Test
    fun `removeEventProperty should call CSQ removeEventProperty and run on UI thread`() {
        // Given
        val propertyName = "test_property"

        // When
        underTest.removeEventProperty(propertyName)

        // Then
        verify { CSQ.removeEventProperty(propertyName) }
        verify { mockReactNativeUiThreadUtil.runOnUiThread(any()) }
    }

    @Test
    fun `removeEventProperty should handle multiple sequential calls`() {
        // Given
        val property1 = "property1"
        val property2 = "property2"
        val property3 = "property3"

        // When
        underTest.removeEventProperty(property1)
        underTest.removeEventProperty(property2)
        underTest.removeEventProperty(property3)

        // Then
        verify { CSQ.removeEventProperty(property1) }
        verify { CSQ.removeEventProperty(property2) }
        verify { CSQ.removeEventProperty(property3) }
        verify(exactly = 3) { mockReactNativeUiThreadUtil.runOnUiThread(any()) }
    }

    @Test
    fun `clearEventProperties should call CSQ clearEventProperties and run on UI thread`() {
        // When
        underTest.clearEventProperties()

        // Then
        verify { CSQ.clearEventProperties() }
        verify { mockReactNativeUiThreadUtil.runOnUiThread(any()) }
    }

    @Test
    fun `addUserProperties should call CSQ addUserProperties and run on UI thread`() {
        // Given
        val properties = mapOf("key" to "value")

        // When
        underTest.addUserProperties(properties)

        // Then
        verify { CSQ.addUserProperties(properties) }
        verify { mockReactNativeUiThreadUtil.runOnUiThread(any()) }
    }

    @Test
    fun `addUserProperties should call CSQ addUserProperties with mixed type properties`() {
        // Given
        val properties = mapOf(
            "name" to "test",
            "count" to 101,
            "float" to 50.5,
            "active" to true
        )

        // When
        underTest.addUserProperties(properties)

        // Then
        verify { CSQ.addUserProperties(properties) }
    }

    @Test
    fun `addUserProperties should call CSQ addUserProperties with empty properties`() {
        // Given
        val properties = emptyMap<String, Any>()

        // When
        underTest.addUserProperties(properties)

        // Then
        verify { CSQ.addUserProperties(properties) }
    }
}