package io.caf.documentdetector

import android.app.Activity
import android.content.Intent
import android.os.Build
import com.combateafraude.documentdetector.DocumentDetectorActivity
import com.combateafraude.documentdetector.input.DocumentDetector
import com.combateafraude.documentdetector.output.DocumentDetectorResult
import com.facebook.react.bridge.ActivityEventListener
import com.facebook.react.bridge.BaseActivityEventListener
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContext
import com.facebook.react.bridge.ReactContextBaseJavaModule
import com.facebook.react.bridge.ReactMethod
import com.facebook.react.bridge.WritableMap
import io.caf.documentdetector.utils.EncodeJSON
import io.caf.documentdetector.utils.SendEvent
import javax.annotation.Nonnull

class CafDocumentDetector(reactContext: ReactApplicationContext) :
    ReactContextBaseJavaModule(reactContext) {
    private val reactContext: ReactContext = reactContext

    private val activityEventListener: ActivityEventListener =
        object : BaseActivityEventListener() {
            override fun onActivityResult(
                activity: Activity, requestCode: Int, resultCode: Int, data: Intent?
            ) {
                if (requestCode == CAF_REQUEST_CODE) {
                    handleDocumentDetectorResult(data)
                }
            }
        }

    init {
        reactContext.addActivityEventListener(activityEventListener)
    }

    @Nonnull
    override fun getName(): String {
        return CAF_DOCUMENT_DETECTOR
    }

    @ReactMethod
    fun startDocumentDetector(mobileToken: String, personId: String, settings: String) {
        try {
            val builder: DocumentDetector.Builder =
                CafDocumentDetectorBrigde.start(
                    mobileToken = mobileToken,
                    personId = personId,
                    settings = settings
                )
            launchDocumentDetectorActivity(builder)
        } catch (e: Exception) {
            SendEvent.sendEvent(
                reactContext,
                DOCUMENT_DETECTOR_ERROR_EVENT,
                EncodeJSON.createLibraryErrorMap(e.message)
            )
        }
    }

    private fun launchDocumentDetectorActivity(documentDetectorBuilder: DocumentDetector.Builder) {
        reactApplicationContext.currentActivity?.let { activity: Activity ->
            val documentDetectorIntent =
                Intent(reactApplicationContext, DocumentDetectorActivity::class.java)

            documentDetectorIntent.putExtra(
                DocumentDetector.PARAMETER_NAME, documentDetectorBuilder.build()
            )

            activity.startActivityForResult(documentDetectorIntent, CAF_REQUEST_CODE)
        }
    }

    private fun handleDocumentDetectorResult(data: Intent?) {
        data ?: return SendEvent.sendEvent(reactContext, DOCUMENT_DETECTOR_CANCEL_EVENT, true)

        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            data.getSerializableExtra(
                DocumentDetectorResult.PARAMETER_NAME,
                DocumentDetectorResult::class.java
            )
        } else {
            data.getSerializableExtra(DocumentDetectorResult.PARAMETER_NAME) as DocumentDetectorResult?
        }

        result?.let {
            if (it.wasSuccessful()) {
                val map: WritableMap = EncodeJSON.createCaptureMap(result)
                return SendEvent.sendEvent(reactContext, DOCUMENT_DETECTOR_SUCCESS_EVENT, map)
            }

            it.sdkFailure?.let { failure ->
                return SendEvent.sendEvent(
                    reactContext,
                    DOCUMENT_DETECTOR_ERROR_EVENT,
                    EncodeJSON.createErrorMap(failure)
                )
            }
        }

        SendEvent.sendEvent(
            reactContext,
            DOCUMENT_DETECTOR_ERROR_EVENT,
            EncodeJSON.UNEXPECTED_REASON
        )
    }

    companion object {
        private const val CAF_DOCUMENT_DETECTOR = "CafDocumentDetector"
        private const val CAF_REQUEST_CODE = 50006
        private const val DOCUMENT_DETECTOR_SUCCESS_EVENT = "DocumentDetector_Success"
        private const val DOCUMENT_DETECTOR_CANCEL_EVENT = "DocumentDetector_Cancel"
        private const val DOCUMENT_DETECTOR_ERROR_EVENT = "DocumentDetector_Error"
    }
}