package io.oxygenhub.android.secondfactor

import android.content.Context

import android.hardware.biometrics.BiometricManager.Authenticators

import android.hardware.biometrics.BiometricPrompt

import android.os.CancellationSignal

import android.security.keystore.KeyGenParameterSpec

import android.security.keystore.KeyProperties

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.suspendCancellableCoroutine

import java.security.KeyPairGenerator

import java.security.KeyStore

import java.security.PrivateKey

import java.security.Signature

import java.security.spec.ECGenParameterSpec

import kotlin.coroutines.resume

/** What the phone signs to answer an approval: the hub checks the same bytes (oxygenhub#356). */

object ApprovalMessage {

    fun of(id: String, number: Long, approve: Boolean): ByteArray =

        "oxygenhub approval v1\n$id\n$number\n${if (approve) "approve" else "deny"}".toByteArray()

}

fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }

/**

 * This phone's second-factor key (#32): a P-256 key made in the Android

 * Keystore that never leaves it and signs only after a fingerprint, face

 * or the device PIN, each time.

 */

object PhoneKey {

    private const val ALIAS = "oxygenhub-second-factor"

    private fun store(): KeyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }

    fun exists(): Boolean = runCatching { store().containsAlias(ALIAS) }.getOrDefault(false)

    /** Whether this phone holds its key: the app looks for approvals only then. */

    private val _present = MutableStateFlow(false)

    val present: StateFlow<Boolean> = _present.asStateFlow()

    fun refresh() {

        _present.value = exists()

    }

    /** A new key, replacing any before it: its SubjectPublicKeyInfo, in hex, for the hub. */

    fun create(): String {

        val ks = store()

        if (ks.containsAlias(ALIAS)) ks.deleteEntry(ALIAS)

        val gen = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore")

        gen.initialize(

            KeyGenParameterSpec.Builder(ALIAS, KeyProperties.PURPOSE_SIGN)

                .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))

                .setDigests(KeyProperties.DIGEST_SHA256)

                .setUserAuthenticationRequired(true)

                // Every use asks: a fingerprint or face, or the device PIN.

                .setUserAuthenticationParameters(0, KeyProperties.AUTH_BIOMETRIC_STRONG or KeyProperties.AUTH_DEVICE_CREDENTIAL)

                // The PIN opens it anyway, so a new fingerprint need not end it.

                .setInvalidatedByBiometricEnrollment(false)

                .build(),

        )

        return gen.generateKeyPair().public.encoded.toHex().also { _present.value = true }

    }

    fun delete() {

        runCatching { store().deleteEntry(ALIAS) }

        _present.value = false

    }

    /** A signature ready to be opened by the prompt; null when the key is gone or no longer usable. */

    fun signature(): Signature? = runCatching {

        val key = store().getKey(ALIAS, null) as? PrivateKey ?: return null

        Signature.getInstance("SHA256withECDSA").apply { initSign(key) }

    }.getOrNull()

    /**

     * Sign [message] after the system's prompt: null when the person

     * cancels, the prompt fails, or the key is gone (the lock screen was

     * removed, say).

     */

    suspend fun sign(context: Context, title: String, subtitle: String, message: ByteArray): ByteArray? {

        val sig = signature() ?: return null

        return suspendCancellableCoroutine { cont ->

            val cancel = CancellationSignal()

            cont.invokeOnCancellation { cancel.cancel() }

            val prompt = BiometricPrompt.Builder(context)

                .setTitle(title)

                .setSubtitle(subtitle)

                .setAllowedAuthenticators(Authenticators.BIOMETRIC_STRONG or Authenticators.DEVICE_CREDENTIAL)

                .build()

            prompt.authenticate(

                BiometricPrompt.CryptoObject(sig),

                cancel,

                context.mainExecutor,

                object : BiometricPrompt.AuthenticationCallback() {

                    override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {

                        val signed = runCatching {

                            val s = result.cryptoObject.signature ?: sig

                            s.update(message)

                            s.sign()

                        }.getOrNull()

                        if (cont.isActive) cont.resume(signed)

                    }

                    override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {

                        if (cont.isActive) cont.resume(null)

                    }

                },

            )

        }

    }

}