package com.brickmodule

import com.facebook.react.bridge.*

/**
 * Helper class for converting data to React Native compatible formats
 * Ensures type safety when sending events to JavaScript
 */
object EventDataConverter {
    
    /**
     * Convert any data to React Native compatible format
     * 
     * @param data The data to convert
     * @return React Native compatible data or null if conversion fails
     */
    fun convert(data: Any?): Any? {
        return try {
            when (data) {
                null -> null
                is String -> data
                is Boolean -> data
                is Int -> data
                is Double -> data
                is Float -> data.toDouble()
                is Long -> data.toDouble()
                is Map<*, *> -> convertMap(data)
                is List<*> -> convertList(data)
                is Array<*> -> convertList(data.toList())
                else -> {
                    println("⚠️ EventDataConverter: Unsupported data type ${data.javaClass.simpleName}, converting to string")
                    data.toString()
                }
            }
        } catch (e: Exception) {
            println("❌ EventDataConverter: Failed to convert data: ${e.message}")
            null
        }
    }
    
    /**
     * Convert a map to WritableMap for React Native
     * 
     * @param map The map to convert
     * @return WritableMap or null if conversion fails
     */
    private fun convertMap(map: Map<*, *>): WritableMap? {
        return try {
            val writableMap = Arguments.createMap()
            
            map.forEach { (key, value) ->
                val keyString = key?.toString()
                if (keyString != null) {
                    when (val convertedValue = convert(value)) {
                        null -> writableMap.putNull(keyString)
                        is String -> writableMap.putString(keyString, convertedValue)
                        is Boolean -> writableMap.putBoolean(keyString, convertedValue)
                        is Int -> writableMap.putInt(keyString, convertedValue)
                        is Double -> writableMap.putDouble(keyString, convertedValue)
                        is WritableMap -> writableMap.putMap(keyString, convertedValue)
                        is WritableArray -> writableMap.putArray(keyString, convertedValue)
                        else -> writableMap.putString(keyString, convertedValue.toString())
                    }
                }
            }
            
            writableMap
        } catch (e: Exception) {
            println("❌ EventDataConverter: Failed to convert map: ${e.message}")
            null
        }
    }
    
    /**
     * Convert a list to WritableArray for React Native
     * 
     * @param list The list to convert
     * @return WritableArray or null if conversion fails
     */
    private fun convertList(list: List<*>): WritableArray? {
        return try {
            val writableArray = Arguments.createArray()
            
            list.forEach { item ->
                when (val convertedValue = convert(item)) {
                    null -> writableArray.pushNull()
                    is String -> writableArray.pushString(convertedValue)
                    is Boolean -> writableArray.pushBoolean(convertedValue)
                    is Int -> writableArray.pushInt(convertedValue)
                    is Double -> writableArray.pushDouble(convertedValue)
                    is WritableMap -> writableArray.pushMap(convertedValue)
                    is WritableArray -> writableArray.pushArray(convertedValue)
                    else -> writableArray.pushString(convertedValue.toString())
                }
            }
            
            writableArray
        } catch (e: Exception) {
            println("❌ EventDataConverter: Failed to convert list: ${e.message}")
            null
        }
    }
    
    /**
     * Validate if data can be safely converted to React Native format
     * 
     * @param data The data to validate
     * @return true if data can be safely converted, false otherwise
     */
    fun isConvertible(data: Any?): Boolean {
        return when (data) {
            null -> true
            is String, is Boolean, is Number -> true
            is Map<*, *> -> data.all { (key, value) -> 
                key is String && isConvertible(value) 
            }
            is List<*> -> data.all { isConvertible(it) }
            is Array<*> -> data.all { isConvertible(it) }
            else -> false
        }
    }
}