package com.contentsquare.rn.csq.utils

import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.ReadableType
import io.mockk.every
import io.mockk.mockk
import org.junit.Test
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue

class CustomVarConverterTest {

    @Test
    fun `convertReadableArrayToCSQCustomVarList should return empty list when input is null`() {
        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(null)

        // Then
        assertTrue(result.isEmpty())
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should return empty list when array is empty`() {
        // Given
        val mockArray = mockk<ReadableArray> {
            every { size() } returns 0
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertTrue(result.isEmpty())
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should convert valid custom vars correctly`() {
        // Given
        val mockMap1 = mockk<ReadableMap> {
            every { getInt("index") } returns 1
            every { getString("key") } returns "screen_type"
            every { getString("value") } returns "product_page"
        }

        val mockMap2 = mockk<ReadableMap> {
            every { getInt("index") } returns 2
            every { getString("key") } returns "user_type"
            every { getString("value") } returns "premium"
        }

        val mockArray = mockk<ReadableArray> {
            every { size() } returns 2
            every { getType(0) } returns ReadableType.Map
            every { getType(1) } returns ReadableType.Map
            every { getMap(0) } returns mockMap1
            every { getMap(1) } returns mockMap2
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertEquals(2, result.size)

        val firstVar = result[0]
        assertEquals(1, firstVar.index)
        assertEquals("screen_type", firstVar.name)
        assertEquals("product_page", firstVar.value)

        val secondVar = result[1]
        assertEquals(2, secondVar.index)
        assertEquals("user_type", secondVar.name)
        assertEquals("premium", secondVar.value)
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should skip non-map entries`() {
        // Given
        val mockMap = mockk<ReadableMap> {
            every { getInt("index") } returns 1
            every { getString("key") } returns "valid_key"
            every { getString("value") } returns "valid_value"
        }

        val mockArray = mockk<ReadableArray> {
            every { size() } returns 3
            every { getType(0) } returns ReadableType.String  // Non-map type
            every { getType(1) } returns ReadableType.Map     // Valid map
            every { getType(2) } returns ReadableType.Number  // Non-map type
            every { getMap(1) } returns mockMap
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertEquals(1, result.size)
        assertEquals(1, result[0].index)
        assertEquals("valid_key", result[0].name)
        assertEquals("valid_value", result[0].value)
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should skip entries with missing index`() {
        // Given
        val mockMapWithoutIndex = mockk<ReadableMap> {
            every { getInt("index") } throws RuntimeException("No such key: index")
            every { getString("key") } returns "test_key"
            every { getString("value") } returns "test_value"
        }

        val mockValidMap = mockk<ReadableMap> {
            every { getInt("index") } returns 1
            every { getString("key") } returns "valid_key"
            every { getString("value") } returns "valid_value"
        }

        val mockArray = mockk<ReadableArray> {
            every { size() } returns 2
            every { getType(0) } returns ReadableType.Map
            every { getType(1) } returns ReadableType.Map
            every { getMap(0) } returns mockMapWithoutIndex
            every { getMap(1) } returns mockValidMap
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertEquals(1, result.size)
        assertEquals(1, result[0].index)
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should skip entries with missing key`() {
        // Given
        val mockMapWithoutKey = mockk<ReadableMap> {
            every { getInt("index") } returns 1
            every { getString("key") } throws RuntimeException("No such key: key")
            every { getString("value") } returns "test_value"
        }

        val mockValidMap = mockk<ReadableMap> {
            every { getInt("index") } returns 2
            every { getString("key") } returns "valid_key"
            every { getString("value") } returns "valid_value"
        }

        val mockArray = mockk<ReadableArray> {
            every { size() } returns 2
            every { getType(0) } returns ReadableType.Map
            every { getType(1) } returns ReadableType.Map
            every { getMap(0) } returns mockMapWithoutKey
            every { getMap(1) } returns mockValidMap
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertEquals(1, result.size)
        assertEquals(2, result[0].index)
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should skip entries with missing value`() {
        // Given
        val mockMapWithoutValue = mockk<ReadableMap> {
            every { getInt("index") } returns 1
            every { getString("key") } returns "test_key"
            every { getString("value") } throws RuntimeException("No such key: value")
        }

        val mockValidMap = mockk<ReadableMap> {
            every { getInt("index") } returns 2
            every { getString("key") } returns "valid_key"
            every { getString("value") } returns "valid_value"
        }

        val mockArray = mockk<ReadableArray> {
            every { size() } returns 2
            every { getType(0) } returns ReadableType.Map
            every { getType(1) } returns ReadableType.Map
            every { getMap(0) } returns mockMapWithoutValue
            every { getMap(1) } returns mockValidMap
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertEquals(1, result.size)
        assertEquals(2, result[0].index)
    }

    @Test
    fun `convertReadableArrayToCSQCustomVarList should handle exceptions gracefully`() {
        // Given
        val mockMapWithException = mockk<ReadableMap> {
            every { getInt("index") } throws RuntimeException("Test exception")
        }

        val mockValidMap = mockk<ReadableMap> {
            every { getInt("index") } returns 1
            every { getString("key") } returns "valid_key"
            every { getString("value") } returns "valid_value"
        }

        val mockArray = mockk<ReadableArray> {
            every { size() } returns 2
            every { getType(0) } returns ReadableType.Map
            every { getType(1) } returns ReadableType.Map
            every { getMap(0) } returns mockMapWithException
            every { getMap(1) } returns mockValidMap
        }

        // When
        val result = CustomVarConverter.convertReadableArrayToCSQCustomVarList(mockArray)

        // Then
        assertEquals(1, result.size)
        assertEquals(1, result[0].index)
    }
}