package com.dynamsoft.reactnativelib.basicutils


import android.util.Base64
import com.dynamsoft.core.basic_structures.CapturedResultItem
import com.dynamsoft.dbr.AztecDetails
import com.dynamsoft.dbr.BarcodeDetails
import com.dynamsoft.dbr.BarcodeResultItem
import com.dynamsoft.dbr.DataMatrixDetails
import com.dynamsoft.dbr.DecodedBarcodesResult
import com.dynamsoft.dbr.ECISegment
import com.dynamsoft.dbr.OneDCodeDetails
import com.dynamsoft.dbr.PDF417Details
import com.dynamsoft.dbr.QRCodeDetails
import com.dynamsoft.dbr.SimplifiedBarcodeReaderSettings
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 BarcodeResultItem.toWritableMap(): WritableMap = Arguments.createMap().apply {
    merge((this@toWritableMap as CapturedResultItem).toSharedWritableMap())
//    putInt("format0_31", format.toInt())
//    putInt("format32_63", (format shr (32)).toInt())
    putString("_formatNumberString", format.toULong().toString())
    putString("formatString", formatString)
    putString("text", text)
    putString("bytes", Base64.encodeToString(bytes ?: byteArrayOf(), Base64.NO_WRAP))
    putMap("location", location.toWritableMap())
    putInt("confidence", confidence)
    putInt("angle", angle)
    putInt("moduleSize", moduleSize)
    putBoolean("isMirrored", isMirrored)
    putBoolean("isDPM", isDPM)
    when (details) {
        is QRCodeDetails -> putMap("qrCodeDetails", details.toWritableMap())
        is AztecDetails -> putMap("aztecDetails", details.toWritableMap())
        is OneDCodeDetails -> putMap("oneDCodeDetails", details.toWritableMap())
        is DataMatrixDetails -> putMap("dataMatrixDetails", details.toWritableMap())
        is PDF417Details -> putMap("pdf417Details", details.toWritableMap())
        else -> Unit
    }
    putArray("eciSegments", eciSegments?.toWritableArray())
}

fun Array<out BarcodeResultItem>.toWritableArray(): WritableArray = Arguments.createArray().apply {
    forEach { pushMap(it.toWritableMap()) }
}

fun DecodedBarcodesResult.toWritableMap(): WritableMap = Arguments.createMap().apply {
    merge(this@toWritableMap.toSharedWritableMap())
    putArray("items", items.toWritableArray())
}

fun SimplifiedBarcodeReaderSettings.toWritableMap(): WritableMap = Arguments.createMap().apply {
//    putInt("barcodeFormatIds0_31", barcodeFormatIds.toInt())
//    putInt("barcodeFormatIds32_63", barcodeFormatIds.shr(32).toInt())
    putString("_barcodeFormatIdsNumberString", barcodeFormatIds.toULong().toString())
    putInt("expectedBarcodesCount", expectedBarcodesCount)
    putInt("minResultConfidence", minResultConfidence)
    putInt("minBarcodeTextLength", minBarcodeTextLength)
    putString("barcodeTextRegExPattern", barcodeTextRegExPattern)
    putInt("maxThreadsInOneTask", maxThreadsInOneTask)
    putArray("localizationModes", localizationModes.toWritableArray())
    putArray("deblurModes", deblurModes.toWritableArray())
    putArray("grayscaleTransformationModes", grayscaleTransformationModes.toWritableArray())
    putArray("grayscaleEnhancementModes", grayscaleEnhancementModes.toWritableArray())
    putInt("scaleDownThreshold", scaleDownThreshold)
}

fun SimplifiedBarcodeReaderSettings.updateFromReadableMap(newSettings: ReadableMap) {
    if (newSettings.hasKey("_barcodeFormatIdsNumberString"))
        barcodeFormatIds = (newSettings.getString("_barcodeFormatIdsNumberString") ?: "0").toULong().toLong()
//    barcodeFormatIds = barcodeFormatIds0_31.toLong() or barcodeFormatIds32_63.toLong().shl(32)
//    val barcodeFormatIds0_31 = if (newSettings.hasKey("barcodeFormatIds0_31")) newSettings.getInt("barcodeFormatIds0_31") else 0
//    val barcodeFormatIds32_63 = if (newSettings.hasKey("barcodeFormatIds32_63")) newSettings.getInt("barcodeFormatIds32_63") else 0
    if (newSettings.hasKey("expectedBarcodesCount")) expectedBarcodesCount = newSettings.getInt("expectedBarcodesCount")
    if (newSettings.hasKey("minResultConfidence")) minResultConfidence = newSettings.getInt("minResultConfidence")
    if (newSettings.hasKey("minBarcodeTextLength")) minBarcodeTextLength = newSettings.getInt("minBarcodeTextLength")
    if (newSettings.hasKey("barcodeTextRegExPattern"))
        barcodeTextRegExPattern = newSettings.getString("barcodeTextRegExPattern")
    if (newSettings.hasKey("localizationModes"))
        localizationModes = newSettings.getArray("localizationModes")?.toIntArray()
    if (newSettings.hasKey("deblurModes"))
        deblurModes = newSettings.getArray("deblurModes")?.toIntArray()
    if (newSettings.hasKey("grayscaleTransformationModes"))
        grayscaleTransformationModes = newSettings.getArray("grayscaleTransformationModes")?.toIntArray()
    if (newSettings.hasKey("grayscaleEnhancementModes"))
        grayscaleEnhancementModes = newSettings.getArray("grayscaleEnhancementModes")?.toIntArray()
    if (newSettings.hasKey("scaleDownThreshold")) scaleDownThreshold = newSettings.getInt("scaleDownThreshold")
    maxThreadsInOneTask = if (newSettings.hasKey("maxThreadsInOneTask")) newSettings.getInt("maxThreadsInOneTask") else maxThreadsInOneTask
}

fun BarcodeDetails.toWritableMap(): WritableMap = Arguments.createMap().apply {
    when (this) {
        is QRCodeDetails -> {
            putInt("columns", columns)
            putInt("errorCorrectionLevel", errorCorrectionLevel)
            putInt("version", version)
            putInt("model", model)
            putInt("mode", mode)
            putInt("page", page)
            putInt("totalPage", totalPage)
            putInt("parityData", parityData.toInt())
            putInt("dataMaskPattern", dataMaskPattern)
            putArray("codewords", Arguments.fromArray(codewords))
        }

        is AztecDetails -> {
            putInt("rows", rows)
            putInt("columns", columns)
            putInt("layerNumber", layerNumber)
        }

        is OneDCodeDetails -> {
            putArray("startCharsBytes", Arguments.fromArray(startCharsBytes))
            putArray("stopCharsBytes", Arguments.fromArray(stopCharsBytes))
            putArray("checkDigitBytes", Arguments.fromArray(checkDigitBytes))
            putDouble("startPatternRange_lower", startPatternRange.lower.toDouble())
            putDouble("middlePatternRange_lower", middlePatternRange.lower.toDouble())
            putDouble("endPatternRange_lower", endPatternRange.lower.toDouble())
            putDouble("startPatternRange_upper", startPatternRange.upper.toDouble())
            putDouble("middlePatternRange_upper", middlePatternRange.upper.toDouble())
            putDouble("endPatternRange_upper", endPatternRange.upper.toDouble())
        }

        is DataMatrixDetails -> {
            putInt("rows", rows)
            putInt("columns", columns)
            putInt("dataRegionRows", dataRegionRows)
            putInt("dataRegionColumns", dataRegionColumns)
            putInt("dataRegionNumber", dataRegionNumber)
        }

        is PDF417Details -> {
            putInt("rows", rows)
            putInt("columns", columns)
            putInt("errorCorrectionLevel", errorCorrectionLevel)
            putBoolean("hasLeftRowIndicator", hasLeftRowIndicator())
            putBoolean("hasRightRowIndicator", hasRightRowIndicator())
            putArray("codewords", Arguments.fromArray(codewords))
        }

        else -> Unit
    }
}

fun Array<out ECISegment>.toWritableArray(): WritableArray = Arguments.createArray().apply {
    forEach { pushMap(it.toWritableMap()) }
}

fun ECISegment.toWritableMap(): WritableMap = Arguments.createMap().apply {
    putInt("eciValue", eciValue)
    putString("charsetEncoding", charsetEncoding)
    putInt("startIndex", startIndex)
    putInt("length", length)
}