package com.dynamsoft.reactnativelib.utility

import android.graphics.Rect
import com.dynamsoft.core.basic_structures.DSRect
import com.dynamsoft.core.basic_structures.EnumImageFileFormat
import com.dynamsoft.core.basic_structures.ImageData
import com.dynamsoft.core.basic_structures.Quadrilateral
import com.dynamsoft.utility.EnumFilterType
import com.dynamsoft.utility.ImageDrawer
import com.dynamsoft.utility.ImageIO
import com.dynamsoft.utility.ImageProcessor
import com.dynamsoft.utility.UtilityException
import com.facebook.react.bridge.ReactApplicationContext

class ImageManagerModuleImpl(private val reactContext: ReactApplicationContext) {
    companion object {
        const val NAME = "DynamsoftImageManagerModule"
    }

    private val imageIo by lazy { ImageIO() }
    private val imageProcessor by lazy { ImageProcessor() }
    private val imageDrawer by lazy { ImageDrawer() }

    fun getName() = NAME

    fun install(): Boolean {
        reactContext.javaScriptContextHolder?.apply {
            nativeInstall(get())
        }
        return true
    }

    fun saveToFileCalledInJsi(imageData: ImageData, filePath: String, overWrite: Boolean) {
        imageIo.saveToFile(imageData, filePath, overWrite)
    }

    fun readFromFileCalledInJsi(filePath: String): ImageData? {
        return try {
            imageIo.readFromFile(filePath)
        } catch (_: UtilityException) {
            null
        }
    }

    fun readFromMemoryCalledInJsi(buffer: ByteArray): ImageData? {
        return try {
            imageIo.readFromMemory(buffer)
        } catch (_: UtilityException) {
            null
        }
    }


    fun saveToMemoryCalledInJsi(imageData: ImageData, @EnumImageFileFormat format: Int): ByteArray? {
        return try {
            imageIo.saveToMemory(imageData, format)
        } catch (_: UtilityException) {
            null
        }
    }

    fun drawOnImageCalledInJsi(imageData: ImageData, quads: Array<Quadrilateral>, color: Int, thickness: Int): ImageData {
        return imageDrawer.drawOnImage(imageData, quads, color, thickness)
    }

    fun cropImageCalledInJsi(imageData: ImageData, dsRect: DSRect): ImageData? {
        val rect = if (dsRect.measuredInPercentage) {
            Rect(
                (dsRect.left * imageData.width).toInt(),
                (dsRect.top * imageData.height).toInt(),
                (dsRect.right * imageData.width).toInt(),
                (dsRect.bottom * imageData.height).toInt()
            )
        } else {
            Rect(dsRect.left.toInt(), dsRect.top.toInt(), dsRect.right.toInt(), dsRect.bottom.toInt())
        }
        return try {
            imageProcessor.cropImage(imageData, rect)
        } catch (e: UtilityException) {
            null
        }
    }

    fun cropAndDeskewImageCalledInJsi(imageData: ImageData, quad: Quadrilateral, dstWidth: Int, dstHeight: Int, padding: Int): ImageData? {
        return try {
            imageProcessor.cropAndDeskewImage(imageData, quad, dstWidth, dstHeight, padding)
        } catch (e: UtilityException) {
            null
        }
    }

    fun adjustBrightnessCalledInJsi(imageData: ImageData, brightness: Int) : ImageData {
        return imageProcessor.adjustBrightness(imageData, brightness)
    }

    fun adjustContrastCalledInJsi(imageData: ImageData, contrast: Int) : ImageData {
        return imageProcessor.adjustContrast(imageData, contrast)
    }

    fun filterImageCalledInJsi(imageData: ImageData, @EnumFilterType filterType: Int) : ImageData {
        return imageProcessor.filterImage(imageData, filterType)
    }

    fun convertToGrayCalledInJsi(imageData: ImageData, r: Float, g: Float, b: Float) : ImageData {
        return imageProcessor.convertToGray(imageData, r, g, b)
    }

    fun convertToBinaryGlobalCalledInJsi(imageData: ImageData, threshold: Int, invert: Boolean): ImageData {
        return imageProcessor.convertToBinaryGlobal(imageData, threshold, invert)
    }

    fun convertToBinaryLocalCalledInJsi(imageData: ImageData, blockSize: Int, compensation: Int, invert: Boolean): ImageData {
        return imageProcessor.convertToBinaryLocal(imageData, blockSize, compensation, invert)
    }



    private external fun nativeInstall(jsiPtr: Long)

}