package com.smartechpushreactnative

import android.util.Log
import com.facebook.react.bridge.Callback
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.WritableArray
import com.facebook.react.bridge.WritableMap
import com.facebook.react.bridge.WritableNativeArray
import com.facebook.react.bridge.WritableNativeMap
import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
import com.netcore.android.smartechpush.SmartPush
import com.netcore.android.smartechpush.notification.SMTNotificationReceivedListener
import com.netcore.android.smartechpush.pnpermission.SMTNotificationPermissionCallback
import org.json.JSONArray
import org.json.JSONObject
import java.lang.ref.WeakReference


private const val SmartechNotificationReceived = "SmartechNotificationReceived"
private const val TAG = "SmartechPushReactNative"
const val NAME = "SmartechPushReactNative"
private lateinit var smartechPush: SmartPush;
private lateinit var reactContext: ReactApplicationContext;


class SmartechPushReactNativeImpl(private val reactApplicationContext: ReactApplicationContext) :
  SMTNotificationReceivedListener {

  init {
    reactContext = reactApplicationContext
    smartechPush = SmartPush.getInstance(WeakReference(reactApplicationContext))
    smartechPush.setSMTNotificationReceivedListener(this)
  }

  fun getName(): String {
    return NAME
  }

  fun getConstants(): MutableMap<String, Any> {
    val constants = mutableMapOf<String, Any>()
    constants[SmartechNotificationReceived] = SmartechNotificationReceived
    return constants
  }

  fun addListener(eventType: String) {
    // Intentionally blank
  }

  fun removeListeners(count: Double) {
    // Intentionally blank
  }

  override fun onNotificationReceived(payload: String) {
    try {
      val readableMap = jsonToWritableMap(JSONObject(payload))
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java).emit(
        SmartechNotificationReceived, readableMap
      )
    } catch (exception: Exception) {
      exception.printStackTrace();
    }

  }

  fun optPushNotification(value: Boolean?) {
    try {
      if (value != null) {
        smartechPush.optPushNotification(value)
      }
    } catch (e: Throwable) {
      e.printStackTrace()
    }
  }

  fun hasOptedPushNotification(callback: Callback?) {
    try {
      val isPushNotificationOpted: Boolean = smartechPush.hasOptedPushNotification()
      callbackHandler(callback, isPushNotificationOpted)
    } catch (e: Throwable) {
      e.printStackTrace()
      callbackHandlerError(callback, e.message ?: "Unknown error")
    }
  }

  fun getDevicePushToken(callback: Callback?) {
    try {
      val token: String = smartechPush.getDevicePushToken()
      callbackHandler(callback, token)
    } catch (e: Throwable) {
      e.printStackTrace()
      callbackHandlerError(callback, e.message ?: "Failed to get device token")
    }
  }

  fun setDevicePushToken(token: String?) {
    try {
      smartechPush.setDevicePushToken(token)
    } catch (e: Throwable) {
      e.printStackTrace()
    }
  }

  fun handlePushNotification(notificationData: String, callback: Callback?) {
    try {
      if (notificationData.isNotEmpty()) {
        val isPushFromSmartech: Boolean =
          smartechPush.isNotificationFromSmartech(JSONObject(notificationData))
        if (isPushFromSmartech) {
          smartechPush.handlePushNotification(notificationData)
        }
        callbackHandler(callback, isPushFromSmartech)
      } else {
        callbackHandler(callback, false)
      }
    } catch (e: Throwable) {
      e.printStackTrace()
      callbackHandlerError(
        callback,
        e.message ?: "Failed to handle push notification")
    }
  }

  fun requestNotificationPermission(callback: Callback?) {
    try {
      smartechPush.requestNotificationPermission(object : SMTNotificationPermissionCallback {
        override fun notificationPermissionStatus(i: Int) {
          callbackHandler(callback, i)
        }
      })
    } catch (e: Throwable) {
      e.printStackTrace()
    }
  }

  fun updateNotificationPermission(pnPermissionStatus: Double?) {
    try {
      if (pnPermissionStatus != null) {
        smartechPush.updateNotificationPermission(pnPermissionStatus.toInt())
      }
    } catch (e: Throwable) {
      e.printStackTrace()
    }
  }

  fun registerForPushNotificationWithAuthorizationOptions(
    alert: Boolean,
    badge: Boolean,
    sound: Boolean
  ) {
  }

  private fun jsonToWritableMap(jsonObject: JSONObject?): WritableMap? {
    if (jsonObject == null) {
      return null
    }

    val writableMap: WritableMap = WritableNativeMap()
    val iterator = jsonObject.keys()

    if (!iterator.hasNext()) {
      return null
    }

    while (iterator.hasNext()) {
      val key = iterator.next()

      try {
        val value = jsonObject.get(key)

        when (value) {
          null -> writableMap.putNull(key)
          is Boolean -> writableMap.putBoolean(key, value)
          is Int -> writableMap.putInt(key, value) // putInt is correct for WritableMap
          is Double -> writableMap.putDouble(key, value)
          is Long -> writableMap.putDouble(key, value.toDouble())
          is Float -> writableMap.putDouble(key, value.toDouble())
          is String -> writableMap.putString(key, value)
          is JSONObject -> writableMap.putMap(key, jsonToWritableMap(value))
          is JSONArray -> writableMap.putArray(key, jsonArrayToWritableArray(value))
          else -> {
            if (value.javaClass.isEnum) {
              writableMap.putString(key, value.toString())
            }
          }
        }
      } catch (e: Throwable) {
        e.printStackTrace()
      }
    }

    return writableMap
  }

  private fun jsonArrayToWritableArray(jsonArray: JSONArray?): WritableArray? {
    if (jsonArray == null || jsonArray.length() <= 0) {
      return null
    }

    val writableArray: WritableArray = WritableNativeArray()

    for (i in 0 until jsonArray.length()) {
      try {
        val value = jsonArray.get(i)

        when (value) {
          null -> writableArray.pushNull()
          is Boolean -> writableArray.pushBoolean(value)
          is Int -> writableArray.pushInt(value) // Corrected: pushInt for WritableArray
          is Double -> writableArray.pushDouble(value)
          is Long -> writableArray.pushDouble(value.toDouble())
          is Float -> writableArray.pushDouble(value.toDouble())
          is String -> writableArray.pushString(value)
          is JSONObject -> writableArray.pushMap(jsonToWritableMap(value))
          is JSONArray -> writableArray.pushArray(jsonArrayToWritableArray(value))
          else -> {
            if (value.javaClass.isEnum) {
              writableArray.pushString(value.toString())
            }
          }
        }
      } catch (e: Throwable) {
        e.printStackTrace()
      }
    }
    return writableArray
  }

  private fun callbackHandler(callback: Callback?, response: Any) {
    if (callback == null) {
      Log.i(TAG, "Callback is null.")
      return
    }
    try {
      callback.invoke(null, response)
    } catch (e: Throwable) {
      e.printStackTrace()
    }
  }

  private fun callbackHandlerError(callback: Callback?, errorMessage: String) {
    if (callback == null) {
      Log.i(TAG, "Callback is null.")
      return
    }

    Log.e(TAG, "Error occurred: $errorMessage")
    try {
      callback.invoke(errorMessage, null) // Error: error=errorMessage, result=null
    } catch (e: Throwable) {
      e.printStackTrace()
    }
  }
}