package idsdk

import android.graphics.Bitmap
import android.util.Base64
import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.flowWithLifecycle
import androidx.lifecycle.lifecycleScope
import com.getcapacitor.Bridge
import com.getcapacitor.JSObject
import com.getcapacitor.PluginCall
import com.getcapacitor.plugin.luna.idsdk.BuildConfig
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.*
import ru.visionlabs.sdk.lunacore.*
import ru.visionlabs.sdk.lunacore.liveness.LivenessType
import java.io.ByteArrayOutputStream

class LunaSDK(private val bridge: Bridge) {
    private var initializing: Boolean = false
    private var initialized: Boolean = false
    private val TAG = BuildConfig.PLUGIN_NAME

    fun initialize(call: PluginCall) {
        val ret = JSObject()

        if (initializing) {
            ret.put("initializing", true)
            call.resolve(ret)
            println("IS INITIALIZING")
            return
        }

        if (initialized) {
            ret.put("initialized", true)
            call.resolve(ret)
            println("IS ALREADY INITIALIZED")
            return
        }
        initializing = true

        Settings.lunaConfig = LunaConfig.create(
            acceptOccludedFaces = true,
            acceptMask = false,
            acceptOneEyed = true,
            usePrimaryFaceTracking = false,
            acceptEyesClosed = false,
            useDescriptors = false,
            livenessType = LivenessType.None
        )

        try {
            LunaID.initEngine(
                app = bridge.activity.application,
                lunaConfig = Settings.lunaConfig
            )
        } catch (e: Error) {
            initializing = false
            initialized = false
            e.printStackTrace()
            ret.put("initialized", initialized)
            call.resolve(ret)
            return
        }

        LunaID.engineInitStatus
            .flowWithLifecycle(bridge.activity.lifecycle, Lifecycle.State.STARTED)
            .onEach {
                when (it) {
                    is LunaID.EngineInitStatus.InProgress -> {
                        initializing = true
                        Log.d(TAG, "EngineInitStatus - Engine init in progress")
                    }

                    is LunaID.EngineInitStatus.Success -> {
                        Log.d(TAG, "EngineInitStatus - Engine initialized successfully")
                        initializing = false
                        initialized = true
                        ret.put("initialized", initialized)
                        call.resolve(ret)
                    }

                    is LunaID.EngineInitStatus.Failure -> {
                        Log.e(TAG, it.cause?.message ?: "EngineInitStatus - Unknown error")
                        Log.e(TAG, it.cause?.stackTraceToString() ?: "EngineInitStatus - No stackTrace")
                        bridge.activity.finish()
                        initializing = false
                        initialized = false
                        ret.put("initialized", initialized)
                        call.resolve(ret)
                    }

                    is LunaID.EngineInitStatus.NotInitialized ->{
                        Log.e(TAG, it.toString())
                        initializing = false
                        initialized = false
                        ret.put("initialized", initialized)
                        call.resolve(ret)
                    }

                    else -> {
                        initializing = false
                        initialized = false
                    }
                }
            }
            .flowOn(Dispatchers.Main)
            .launchIn(bridge.activity.lifecycleScope)
    }

    fun start(call: PluginCall) {
        if (!initialized) {
            call.reject("Configurations not initialized. call initialize() first", "NOT_INITIALIZED")
            return
        }

        val disableErrors = call.getBoolean("disableErrors", false) ?: Settings.disableErrors
        val ignoreVideoWithoutFace = call.getBoolean("ignoreVideoWithoutFace", false) ?: false
        val recordVideo = call.getBoolean("recordVideo", false) ?: false
        val recordingTimeMillis = call.getLong("recordingTimeMillis", 6000) ?: 6000

        val params = ShowCameraParams(
            disableErrors = disableErrors,
            ignoreVideoWithoutFace = ignoreVideoWithoutFace,
            recordVideo = recordVideo,
            recordingTimeMillis = recordingTimeMillis,
            checkSecurity = true
        )

        val otherInteractions = listOf(
            YawLeftInteraction(timeoutMs = 15000, startAngleDeg = 15, endAngleDeg = 20),
            YawRightInteraction(timeoutMs = 15000, startAngleDeg = 15, endAngleDeg = 20),
        )

        val randomInteraction = otherInteractions.random()


        val interactions = Interactions.Builder()
            .addInteraction(BlinkInteraction(timeoutMs = 15000, acceptOneEyed = true))
            .addInteraction(randomInteraction)
            .build()

        LunaID.showCamera(
            context = bridge.activity,
            params = params,
            interactions = interactions,
        )

        LunaID.bestShot
            .filterNotNull()
            .onEach {
                Log.d(TAG, "bestShot: ${it.bestShot}")
                val byteArrayOutputStream = ByteArrayOutputStream()
                it.bestShot.image.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream)
                val byteArray: ByteArray = byteArrayOutputStream.toByteArray()
                val base64Img = Base64.encodeToString(byteArray, Base64.DEFAULT)
                val ret = JSObject()
                ret.put("base64String", base64Img)
                Log.w(TAG, it.videoPath.toString())
                ret.put("videoPath", it.videoPath)
                call.resolve(ret)
            }.flowOn(Dispatchers.Main)
            .launchIn(bridge.activity.lifecycleScope)

    }
}