package io.oxygenhub.android.alerts

import android.content.Context

import android.security.keystore.KeyGenParameterSpec

import android.security.keystore.KeyProperties

import android.security.keystore.StrongBoxUnavailableException

import android.util.Base64

import androidx.core.content.edit

import java.security.GeneralSecurityException

import java.security.KeyStore

import javax.crypto.Cipher

import javax.crypto.KeyGenerator

import javax.crypto.SecretKey

import javax.crypto.spec.GCMParameterSpec

import uniffi.rust_core.alertNewSecret

import uniffi.rust_core.alertPublicKey

/**

 * The phone's alert key (#16): an X25519 secret, made by the Rust core,

 * that the hub seals each alert to. Kept in app-private preferences only as

 * ciphertext under an AES-GCM key in the Android Keystore (StrongBox where

 * the phone has one), as the session's token is; out of backups, since a

 * restored copy could not be opened anyway. A lost key just means a new one

 * and registering again.

 */

object AlertKey {

    private const val PREFS = "alerts"

    private const val SEALED = "secret.sealed"

    private const val KEYSTORE = "AndroidKeyStore"

    private const val ALIAS = "io.oxygenhub.android.alerts"

    private const val TRANSFORMATION = "AES/GCM/NoPadding"

    /** The secret, made and kept the first time it is asked for. */

    @Synchronized

    fun secret(context: Context): ByteArray {

        val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)

        prefs.getString(SEALED, null)?.let { sealed ->

            try {

                return open(sealed)

            } catch (_: GeneralSecurityException) {

                // The Keystore key is gone: a new secret, registered again.

            } catch (_: IllegalArgumentException) {

            }

        }

        val fresh = alertNewSecret()

        prefs.edit { putString(SEALED, seal(fresh)) }

        return fresh

    }

    /** The public key, hex, for the hub. */

    fun publicKeyHex(context: Context): String = alertPublicKey(secret(context)).joinToString("") { "%02x".format(it) }

    private fun seal(plain: ByteArray): String {

        val cipher = Cipher.getInstance(TRANSFORMATION)

        cipher.init(Cipher.ENCRYPT_MODE, key())

        return b64(cipher.iv) + ":" + b64(cipher.doFinal(plain))

    }

    private fun open(sealed: String): ByteArray {

        val parts = sealed.split(':', limit = 2)

        require(parts.size == 2) { "not a sealed secret" }

        val key = existingKey() ?: throw GeneralSecurityException("no key")

        val cipher = Cipher.getInstance(TRANSFORMATION)

        cipher.init(Cipher.DECRYPT_MODE, key, GCMParameterSpec(128, Base64.decode(parts[0], Base64.NO_WRAP)))

        return cipher.doFinal(Base64.decode(parts[1], Base64.NO_WRAP))

    }

    private fun b64(bytes: ByteArray): String = Base64.encodeToString(bytes, Base64.NO_WRAP)

    private fun existingKey(): SecretKey? {

        val ks = KeyStore.getInstance(KEYSTORE).apply { load(null) }

        return (ks.getEntry(ALIAS, null) as? KeyStore.SecretKeyEntry)?.secretKey

    }

    private fun key(): SecretKey = existingKey() ?: try {

        generate(strongBox = true)

    } catch (_: StrongBoxUnavailableException) {

        generate(strongBox = false)

    }

    private fun generate(strongBox: Boolean): SecretKey {

        val spec = KeyGenParameterSpec.Builder(ALIAS, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)

            .setBlockModes(KeyProperties.BLOCK_MODE_GCM)

            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)

            .setKeySize(256)

            .setIsStrongBoxBacked(strongBox)

            .build()

        return KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, KEYSTORE).apply { init(spec) }.generateKey()

    }

}