package com.contentsquare.rn.csq.utils

import com.contentsquare.rn.utils.ReactNativeTypesConverter
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.WritableMap
import com.facebook.react.bridge.Dynamic
import com.facebook.react.bridge.ReadableType
import com.facebook.react.bridge.WritableArray
import kotlin.collections.iterator

/**
 * Extension function to convert ReadableMap to Map<String, Any>
 */
fun ReadableMap.toMap(): Map<String, Any> {
    return this.toHashMap() as Map<String, Any>
}

/**
 * Extension function to convert Map to WritableMap
 * Enhanced version of MapUtil.convertMapToWritableMap with support for more types
 */
fun Map<*, *>.toWritableMap(): WritableMap {
    val writableMap = Arguments.createMap()
    for ((key, value) in this) {
        when (value) {
            null -> writableMap.putNull(key.toString())
            is Boolean -> writableMap.putBoolean(key.toString(), value)
            is Int -> writableMap.putInt(key.toString(), value)
            is Double -> writableMap.putDouble(key.toString(), value)
            is Float -> writableMap.putDouble(key.toString(), value.toDouble())
            is Long -> writableMap.putDouble(key.toString(), value.toDouble())
            is String -> writableMap.putString(key.toString(), value)
            is Map<*, *> -> writableMap.putMap(key.toString(), value.toWritableMap())
            is List<*> -> writableMap.putArray(key.toString(), value.toWritableArray())
            else -> writableMap.putString(key.toString(), value.toString())
        }
    }
    return writableMap
}

/**
 * Extension function to convert Any? to appropriate React Native type
 * Returns the value directly for primitives, or converts collections to WritableMap/WritableArray
 */
fun Any?.toWritable(): Any? {
    return when (this) {
        null -> null
        is Boolean -> this
        is Int -> this
        is Double -> this
        is Float -> this
        is Long -> this
        is String -> this
        is Map<*, *> -> this.toWritableMap()
        is List<*> -> this.toWritableArray()
        else -> this.toString()
    }
}

/**
 * Extension function to convert Dynamic to Any
 */
fun Dynamic.toAny(): Any? {
    return when (this.type) {
        ReadableType.Null -> null
        ReadableType.Boolean -> this.asBoolean()
        ReadableType.Number -> this.asDouble()
        ReadableType.String -> this.asString()
        ReadableType.Map -> ReactNativeTypesConverter.readableMapToMap(
            this.asMap(),
            emptyList(),
            emptyList()
        )

        ReadableType.Array -> this.asArray()
            ?.let { ReactNativeTypesConverter.readableArrayToList(it, emptyList(), emptyList()) }
    }
}

/**
 * Extension function to convert List to WritableArray
 */
fun List<*>.toWritableArray(): WritableArray {
    val writableArray = Arguments.createArray()
    for (item in this) {
        when (item) {
            null -> writableArray.pushNull()
            is Boolean -> writableArray.pushBoolean(item)
            is Int -> writableArray.pushInt(item)
            is Double -> writableArray.pushDouble(item)
            is Float -> writableArray.pushDouble(item.toDouble())
            is Long -> writableArray.pushDouble(item.toDouble())
            is String -> writableArray.pushString(item)
            is Map<*, *> -> writableArray.pushMap(item.toWritableMap())
            is List<*> -> writableArray.pushArray(item.toWritableArray())
            else -> writableArray.pushString(item.toString())
        }
    }
    return writableArray
}