package com.fireworksdk.bridge.reactnative.utils

import com.facebook.react.bridge.*
import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject


object FWDataConvertUtils {

  @Throws(JSONException::class)
  fun convertJsonObjectToWritableMap(jsonObject: JSONObject?): WritableMap? {
    if (jsonObject == null) {
      return null
    }
    val map: WritableMap = WritableNativeMap()
    val iterator = jsonObject.keys()
    while (iterator.hasNext()) {
      val key = iterator.next()
      when (val value = jsonObject[key]) {
          is JSONObject -> {
            map.putMap(key, convertJsonObjectToWritableMap(value))
          }
        is JSONArray -> {
          map.putArray(key, convertJsonObjectToWritableArray(value))
        }
        is Boolean -> {
          map.putBoolean(key, value)
        }
        is Int -> {
          map.putInt(key, value)
        }
        is Double -> {
          map.putDouble(key, value)
        }
        is String -> {
          map.putString(key, value)
        }
        else -> {
          map.putString(key, value.toString())
        }
      }
    }
    return map
  }

  @Throws(JSONException::class)
  fun convertJsonObjectToWritableArray(jsonArray: JSONArray?): WritableArray? {
    if (jsonArray == null) {
      return null
    }
    val array: WritableArray = WritableNativeArray()
    for (i in 0 until jsonArray.length()) {
      when (val value = jsonArray[i]) {
          is JSONObject -> {
            array.pushMap(convertJsonObjectToWritableMap(value))
          }
        is JSONArray -> {
          array.pushArray(convertJsonObjectToWritableArray(value))
        }
        is Boolean -> {
          array.pushBoolean(value)
        }
        is Int -> {
          array.pushInt(value)
        }
        is Double -> {
          array.pushDouble(value)
        }
        is String -> {
          array.pushString(value)
        }
        else -> {
          array.pushString(value.toString())
        }
      }
    }
    return array
  }

  @Throws(JSONException::class)
  fun convertReadableMapToJsonObject(readableMap: ReadableMap?): JSONObject? {
    if (readableMap == null) {
      return null
    }
    val `object` = JSONObject()
    val iterator = readableMap.keySetIterator()
    while (iterator.hasNextKey()) {
      val key = iterator.nextKey()
      when (readableMap.getType(key)) {
        ReadableType.Null -> `object`.put(key, JSONObject.NULL)
        ReadableType.Boolean -> `object`.put(key, readableMap.getBoolean(key))
        ReadableType.Number -> `object`.put(key, readableMap.getDouble(key))
        ReadableType.String -> `object`.put(key, readableMap.getString(key))
        ReadableType.Map -> `object`.put(key, convertReadableMapToJsonObject(readableMap.getMap(key)))
        ReadableType.Array -> `object`.put(key, convertReadableArrayToJsonObject(readableMap.getArray(key)))
      }
    }
    return `object`
  }

  @Throws(JSONException::class)
  fun convertReadableArrayToJsonObject(readableArray: ReadableArray?): JSONArray? {
    if (readableArray == null) {
      return null
    }
    val array = JSONArray()
    for (i in 0 until readableArray.size()) {
      when (readableArray.getType(i)) {
        ReadableType.Null -> {}
        ReadableType.Boolean -> array.put(readableArray.getBoolean(i))
        ReadableType.Number -> array.put(readableArray.getDouble(i))
        ReadableType.String -> array.put(readableArray.getString(i))
        ReadableType.Map -> array.put(convertReadableMapToJsonObject(readableArray.getMap(i)))
        ReadableType.Array -> array.put(convertReadableArrayToJsonObject(readableArray.getArray(i)))
      }
    }
    return array
  }
}