package com.dynamsoft.reactnativelib.basicutils

import android.util.Log
import com.dynamsoft.core.basic_structures.CapturedResultItem
import com.dynamsoft.core.basic_structures.CompletionListener
import com.dynamsoft.core.basic_structures.EnumCapturedResultItemType
import com.dynamsoft.cvr.CaptureVisionRouter
import com.dynamsoft.cvr.CapturedResult
import com.dynamsoft.cvr.SimplifiedCaptureVisionSettings
import com.dynamsoft.dbr.BarcodeResultItem
import com.dynamsoft.dcp.ParsedResultItem
import com.dynamsoft.ddn.DeskewedImageResultItem
import com.dynamsoft.ddn.DetectedQuadResultItem
import com.dynamsoft.ddn.EnhancedImageResultItem
import com.dynamsoft.dlr.TextLineResultItem
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.WritableArray
import com.facebook.react.bridge.WritableMap

fun CaptureVisionRouter.startCapturingWithCallback(template: String, logTag: String) {
    startCapturing(template, object : CompletionListener {
        override fun onSuccess() {
            Log.i(logTag, "onSuccess: startCapturing($template)")
        }

        override fun onFailure(errorCode: Int, errorString: String?) {
            Log.e(logTag, "onFailure: startCapturing($template). ErrorCode: $errorCode. ErrorString: $errorString")
        }
    })
}

private fun Array<out CapturedResultItem>.toWritableArray(): WritableArray = Arguments.createArray().apply {
    forEach {
        when (it.type) {
            EnumCapturedResultItemType.CRIT_BARCODE -> {
                pushMap((it as BarcodeResultItem).toWritableMap())
            }
            EnumCapturedResultItemType.CRIT_TEXT_LINE -> {
                pushMap((it as TextLineResultItem).toWritableMap())
            }
            EnumCapturedResultItemType.CRIT_DETECTED_QUAD -> {
                pushMap((it as DetectedQuadResultItem).toWritableMap())
            }
            EnumCapturedResultItemType.CRIT_DESKEWED_IMAGE -> {
                pushMap((it as DeskewedImageResultItem).toWritableMap())
            }
            EnumCapturedResultItemType.CRIT_ENHANCED_IMAGE -> {
                pushMap((it as EnhancedImageResultItem).toWritableMap())
            }
            EnumCapturedResultItemType.CRIT_PARSED_RESULT -> {
                pushMap((it as ParsedResultItem).toWritableMap())
            }
        }
    }
}

fun CapturedResult.toWritableMap(): WritableMap = Arguments.createMap().apply {
    putInt("errorCode", errorCode)
    putString("errorMessage", errorMessage)
    putString("originalImageHashId",originalImageHashId)
    putArray("items", items.toWritableArray())
    putArray("rotationTransformMatrix",FloatArray(9).apply { rotationTransformMatrix.getValues(this) }.toWritableArray())
}

fun SimplifiedCaptureVisionSettings.toWritableMap() = Arguments.createMap().apply {
    putBoolean("outputOriginalImage", outputOriginalImage)
    putMap("roi", roi.toWritableMap())
    putBoolean("roiMeasuredInPercentage", roiMeasuredInPercentage)
    putInt("maxParallelTasks", maxParallelTasks)
    putInt("timeout", timeout)
    putInt("minImageCaptureInterval", minImageCaptureInterval)
    try {
        Class.forName("com.dynamsoft.dbr.SimplifiedBarcodeReaderSettings")
        putMap("barcodeSettings", barcodeSettings?.toWritableMap())
    } catch (e: ClassNotFoundException) {
        /* no-op */
    }

    try {
        Class.forName("com.dynamsoft.dlr.SimplifiedLabelRecognizerSettings")
        putMap("labelSettings", labelSettings?.toWritableMap())
    } catch (e: ClassNotFoundException) {
        /* no-op */
    }

    try {
        Class.forName("com.dynamsoft.ddn.SimplifiedDocumentNormalizerSettings")
        putMap("documentSettings", documentSettings?.toWritableMap())
    } catch (e: ClassNotFoundException) {
        /* no-op */
    }
}

fun SimplifiedCaptureVisionSettings.updateFromReadableMap(newSettings: ReadableMap) {
    outputOriginalImage = if (newSettings.hasKey("outputOriginalImage")) newSettings.getBoolean("outputOriginalImage") else outputOriginalImage
    roi = if (newSettings.hasKey("roi")) newSettings.getMap("roi")!!.toQuad() else roi
    roiMeasuredInPercentage =
        if (newSettings.hasKey("roiMeasuredInPercentage")) newSettings.getBoolean("roiMeasuredInPercentage") else roiMeasuredInPercentage
    maxParallelTasks = if (newSettings.hasKey("maxParallelTasks")) newSettings.getInt("maxParallelTasks") else maxParallelTasks
    timeout = if (newSettings.hasKey("timeout")) newSettings.getInt("timeout") else timeout
    minImageCaptureInterval =
        if (newSettings.hasKey("minImageCaptureInterval")) newSettings.getInt("minImageCaptureInterval") else minImageCaptureInterval
    try {
        Class.forName("com.dynamsoft.dbr.SimplifiedBarcodeReaderSettings")
        newSettings.getMap("barcodeSettings")?.let {
            barcodeSettings?.updateFromReadableMap(it)
        }
    } catch (e: ClassNotFoundException) {
        //keep
    }
    try {
        Class.forName("com.dynamsoft.dlr.SimplifiedLabelRecognizerSettings")
        newSettings.getMap("labelSettings")?.let {
            labelSettings?.updateFromReadableMap(it)
        }
    } catch (e: ClassNotFoundException) {
        //keep
    }


    try {
        Class.forName("com.dynamsoft.ddn.SimplifiedDocumentNormalizerSettings")
        newSettings.getMap("documentSettings")?.let {
            documentSettings?.updateFromReadableMap(it)
        }
    } catch (e: ClassNotFoundException) {
        Log.e("TAG", "updateFromReadableMap: No DDN")
        /* no-op */
    }
}