package io.getvouch.rn

import android.app.Activity
import android.content.Context
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.lifecycle.lifecycleScope
import com.vlayer.vouch.sdk.NotarizationRequestSdkResult
import com.vlayer.vouch.sdk.ProveConfig
import com.vlayer.vouch.sdk.VouchSdk
import kotlinx.coroutines.launch

class VouchActivity : ComponentActivity() {
    private lateinit var vouchSdk: VouchSdk

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val customerId = intent.getStringExtra(EXTRA_CUSTOMER_ID)
        val apiKey = intent.getStringExtra(EXTRA_API_KEY)
        val datasourceId = intent.getStringExtra(EXTRA_DATASOURCE_ID)
        val webhookUrl = intent.getStringExtra(EXTRA_WEBHOOK_URL)
        val languageCodeOverride = intent.getStringExtra(EXTRA_LANGUAGE_CODE_OVERRIDE)
        val inputs = intent.getSerializableExtra(EXTRA_INPUTS) as? HashMap<String, String>
        val metadata = intent.getStringExtra(EXTRA_METADATA)

        if (customerId == null || apiKey == null || datasourceId == null || webhookUrl == null) {
            setResult(
                Activity.RESULT_CANCELED,
                Intent().apply {
                    putExtra(EXTRA_ERROR_MESSAGE, "Missing required parameters")
                },
            )
            finish()
            return
        }

        vouchSdk =
            VouchSdk(
                activityResultCaller = this,
                customerId = customerId,
                apiKey = apiKey,
                languageCode = languageCodeOverride,
            )

        lifecycleScope.launch {
            try {
                vouchSdk.initialize(context = this@VouchActivity)
                vouchSdk.prove(
                    context = this@VouchActivity,
                    proveConfig =
                        ProveConfig(
                            datasourceId = datasourceId,
                            webhookUrl = webhookUrl,
                            inputs = inputs,
                            metadata,
                        ),
                    callback = { result ->
                        handleResult(result)
                    },
                )
            } catch (error: Exception) {
                setResult(
                    Activity.RESULT_CANCELED,
                    Intent().apply {
                        putExtra(EXTRA_ERROR_MESSAGE, error.message ?: "Failed to initialize Vouch SDK")
                    },
                )
                finish()
            }
        }
    }

    private fun handleResult(result: NotarizationRequestSdkResult) {
        val resultIntent = Intent()

        when (result) {
            is NotarizationRequestSdkResult.Success -> {
                resultIntent.putExtra(EXTRA_REQUEST_ID, result.requestId.toString())
                setResult(RESULT_SUCCESS, resultIntent)
            }

            is NotarizationRequestSdkResult.Failure -> {
                resultIntent.putExtra(EXTRA_REQUEST_ID, result.requestId?.toString() ?: "")
                resultIntent.putExtra(EXTRA_ERROR_MESSAGE, result.message ?: "Unknown error")
                setResult(RESULT_FAILURE, resultIntent)
            }

            is NotarizationRequestSdkResult.Canceled -> {
                resultIntent.putExtra(EXTRA_REQUEST_ID, result.requestId?.toString() ?: "")
                setResult(RESULT_CANCELED, resultIntent)
            }
        }

        finish()
    }

    companion object {
        const val EXTRA_CUSTOMER_ID = "customer_id"
        const val EXTRA_API_KEY = "api_key"
        const val EXTRA_DATASOURCE_ID = "datasource_id"
        const val EXTRA_WEBHOOK_URL = "webhook_url"
        const val EXTRA_LANGUAGE_CODE_OVERRIDE = "language_code_override"
        const val EXTRA_INPUTS = "inputs"
        const val EXTRA_METADATA = "metadata"
        const val EXTRA_REQUEST_ID = "request_id"
        const val EXTRA_ERROR_MESSAGE = "error_message"

        const val RESULT_SUCCESS = 1
        const val RESULT_FAILURE = 2
        const val RESULT_CANCELED = 3

        fun createIntent(
            context: Context,
            customerId: String,
            apiKey: String,
            languageCodeOverride: String?,
            datasourceId: String,
            webhookUrl: String,
            metadata: String?,
            inputs: Map<String, String>?,
        ): Intent =
            Intent(context, VouchActivity::class.java).apply {
                putExtra(EXTRA_CUSTOMER_ID, customerId)
                putExtra(EXTRA_API_KEY, apiKey)
                putExtra(EXTRA_LANGUAGE_CODE_OVERRIDE, languageCodeOverride)
                putExtra(EXTRA_DATASOURCE_ID, datasourceId)
                putExtra(EXTRA_WEBHOOK_URL, webhookUrl)
                putExtra(EXTRA_METADATA, metadata)
                inputs?.let { putExtra(EXTRA_INPUTS, HashMap(it)) }
            }
    }
}