package io.scanbot.sdk.reactnative

import android.app.Application
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.modules.core.DeviceEventManagerModule
import io.scanbot.sdk.reactnative.extensions.toJSON
import io.scanbot.sdk.reactnative.extensions.toJSONArray
import io.scanbot.sdk.reactnative.extensions.toWritableMap
import io.scanbot.sdk_wrapper.document.operations.analytics.SBDAnalytics
import io.scanbot.sdk_wrapper.document.operations.barcode.detection.SBDBarcodesDetection
import io.scanbot.sdk_wrapper.document.operations.barcode.parsing.SBDBarcodeDocumentParser
import io.scanbot.sdk_wrapper.document.operations.doc_analyzer.SBDDocumentQualityAnalyzer
import io.scanbot.sdk_wrapper.document.operations.doc_data_extractor.SBDDocumentDataExtractor
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.mock.SBDMock
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.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.extensions.toListUnsafe


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

    companion object {
        const val NAME = "RNScanbotSDK"
        const val ANALYTICS_EVENT = "analyticsEvent"
    }

    override fun getName(): String {
        return NAME
    }

    @Suppress("UNUSED_PARAMETER")
    @ReactMethod
    fun addListener(type: String) {
        // Keep: Required for RN built in Event Emitter Calls, otherwise warnings are thrown in the console log.
    }

    @Suppress("UNUSED_PARAMETER")
    @ReactMethod
    fun removeListeners(type: Int) {
        // Keep: Required for RN built in Event Emitter Calls, otherwise warnings are thrown in the console log.
    }

    //region SDK Operations

    @ReactMethod
    fun initialize(options: ReadableMap, promise: Promise) {
        reactApplicationContextIfActiveOrWarn?.let {
            SBDSetupOperations.initializeSdk(
                it.applicationContext as Application,
                options.toJSON(),
                ScanbotSDKPluginResultDelegate(promise)
            )
        } ?: run {
            promise.reject("", "React Native Instance has already disappeared.")
        }
    }

    @ReactMethod
    fun getLicenseInfo(promise: Promise) {
        SBDLicenseOperations.getLicenseInfo(
            ScanbotSDKPluginResultDelegate(
                promise
            )
        )
    }

    @ReactMethod
    fun getOcrConfigs(promise: Promise) {
        SBDOcr.getConfigs(ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun cleanupStorage(promise: Promise) {
        SBDSetupOperations.cleanup(ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun setAnalyticsServiceCallback(promise: Promise) {
        SBDAnalytics.subscribe(
            resultDelegate = ScanbotSDKPluginResultDelegate(promise)
        ) { event ->
            reactApplicationContextIfActiveOrWarn?.getJSModule(
                DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
            )?.emit(ANALYTICS_EVENT, event.toWritableMap())
        }
    }

    @ReactMethod
    fun removeAnalyticsServiceCallback(promise: Promise) {
        SBDAnalytics.subscribe(
            resultDelegate = ScanbotSDKPluginResultDelegate(promise),
            eventHandler = null
        )
    }

    @ReactMethod
    fun mockCamera(params: ReadableMap, promise: Promise) {
        SBDMock.camera(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion SDK Operations

    //region Barcode Scanner

    @ReactMethod
    fun scanBarcodesFromImage(params: ReadableMap, promise: Promise) {
        SBDBarcodesDetection.detectOnImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun scanBarcodesFromPdf(params: ReadableMap, promise: Promise) {
        SBDBarcodesDetection.detectOnPdf(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun parseBarcodeDocument(params: ReadableMap, promise: Promise) {
        SBDBarcodeDocumentParser.parseDocument(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion Barcode Scanner

    //region Data Detectors

    @ReactMethod
    fun scanCheckFromImage(params: ReadableMap, promise: Promise) {
        SBDCheckRecognizer.recognize(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun scanCreditCardFromImage(params: ReadableMap, promise: Promise) {
        SBDCreditCardRecognizer.recognize(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun scanMrzFromImage(params: ReadableMap, promise: Promise) {
        SBDMrzRecognizer.recognize(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun extractDocumentDataFromImage(params: ReadableMap, promise: Promise) {
        SBDDocDataExtractorRecognizer.recognize(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun verifyDocument(params: ReadableMap, promise: Promise) {
        SBDDocumentDataExtractor.verifyDocument(
            params.getArray("documentParts")!!.toJSONArray().toListUnsafe(),
            ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion Data Detectors

    //region Document Scanner

    @ReactMethod
    fun createDocumentFromImages(params: ReadableMap, promise: Promise) {
        SBDDocument.createFromImages(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun createDocumentFromLegacyPages(params: ReadableMap, promise: Promise) {
        SBDDocument.createFromLegacyPages(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun createDocumentFromPdf(params: ReadableMap, promise: Promise) {
        SBDDocument.createFromPDF(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun documentExists(params: ReadableMap, promise: Promise) {
        SBDDocument.exists(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun loadDocument(params: ReadableMap, promise: Promise) {
        SBDDocument.load(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun getStoredDocumentUuids(promise: Promise) {
        SBDDocument.storedIDs(ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun cloneDocument(params: ReadableMap, promise: Promise) {
        SBDDocument.clone(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun deleteDocument(params: ReadableMap, promise: Promise) {
        SBDDocument.delete(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun deleteAllDocuments(promise: Promise) {
        SBDDocument.deleteAll(ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun addPages(params: ReadableMap, promise: Promise) {
        SBDDocument.addPages(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun movePage(params: ReadableMap, promise: Promise) {
        SBDDocument.movePage(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun modifyPage(params: ReadableMap, promise: Promise) {
        SBDDocument.modifyPage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun removePagesFromDocument(params: ReadableMap, promise: Promise) {
        SBDDocument.removePages(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun removeAllPages(params: ReadableMap, promise: Promise) {
        SBDDocument.removeAllPages(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun scanDocumentFromImage(params: ReadableMap, promise: Promise) {
        SBDDocumentDetection.scanFromImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun analyzeDocumentQualityOnImage(params: ReadableMap, promise: Promise) {
        SBDDocumentQualityAnalyzer.analyzeOnImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion Document Scanner

    //region Legacy Page

    @ReactMethod
    fun removeLegacyPage(params: ReadableMap, promise: Promise) {
        SBDLegacyPage.removePage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun removeAllLegacyPages(promise: Promise) {
        SBDLegacyPage.removeAllPages(ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun setDocumentImageOnLegacyPage(params: ReadableMap, promise: Promise) {
        SBDLegacyPage.setDocumentImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun refreshImageUrisOnLegacyPage(map: ReadableMap, promise: Promise) {
        SBDLegacyPage.refreshImageUris(
            map.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion Legacy Page

    //region Image Processing

    @ReactMethod
    fun applyFiltersOnImageFile(params: ReadableMap, promise: Promise) {
        SBDImageFilters.applyFiltersOnImageFile(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun applyFiltersOnImage(params: ReadableMap, promise: Promise) {
        SBDImageFilters.applyFiltersOnImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun rotateImageFile(params: ReadableMap, promise: Promise) {
        SBDImageOperations.rotateImageFile(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun rotateImage(params: ReadableMap, promise: Promise) {
        SBDImageOperations.rotateImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun resizeImageFile(params: ReadableMap, promise: Promise) {
        SBDImageOperations.resizeImageFile(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun resizeImage(params: ReadableMap, promise: Promise) {
        SBDImageOperations.resizeImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun cropImageFile(params: ReadableMap, promise: Promise) {
        SBDImageOperations.cropImageFile(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun cropImage(params: ReadableMap, promise: Promise) {
        SBDImageOperations.cropImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun readImageData(params: ReadableMap, promise: Promise) {
        SBDImageOperations.getImageData(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion Image Processing

    //region OCR Engine

    @ReactMethod
    fun recognizeOcrOnImages(params: ReadableMap, promise: Promise) {
        SBDOcr.recognizeOnImages(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun recognizeOcrOnDocument(params: ReadableMap, promise: Promise) {
        SBDOcr.recognizeOnDocument(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    //endregion OCR Engine

    //region PDF / TIFF Generation
    @ReactMethod
    fun generatePdfFromImages(params: ReadableMap, promise: Promise) {
        SBDPdf.generateFromImages(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun generatePdfFromDocument(params: ReadableMap, promise: Promise) {
        SBDPdf.createFromDocument(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun generateTiffFromImages(params: ReadableMap, promise: Promise) {
        SBDTiff.generateFromImages(params.toJSON(), ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun generateTiffFromDocument(params: ReadableMap, promise: Promise) {
        SBDTiff.createFromDocument(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun extractImageFilesFromPdf(params: ReadableMap, promise: Promise) {
        SBDExtractFromPdf.extractImages(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    //endregion PDF / TIFF Generation

    //region ImageRefs

    @ReactMethod
    fun imageRefDeserialize(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefDeserialize(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefSerialize(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefSerialize(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefFromImageFileUri(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefFromImageFileUri(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefFromEncodedBuffer(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefFromEncodedBuffer(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefHibernate(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefHibernate(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefClear(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefClear(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefInfo(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefInfo(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefSaveImage(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefSaveImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefEncodeImage(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefEncodeImage(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun imageRefRelease(params: ReadableMap, promise: Promise) {
        SBDImageOperations.imageRefRelease(
            params.toJSON(), ScanbotSDKPluginResultDelegate(promise)
        )
    }

    @ReactMethod
    fun makeSnapshot(promise: Promise) {
        SBDImageOperations.makeSnapshot(ScanbotSDKPluginResultDelegate(promise))
    }

    @ReactMethod
    fun imageRefReleaseAll(promise: Promise) {
        SBDImageOperations.releaseAllImageRefs(ScanbotSDKPluginResultDelegate(promise))
    }

    //endregion ImageRefs
}