package io.scanbot.sdk.capacitor

import android.app.Application
import android.content.Intent
import com.getcapacitor.JSObject
import com.getcapacitor.Plugin
import com.getcapacitor.PluginCall
import com.getcapacitor.PluginMethod
import com.getcapacitor.annotation.CapacitorPlugin
import io.scanbot.sdk_wrapper.barcode.rtuui.SBRtuUiRequestCodes
import io.scanbot.sdk_wrapper.document.operations.barcode_detection.SBDBarcodesDetection
import io.scanbot.sdk_wrapper.document.operations.doc_analyzer.SBDDocumentQualityAnalyzer
import io.scanbot.sdk_wrapper.document.operations.doc_detection.SBDDocumentDetection
import io.scanbot.sdk_wrapper.document.operations.document.SBDDocument
import io.scanbot.sdk_wrapper.document.operations.image_filters.SBDImageFilters
import io.scanbot.sdk_wrapper.document.operations.image_operations.SBDImageOperations
import io.scanbot.sdk_wrapper.document.operations.legacy_page.SBDLegacyPage
import io.scanbot.sdk_wrapper.document.operations.license.SBDLicenseOperations
import io.scanbot.sdk_wrapper.document.operations.ocr.SBDOcr
import io.scanbot.sdk_wrapper.document.operations.pdf.SBDPdf
import io.scanbot.sdk_wrapper.document.operations.pdf_extraction.SBDExtractFromPdf
import io.scanbot.sdk_wrapper.document.operations.recognizers.check.SBDCheckRecognizer
import io.scanbot.sdk_wrapper.document.operations.recognizers.credit_card.SBDCreditCardRecognizer
import io.scanbot.sdk_wrapper.document.operations.recognizers.doc_data_extractor.SBDDocDataExtractorRecognizer
import io.scanbot.sdk_wrapper.document.operations.recognizers.ehic.SBDEhicRecognizer
import io.scanbot.sdk_wrapper.document.operations.recognizers.medical_cert.SBDMedicalCertRecognizer
import io.scanbot.sdk_wrapper.document.operations.recognizers.mrz.SBDMrzRecognizer
import io.scanbot.sdk_wrapper.document.operations.setup.SBDSetupOperations
import io.scanbot.sdk_wrapper.document.operations.tif.SBDTiff
import io.scanbot.sdk_wrapper.document.rtuui.SBDRtuUi
import io.scanbot.sdk_wrapper.document.rtuui.SBDRtuUiRequestCodes
import org.json.JSONObject

@CapacitorPlugin(
    name = "ScanbotSDKCapacitor",
    requestCodes = [
        SBDRtuUiRequestCodes.DOCUMENT_SCANNER,
        SBDRtuUiRequestCodes.LEGACY_DOCUMENT_SCANNER,
        SBDRtuUiRequestCodes.LEGACY_FINDER_DOCUMENT_SCANNER,
        SBDRtuUiRequestCodes.CROPPING_SCREEN,
        SBDRtuUiRequestCodes.LEGACY_CROPPING_SCREEN,
        SBDRtuUiRequestCodes.EHIC_SCANNER,
        SBDRtuUiRequestCodes.DOCUMENT_DATA_EXTRACTOR,
        SBDRtuUiRequestCodes.MRZ_SCANNER,
        SBDRtuUiRequestCodes.MC_RECOGNIZER,
        SBDRtuUiRequestCodes.TEXT_PATTERN_SCANNER,
        SBDRtuUiRequestCodes.CHECK_RECOGNIZER,
        SBDRtuUiRequestCodes.VIN_SCANNER,
        SBDRtuUiRequestCodes.CREDIT_CARD_SCANNER,
        SBRtuUiRequestCodes.BARCODE_SCANNER,
    ]
)
class ScanbotSDKCapacitorPlugin : Plugin() {

    companion object {
        const val missingRequiredPropertyErrorMsg = "Missing required property "
    }

    private var barcodeItemMapperPluginCall: PluginCall? = null


    @PluginMethod
    fun initializeSDK(call: PluginCall) {
        SBDSetupOperations.initializeSdk(
            (context.applicationContext as Application),
            call.data,
            ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun getLicenseInfo(call: PluginCall) {
        SBDLicenseOperations.getLicenseInfo(ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun detectBarcodesOnImage(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDBarcodesDetection.detectOnImage(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun applyImageFilters(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val imageFilters = call.asArrayOrReject("filters")?.toList<JSONObject>() ?: return

        SBDImageFilters.applyFiltersOnImage(
            imageFileUri, imageFilters, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun applyImageFiltersOnPage(call: PluginCall) {
        val page = call.asJsonOrReject("page") ?: return
        val imageFilters = call.asArrayOrReject("filters")?.toList<JSONObject>() ?: return

        SBDImageFilters.applyFiltersOnPage(page, imageFilters, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun getImageData(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return

        SBDImageOperations.getImageData(imageFileUri, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun rotateImage(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val degrees = call.asDoubleOrReject("degrees") ?: return

        SBDImageOperations.rotateImage(imageFileUri, degrees, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun createPage(call: PluginCall) {
        val imageUri = call.asStringOrReject("imageUri") ?: return

        SBDLegacyPage.createPage(imageUri, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun removePage(call: PluginCall) {
        val page = call.asJsonOrReject("page") ?: return

        SBDLegacyPage.removePage(page, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun rotatePage(call: PluginCall) {
        val page = call.asJsonOrReject("page") ?: return
        val times = call.asIntOrReject("times") ?: return

        SBDLegacyPage.rotatePage(page, times, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun setDocumentImage(call: PluginCall) {
        val page = call.asJsonOrReject("page") ?: return
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return

        SBDLegacyPage.setDocumentImage(page, imageFileUri, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun detectDocument(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return

        SBDDocumentDetection.detectDocumentOnImage(
            imageFileUri, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun detectDocumentOnPage(call: PluginCall) {
        val page = call.asJsonOrReject("page") ?: return

        SBDDocumentDetection.detectDocumentOnPage(page, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun documentQualityAnalyzer(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDDocumentQualityAnalyzer.analyze(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun extractImagesFromPdf(call: PluginCall) {
        SBDExtractFromPdf.extractImages(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun extractPagesFromPdf(call: PluginCall) {
        SBDExtractFromPdf.extractLegacyPages(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun recognizeCheck(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return
        val acceptedCheckStandards = call.getArray("acceptedCheckStandards", null)

        SBDCheckRecognizer.recognize(
            imageFileUri,
            configuration,
            acceptedCheckStandards,
            ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun recognizeMrz(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDMrzRecognizer.recognize(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun recognizeMedicalCertificate(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDMedicalCertRecognizer.recognize(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun recognizeEHIC(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDEhicRecognizer.recognize(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun recognizeCreditCard(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDCreditCardRecognizer.recognize(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun documentDataExtractor(call: PluginCall) {
        val imageFileUri = call.asStringOrReject("imageFileUri") ?: return
        val configuration = call.asJsonOrReject("configuration") ?: return

        SBDDocDataExtractorRecognizer.recognize(
            imageFileUri, configuration, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun refreshImageUris(call: PluginCall) {
        SBDLegacyPage.refreshImageUris(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun getOCRConfigs(call: PluginCall) {
        SBDOcr.getConfigs(ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun cleanup(call: PluginCall) {
        SBDSetupOperations.cleanup(ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun performOCR(call: PluginCall) {
        SBDOcr.perform(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun createPDF(call: PluginCall) {
        SBDPdf.create(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun writeTIFF(call: PluginCall) {
        SBDTiff.write(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    //region DocumentAPIs

    @PluginMethod
    fun createDocument(call: PluginCall) {
        SBDDocument.create(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun createDocumentFromLegacyPages(call: PluginCall) {
        SBDDocument.createFromLegacyPages(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun createDocumentFromPDF(call: PluginCall) {
        val pdfUri = call.asStringOrReject("pdfUri") ?: return

        SBDDocument.createFromPDF(pdfUri, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun documentExists(call: PluginCall) {
        val documentID = call.asStringOrReject("documentID") ?: return

        SBDDocument.exists(documentID, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun loadDocument(call: PluginCall) {
        val documentID = call.asStringOrReject("documentID") ?: return

        SBDDocument.load(documentID, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun storedDocumentIDs(call: PluginCall) {
        SBDDocument.storedIDs(ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun cloneDocument(call: PluginCall) {
        val documentID = call.asStringOrReject("documentID") ?: return

        SBDDocument.clone(documentID, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun deleteDocument(call: PluginCall) {
        val documentID = call.asStringOrReject("documentID") ?: return

        SBDDocument.delete(documentID, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun deleteAllDocuments(call: PluginCall) {
        SBDDocument.deleteAll(ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun createPDFForDocument(call: PluginCall) {
        SBDPdf.createFromDocument(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun createTIFF(call: PluginCall) {
        SBDTiff.createFromDocument(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun addPage(call: PluginCall) {
        SBDDocument.addPage(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun movePage(call: PluginCall) {
        SBDDocument.movePage(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun modifyPage(call: PluginCall) {
        SBDDocument.modifyPage(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun removePageFromDocument(call: PluginCall) {
        SBDDocument.removePage(call.data, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun removeAllPages(call: PluginCall) {
        val documentID = call.asStringOrReject("documentID") ?: return

        SBDDocument.removeAllPages(documentID, ScanbotSDKPluginResultDelegate(call))
    }

    //endregion DocumentAPIs

    //region ----RTU UI----

    @PluginMethod
    fun startDocumentScanner(call: PluginCall) {
        SBDRtuUi.startLegacyDocumentScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeDocumentScanner(call: PluginCall) {
        SBDRtuUi.closeLegacyDocumentScanner(activity, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun startFinderDocumentScanner(call: PluginCall) {
        SBDRtuUi.startLegacyFinderDocumentScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeFinderDocumentScanner(call: PluginCall) {
        SBDRtuUi.closeLegacyFinderDocumentScanner(activity, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun startCroppingScreen(call: PluginCall) {
        val page = call.asJsonOrReject("page") ?: return
        val config = call.asJsonOrReject("configuration") ?: return

        SBDRtuUi.startLegacyCroppingScreen(
            activity, page, config, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeCroppingScreen(call: PluginCall) {
        SBDRtuUi.closeLegacyCroppingScreen(activity, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun startDocumentDataExtractor(call: PluginCall) {
        SBDRtuUi.startDocumentDataExtractor(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeDocumentDataExtractor(call: PluginCall) {
        SBDRtuUi.closeDocumentDataExtractor(activity, ScanbotSDKPluginResultDelegate(call))
    }


    @PluginMethod
    fun startEHICScanner(call: PluginCall) {
        SBDRtuUi.startEhicScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeEHICScanner(call: PluginCall) {
        SBDRtuUi.closeEhicScanner(activity, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun startMedicalCertificateScanner(call: PluginCall) {
        SBDRtuUi.startMedicalCertRecognizer(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeMedicalCertificateScanner(call: PluginCall) {
        SBDRtuUi.closeMedicalCertRecognizer(activity, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun startCheckScanner(call: PluginCall) {
        SBDRtuUi.startCheckRecognizer(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeCheckScanner(call: PluginCall) {
        SBDRtuUi.closeCheckRecognizer(activity, ScanbotSDKPluginResultDelegate(call))
    }

    @PluginMethod
    fun startVinScanner(call: PluginCall) {
        SBDRtuUi.startVinScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun closeVinScanner(call: PluginCall) {
        SBDRtuUi.closeVinScanner(activity, ScanbotSDKPluginResultDelegate(call))
    }

    //endregion ----RTU UI----

    //region RTU UI V2

    @PluginMethod
    fun startDocumentScannerV2(call: PluginCall) {
        SBDRtuUi.startDocumentScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun startCroppingScreenV2(call: PluginCall) {
        SBDRtuUi.startCroppingScreen(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun startBarcodeScanner(pluginCall: PluginCall) {
        if (barcodeItemMapperPluginCall != null) {
            SBDRtuUi.startBarcodeScanner(
                activity, pluginCall.data, ScanbotSDKPluginResultDelegate(pluginCall)
            ) { barcodeItem ->
                barcodeItemMapperPluginCall?.resolve(JSObject.fromJSONObject(barcodeItem)) ?: run {
                    // This code should never be executed, but just in case
                    SBDRtuUi.onBarcodeItemMapper(barcodeItemUuid(barcodeItem))
                }
            }
        } else {
            SBDRtuUi.startBarcodeScanner(
                activity, pluginCall.data, ScanbotSDKPluginResultDelegate(pluginCall)
            )
        }
    }

    @PluginMethod
    fun startMRZScannerV2(call: PluginCall) {
        SBDRtuUi.startMrzScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun startTextPatternScannerV2(call: PluginCall) {
        SBDRtuUi.startTextPatternScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    @PluginMethod
    fun startCreditCardScannerV2(call: PluginCall) {
        SBDRtuUi.startCreditCardScanner(
            activity, call.data, ScanbotSDKPluginResultDelegate(call)
        )
    }

    //endregion RTU UI V2

    //region ImageRef

    @PluginMethod
    fun imageRefSerialize(pluginCall: PluginCall) {
        SBDImageOperations.imageRefSerialize(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefDeserialize(pluginCall: PluginCall) {
        SBDImageOperations.imageRefDeserialize(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefFromImageFileUri(pluginCall: PluginCall) {
        SBDImageOperations.imageRefFromImageFileUri(
            pluginCall.getString("uri")!!,
            pluginCall.getObject("options")!!,
            ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefFromEncodedBuffer(pluginCall: PluginCall) {
        SBDImageOperations.imageRefFromEncodedBuffer(
            pluginCall.getString("buffer")!!,
            pluginCall.getObject("options")!!,
            ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefClone(pluginCall: PluginCall) {
        SBDImageOperations.imageRefClone(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefHibernate(pluginCall: PluginCall) {
        SBDImageOperations.imageRefHibernate(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefClear(pluginCall: PluginCall) {
        SBDImageOperations.imageRefClear(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefInfo(pluginCall: PluginCall) {
        SBDImageOperations.imageRefInfo(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefSaveImage(pluginCall: PluginCall) {
        SBDImageOperations.imageRefSaveImage(
            pluginCall.getString("uniqueId")!!,
            pluginCall.getString("path")!!,
            pluginCall.getObject("options")!!,
            ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefEncodeImage(pluginCall: PluginCall) {
        SBDImageOperations.imageRefEncodeImage(
            pluginCall.getString("uniqueId")!!,
            pluginCall.getObject("options")!!,
            ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefRelease(pluginCall: PluginCall) {
        SBDImageOperations.imageRefRelease(
            pluginCall.getString("uniqueId")!!, ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun makeSnapshot(pluginCall: PluginCall) {
        SBDImageOperations.makeSnapshot(
            ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    @PluginMethod
    fun imageRefReleaseAll(pluginCall: PluginCall) {
        SBDImageOperations.releaseAllImageRefs(
            ScanbotSDKPluginResultDelegate(pluginCall)
        )
    }

    //endregion ImageRef

    //region Helper methods that are used only by us from the plugin middle layer (not exposed to the users)

    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
    fun registerBarcodeItemMapperCallback(pluginCall: PluginCall) {
        barcodeItemMapperPluginCall = pluginCall.apply {
            setKeepAlive(true)
        }
    }

    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
    fun onBarcodeItemMapper(pluginCall: PluginCall) {
        val barcodeMappedData = pluginCall.getObject("barcodeMappedData")

        SBDRtuUi.onBarcodeItemMapper(
            pluginCall.getString("barcodeItemUuid")!!, barcodeMappedData
        )
    }

    //endregion Helper methods that are used only by us from the plugin middle layer (not exposed to the users)

    //region Private helper methods

    private fun barcodeItemUuid(barcodeItem: JSONObject): String {
        val text = barcodeItem.getString("text")
        val ext = barcodeItem.getString("upcEanExtension")
        val format = barcodeItem.getString("format")
        return "${text}${ext}_$format"
    }

    //endregion Private helper methods

    @Suppress("OVERRIDE_DEPRECATION", "DEPRECATION")
    override fun handleOnActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        val handledByWrapper = SBDRtuUi.onActivityResult(requestCode, resultCode, data)

        if (handledByWrapper) {
            if (requestCode == SBRtuUiRequestCodes.BARCODE_SCANNER) {
                barcodeItemMapperPluginCall?.release(bridge)
                barcodeItemMapperPluginCall = null
            }
        } else {
            super.handleOnActivityResult(requestCode, resultCode, data)
        }
    }
}