MFA and Passkey Functions

suspend fun getUserDevices(): List<MfaDevice>

viewModelScope.launch {
    try {
        val devices = sdk.mfa.getUserDevices()
        devices.forEach { device ->
            println("Device: ${device.type?.name}, ID: ${device.id}")
        }
    } catch (e: Exception) {
        println("Failed to load devices: ${e.message}")
    }
}

suspend fun addDevice(type: String): MfaAddDevice

viewModelScope.launch {
    try {
        val device = sdk.mfa.addDevice("totp")
        println("Device added with secret: ${device.secret}")
        // Show QR code to user with device.secret
    } catch (e: Exception) {
        println("Failed to add device: ${e.message}")
    }
}

suspend fun verifyDevice(code: String, type: String)

viewModelScope.launch {
    try {
        sdk.mfa.verifyDevice("123456", "totp")
        println("Device verified successfully")
    } catch (e: Exception) {
        println("Failed to verify device: ${e.message}")
    }
}

suspend fun authenticateDevice(params: MfaAuthenticateDevice): String?

viewModelScope.launch {
    try {
        val token = sdk.mfa.authenticateDevice(
            MfaAuthenticateDevice(
                code = "123456",
                deviceId = deviceId,
                createMfaToken = MfaCreateToken(singleUse = true)
            )
        )
        println("MFA Token: $token")
    } catch (e: Exception) {
        println("Failed to authenticate: ${e.message}")
    }
}

suspend fun deleteUserDevice(deviceId: String, mfaAuthToken: String)

viewModelScope.launch {
    try {
        // First authenticate to get token
        val token = sdk.mfa.authenticateDevice(
            MfaAuthenticateDevice(
                code = "123456",
                deviceId = deviceId,
                createMfaToken = MfaCreateToken(singleUse = true)
            )
        )

        // Then delete the device
        if (!token.isNullOrEmpty()) {
            sdk.mfa.deleteUserDevice(deviceId, token)
            println("Device deleted")
        }
    } catch (e: Exception) {
        println("Failed to delete device: ${e.message}")
    }
}

suspend fun getRecoveryCodes(generateNewCodes: Boolean = false): List<String>

viewModelScope.launch {
    try {
        // Get existing codes
        val codes = sdk.mfa.getRecoveryCodes(generateNewCodes = false)
        println("Recovery codes: $codes")

        // Or generate new codes
        val newCodes = sdk.mfa.getRecoveryCodes(generateNewCodes = true)
        println("New recovery codes: $newCodes")
    } catch (e: Exception) {
        println("Failed to get codes: ${e.message}")
    }
}

suspend fun acknowledgeRecoveryCodes()

viewModelScope.launch {
    try {
        sdk.mfa.acknowledgeRecoveryCodes()
    } catch (e: Exception) {
        println("Failed to acknowledge: ${e.message}")
    }
}

suspend fun authenticateRecoveryCode(code: String)

viewModelScope.launch {
    try {
        sdk.mfa.authenticateRecoveryCode("recovery-code")
        println("Authenticated with recovery code")
    } catch (e: Exception) {
        println("Invalid recovery code: ${e.message}")
    }
}

suspend fun getPasskeys(): List<UserPasskey>

viewModelScope.launch {
    try {
        val passkeys = sdk.passkeys.getPasskeys()
        passkeys.forEach { passkey ->
            println("ID: ${passkey.id}")
            println("Created: ${passkey.createdAt}")
            println("Last used: ${passkey.lastUsedAt}")
            println("Is default: ${passkey.isDefault}")
        }
    } catch (e: Exception) {
        println("Failed to load passkeys: ${e.message}")
    }
}

suspend fun registerPasskey()

viewModelScope.launch {
    try {
        sdk.passkeys.registerPasskey()
        println("Passkey registered successfully")
    } catch (e: Exception) {
        println("Failed to register: ${e.message}")
    }
}

suspend fun authenticatePasskeyMFA(
    createMfaToken: MfaCreateToken,
    relatedOriginRpId: String?
): PasskeyAuthenticationResponse

viewModelScope.launch {
    try {
        val response = sdk.passkeys.authenticatePasskeyMFA(
            createMfaToken = MfaCreateToken(singleUse = true),
            relatedOriginRpId = null
        )
        println("MFA Token: ${response.jwt}")
    } catch (e: Exception) {
        println("Failed to authenticate: ${e.message}")
    }
}

suspend fun deletePasskey(request: DeletePasskeyRequest)

viewModelScope.launch {
    try {
        sdk.passkeys.deletePasskey(
            DeletePasskeyRequest(passkeyId = passkeyId)
        )
        println("Passkey deleted")
    } catch (e: Exception) {
        println("Failed to delete: ${e.message}")
    }
}

data class MfaDevice(
    val id: String?,
    val type: MfaDeviceType?
)

enum class MfaDeviceType {
    totp
}

data class MfaAuthenticateDevice(
    val code: String,
    val deviceId: String,
    val createMfaToken: MfaCreateToken
)

data class MfaCreateToken(
    val singleUse: Boolean
)

data class UserPasskey(
    val id: String,
    val createdAt: String,
    val lastUsedAt: String?,
    val isDefault: Boolean?
)

data class DeletePasskeyRequest(
    val passkeyId: String
)

data class PasskeyAuthenticationResponse(
    val jwt: String?
)