package com.biopassid.fingerprintsdkreactnative

import android.content.Context
import android.graphics.Bitmap
import android.graphics.Color
import android.graphics.Rect
import android.util.Base64
import android.util.Log
import android.util.Size
import br.com.biopassid.fingerprintsdk.config.FingerprintConfig
import br.com.biopassid.fingerprintsdk.config.enums.FingerprintCaptureType
import br.com.biopassid.fingerprintsdk.config.enums.FingerprintOutputType
import br.com.biopassid.fingerprintsdk.engine.FingerprintCaptureState
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.WritableNativeMap
import java.io.ByteArrayOutputStream

private const val TAG = "FingerprintSdkReactNativeModule/Utils"

object Utils {
  fun mapToBioPassIDFingerprintConfig(
    context: Context?,
    fingerprintConfig: ReadableMap
  ): FingerprintConfig {
    val mapConfig = fingerprintConfig.toHashMap()

    val licenseKey = mapConfig["licenseKey"] as String
    val numberFingersToCapture = mapConfig["numberFingersToCapture"] as Double
    val fontFamily = mapConfig["fontFamily"] as String
    val overlayColor = mapConfig["overlayColor"] as String
    val timeToCapture = mapConfig["timeToCapture"] as Double
    val captureType: FingerprintCaptureType =
      when (mapConfig["captureType"] as String) {
        "RIGHT_HAND_FINGERS" -> FingerprintCaptureType.RIGHT_HAND_FINGERS
        "LEFT_HAND_FINGERS" -> FingerprintCaptureType.LEFT_HAND_FINGERS
        else -> FingerprintCaptureType.THUMBS
      }
    val outputType: FingerprintOutputType =
      when (mapConfig["outputType"] as String) {
        "CAPTURE_AND_SEGMENTATION" -> FingerprintOutputType.CAPTURE_AND_SEGMENTATION
        else -> FingerprintOutputType.ONLY_CAPTURE
      }

    // Gets capture countdown properties
    val mapCaptureCountdown = mapConfig["captureCountdown"] as Map<*, *>
    val captureCountdownEnabled = mapCaptureCountdown["enabled"] as Boolean
    val captureCountdownBackgroundColor = mapCaptureCountdown["backgroundColor"] as String
    val captureCountdownProgressColor = mapCaptureCountdown["progressColor"] as String
    val captureCountdownTextColor = mapCaptureCountdown["textColor"] as String

    // Gets back button properties
    val mapBackButton = mapConfig["backButton"] as Map<*, *>
    val backButtonEnabled = mapBackButton["enabled"] as Boolean
    val backButtonBackgroundColor = mapBackButton["backgroundColor"] as String
    val backButtonPadding = mapBackButton["buttonPadding"] as Double
    val mapBackButtonSize = mapBackButton["buttonSize"] as Map<*, *>
    val backButtonSize = Size(
      (mapBackButtonSize["width"] as Double).toInt(),
      (mapBackButtonSize["height"] as Double).toInt()
    )
    val mapBackButtonIcon = mapBackButton["iconOptions"] as Map<*, *>
    val backButtonIconEnabled = mapBackButtonIcon["enabled"] as Boolean
    val backButtonIconFile = mapBackButtonIcon["iconFile"] as String
    val backButtonIconColor = mapBackButtonIcon["iconColor"] as String
    val mapBackButtonIconSize = mapBackButtonIcon["iconSize"] as Map<*, *>
    val backButtonIconSize = Size(
      (mapBackButtonIconSize["width"] as Double).toInt(),
      (mapBackButtonIconSize["height"] as Double).toInt()
    )
    val mapBackButtonLabel = mapBackButton["labelOptions"] as Map<*, *>
    val backButtonLabelEnabled = mapBackButtonLabel["enabled"] as Boolean
    val backButtonLabelContent = mapBackButtonLabel["content"] as String
    val backButtonLabelTextColor = mapBackButtonLabel["textColor"] as String
    val backButtonLabelTextSize = mapBackButtonLabel["textSize"] as Double

    // Gets help text properties
    val mapHelpText = mapConfig["helpText"] as Map<*, *>
    val helpTextEnabled = mapHelpText["enabled"] as Boolean
    val helpTextColor = mapHelpText["textColor"] as String
    val helpTextSize = mapHelpText["textSize"] as Double
    val mapHelpTextMessages = mapHelpText["messages"] as Map<*, *>
    val helpTextLeftHandMessage = mapHelpTextMessages["leftHandMessage"] as String
    val helpTextRightHandMessage = mapHelpTextMessages["rightHandMessage"] as String
    val helpTextThumbsMessage = mapHelpTextMessages["thumbsMessage"] as String

    // Gets finger ellipse properties
    val mapFingerEllipse = mapConfig["fingerEllipse"] as Map<*, *>
    val fingerEllipseEnabled = mapFingerEllipse["enabled"] as Boolean
    val fingerEllipseColor = mapFingerEllipse["ellipseColor"] as String

    // Gets distance indicator properties
    val mapDistanceIndicator = mapConfig["distanceIndicator"] as Map<*, *>
    val distanceIndicatorEnabled = mapDistanceIndicator["enabled"] as Boolean
    val distanceIndicatorSelectedBarColor = mapDistanceIndicator["selectedBarColor"] as String
    val distanceIndicatorUnselectedBarColor = mapDistanceIndicator["unselectedBarColor"] as String
    val distanceIndicatorArrowColor = mapDistanceIndicator["arrowColor"] as String

    // Gets too close text properties
    val mapTooCloseText = mapDistanceIndicator["tooCloseText"] as Map<*, *>
    val tooCloseTextEnabled = mapTooCloseText["enabled"] as Boolean
    val tooCloseTextContent = mapTooCloseText["content"] as String
    val tooCloseTextColor = mapTooCloseText["textColor"] as String
    val tooCloseTextSize = mapTooCloseText["textSize"] as Double

    // Gets too far text properties
    val mapTooFarText = mapDistanceIndicator["tooFarText"] as Map<*, *>
    val tooFarTextEnabled = mapTooFarText["enabled"] as Boolean
    val tooFarTextContent = mapTooFarText["content"] as String
    val tooFarTextColor = mapTooFarText["textColor"] as String
    val tooFarTextSize = mapTooFarText["textSize"] as Double

    // Gets font family resource
    val fontFamilyRes = getResourceId(context, "font", fontFamily)

    // Gets back button image resource
    val backButtonIconRes = getResourceId(context, "drawable", backButtonIconFile)

    val config = FingerprintConfig()
    config.licenseKey = licenseKey
    config.numberFingersToCapture = numberFingersToCapture.toInt()
    config.fontFamily = fontFamilyRes ?: br.com.biopassid.fingerprintsdk.R.font.fingerprintsdk_opensans_regular
    config.overlayColor = hexStringToColor(overlayColor) ?: config.overlayColor
    config.timeToCapture = timeToCapture.toInt()
    config.captureType = captureType
    config.outputType = outputType

    // Gets capture countdown properties
    config.captureCountdown.enabled = captureCountdownEnabled
    config.captureCountdown.backgroundColor = hexStringToColor(captureCountdownBackgroundColor) ?: config.captureCountdown.backgroundColor
    config.captureCountdown.progressColor = hexStringToColor(captureCountdownProgressColor) ?: config.captureCountdown.progressColor
    config.captureCountdown.textColor = hexStringToColor(captureCountdownTextColor) ?: config.captureCountdown.textColor

    // Sets back button properties
    config.backButton.enabled = backButtonEnabled
    config.backButton.backgroundColor =
      hexStringToColor(backButtonBackgroundColor) ?: config.backButton.backgroundColor
    config.backButton.buttonPadding = backButtonPadding.toInt()
    config.backButton.buttonSize = backButtonSize
    config.backButton.iconOptions.enabled = backButtonIconEnabled
    config.backButton.iconOptions.iconFile = backButtonIconRes ?: br.com.biopassid.fingerprintsdk.R.drawable.fingerprintsdk_ic_close
    config.backButton.iconOptions.iconColor =
      hexStringToColor(backButtonIconColor) ?: config.backButton.iconOptions.iconColor
    config.backButton.iconOptions.iconSize = backButtonIconSize
    config.backButton.labelOptions.enabled = backButtonLabelEnabled
    config.backButton.labelOptions.content = backButtonLabelContent
    config.backButton.labelOptions.textColor =
      hexStringToColor(backButtonLabelTextColor) ?: config.backButton.labelOptions.textColor
    config.backButton.labelOptions.textSize = backButtonLabelTextSize.toInt()

    // Sets help text properties
    config.helpText.enabled = helpTextEnabled
    config.helpText.textColor = hexStringToColor(helpTextColor) ?: config.helpText.textColor
    config.helpText.textSize = helpTextSize.toInt()
    config.helpText.messages.leftHandMessage = helpTextLeftHandMessage
    config.helpText.messages.rightHandMessage = helpTextRightHandMessage
    config.helpText.messages.thumbsMessage = helpTextThumbsMessage

    // Sets finger ellipse properties
    config.fingerEllipse.enabled = fingerEllipseEnabled
    config.fingerEllipse.ellipseColor =
      hexStringToColor(fingerEllipseColor) ?: config.fingerEllipse.ellipseColor

    // Gets distance indicator properties
    config.distanceIndicator.enabled = distanceIndicatorEnabled
    config.distanceIndicator.selectedBarColor = hexStringToColor(distanceIndicatorSelectedBarColor)
      ?: config.distanceIndicator.selectedBarColor
    config.distanceIndicator.unselectedBarColor =
      hexStringToColor(distanceIndicatorUnselectedBarColor)
        ?: config.distanceIndicator.unselectedBarColor
    config.distanceIndicator.arrowColor =
      hexStringToColor(distanceIndicatorArrowColor) ?: config.distanceIndicator.arrowColor

    // Sets too close text properties
    config.distanceIndicator.tooCloseText.enabled = tooCloseTextEnabled
    config.distanceIndicator.tooCloseText.content = tooCloseTextContent
    config.distanceIndicator.tooCloseText.textColor =
      hexStringToColor(tooCloseTextColor) ?: config.distanceIndicator.tooCloseText.textColor
    config.distanceIndicator.tooCloseText.textSize = tooCloseTextSize.toInt()

    // Sets too far text properties
    config.distanceIndicator.tooFarText.enabled = tooFarTextEnabled
    config.distanceIndicator.tooFarText.content = tooFarTextContent
    config.distanceIndicator.tooFarText.textColor =
      hexStringToColor(tooFarTextColor) ?: config.distanceIndicator.tooFarText.textColor
    config.distanceIndicator.tooFarText.textSize = tooFarTextSize.toInt()

    return config
  }

  fun onFingerCaptureEventToNativeMap(bitmaps: List<Bitmap>, error: String?): WritableNativeMap {
    val base64List: ArrayList<String> = ArrayList()
    for (bitmap in bitmaps) {
      val byteArray = bitmapToBase64(bitmap)
      base64List.add(byteArray)
    }
    val onFingerCaptureMap =
      hashMapOf<String, Any?>("images" to base64List, "error" to error)
    return Arguments.makeNativeMap(onFingerCaptureMap)
  }

  fun onStatusChangedEventToNativeMap(state: FingerprintCaptureState): WritableNativeMap {
    val onStatusChangedMap =
      hashMapOf<String, Any>("state" to state.name)
    return Arguments.makeNativeMap(onStatusChangedMap)
  }

  fun onFingerDetectedEventToNativeMap(fingerRects: List<Rect>): WritableNativeMap {
    val rectList: ArrayList<Map<String, Int>> = ArrayList()
    for (fingerRect in fingerRects) {
      val fingerRectMap = hashMapOf(
        "left" to fingerRect.left,
        "top" to fingerRect.top,
        "right" to fingerRect.right,
        "bottom" to fingerRect.bottom
      )
      rectList.add(fingerRectMap)
    }
    val onFingerDetectedMap =
      hashMapOf<String, Any>("fingerRects" to rectList)
    return Arguments.makeNativeMap(onFingerDetectedMap)
  }

  private fun bitmapToBase64(bitmap: Bitmap): String {
    val stream = ByteArrayOutputStream()
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
    val byteArray = stream.toByteArray()
    bitmap.recycle()
    return Base64.encodeToString(byteArray, Base64.NO_WRAP)
  }

  private fun hexStringToColor(hexString: String): Int? {
    return try {
      Color.parseColor(hexString)
    } catch (e: Exception) {
      Log.e(TAG, "Error when trying parse color.")
      null
    }
  }

  private fun getResourceId(
    context: Context?,
    resourceName: String,
    variableName: String
  ): Int? {
    try {
      val resId = context?.resources?.getIdentifier(
        variableName,
        resourceName,
        context.packageName
      )
      if (resId != null && resId != 0) {
        return resId
      }
      Log.e(TAG, "Could not get resource id.")
      return null
    } catch (e: Exception) {
      Log.e(TAG, "Could not get resource id.")
      return null
    }
  }
}