package com.trusteehelpcrunch

import android.util.Log
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContextBaseJavaModule
import com.facebook.react.bridge.ReactMethod
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.ReadableMapKeySetIterator
import com.google.firebase.messaging.RemoteMessage
import com.helpcrunch.library.core.HelpCrunch
import com.helpcrunch.library.core.models.user.HCUser
import com.helpcrunch.library.core.isHelpCrunchMessage


class TrusteeHelpCrunchModule(reactContext: ReactApplicationContext) :
  ReactContextBaseJavaModule(reactContext) {

  override fun getName(): String {
    return NAME
  }

  companion object {
    const val NAME = "TrusteeHelpCrunch"

      @Synchronized
      fun initialize(organization: String, appId: Int, secret: String) {
          HelpCrunch.initialize(organization, appId, secret)
      }

      fun isMessageFromHelpCrunch(remoteMessage: RemoteMessage): Boolean {
          try {
              return remoteMessage.isHelpCrunchMessage()
          } catch (err: Exception) {
              Log.e(NAME, "isIntercomPush error:")
              Log.e(NAME, err.toString())
              return false
          }
      }

      fun handleRemotePushMessage(remoteMessage: RemoteMessage) {
          try {
              HelpCrunch.showNotification(remoteMessage)
          } catch (err: Exception) {
              Log.e(NAME, "handleRemotePushMessage error:")
              Log.e(NAME, err.toString())
          }
      }
  }

    @ReactMethod
    fun presentHelpCrunch(promise: Promise) {

        // val currentActivity = this.currentActivity;
        // if (currentActivity != null) {
            try {
                HelpCrunch.showChatScreen()
                promise.resolve(true)
            } catch (err: Exception) {
                Log.e(NAME, "HelpCrunch.showChatScreen error:")
                Log.e(NAME, err.toString())
                promise.resolve(false)
            }
        
        //     return
        // }
        // promise.resolve(false);
    }

    @ReactMethod
    fun updateUser(userData: ReadableMap, promise: Promise) {
      val builder: HCUser.Builder = HCUser.Builder()
      val iterator: ReadableMapKeySetIterator = userData.keySetIterator()

        while (iterator.hasNextKey()) {
            val key = iterator.nextKey()
            when (key) {
                "email" -> builder.withEmail(userData.getString(key).toString())
                "userId" -> builder.withUserId(userData.getString(key).toString())
                "name" -> builder.withName(userData.getString(key).toString())
                "phone" -> builder.withPhone(userData.getString(key).toString())
                // "customAttributes" -> {
                //     if (readableMap.getType(key) == ReadableType.Map) {
                //         builder.withCustomAttributes(IntercomHelpers.deconstructReadableMap(readableMap.getMap(key), false))
                //     }
                // }
            }
        }


      val user: HCUser = builder.build()
        HelpCrunch.updateUser(user)
    }

    @ReactMethod
    fun forceUpdateUser(userData: ReadableMap, promise: Promise) {
        val builder: HCUser.Builder = HCUser.Builder()
        val iterator: ReadableMapKeySetIterator = userData.keySetIterator()

        while (iterator.hasNextKey()) {
            val key = iterator.nextKey()
            when (key) {
                "email" -> builder.withEmail(userData.getString(key).toString())
                "userId" -> builder.withUserId(userData.getString(key).toString())
                "name" -> builder.withName(userData.getString(key).toString())
                "phone" -> builder.withPhone(userData.getString(key).toString())
                // "customAttributes" -> {
                //     if (readableMap.getType(key) == ReadableType.Map) {
                //         builder.withCustomAttributes(IntercomHelpers.deconstructReadableMap(readableMap.getMap(key), false))
                //     }
                // }
            }
        }


        val user: HCUser = builder.build()
        HelpCrunch.forceUpdateUser(user)
    }

    @ReactMethod
    fun logout(promise: Promise) {
        HelpCrunch.logout()
        promise.resolve(true);
    }

    @ReactMethod
    fun trackEvent(eventName: String, eventData: ReadableMap, promise: Promise) {
        HelpCrunch.trackEvent(eventName, eventData.toHashMap())
        promise.resolve(true)
    }
}