dependencyResolutionManagement {
    repositories {
        maven { url '/path/to/aar_distribution' }  // local path or hosted URL
        google()
        mavenCentral()
    }
}

dependencies {
    releaseImplementation 'com.example.wink_identity:flutter_release:1.0'
    implementation 'com.wink:wink-identity-android:2.1.1'
}

import com.wink.identity.*

WinkSDKAdapter.configure(applicationContext, WinkConfiguration(
    keyId = "your_key_id",
    merchantId = "your_merchant_id",
    environment = "prod"  // "dev", "staging", or "prod"
))

WinkSDKAdapter.configure(applicationContext, WinkConfiguration(
    keyId = "your_key_id",
    merchantId = "your_merchant_id",

    // Biometric / Face
    livenessEnabled = true,
    faceConfidenceThreshold = 90,
    mfaOrder = listOf("face", "voice"),
    retriesAllowed = 3,

    // Palm
    enablePalm = true,
    allowPalmFlip = false,
    palmCameraDir = 1,
    mfaGestureLiveness = false,
    enrollGestureLiveness = false,

    // OAuth / SSO
    auth0Domain = "your-tenant.auth0.com",
    auth0ClientId = "your_client_id",
    auth0MtmClientId = "your_mtm_client_id",
    auth0MtmClientSecret = "your_mtm_client_secret",
    oktaClientId = "your_okta_client_id",
    allowAppleLogin = true,
    allowGoogleLogin = true,
    allowPazeLogin = false,
    iamFirst = true,
    iamFirstProvider = "auth0",

    // Features
    allowIdScan = true,
    enableVoice = true,
    enableDocumentVerification = true,

    // Environment
    environment = "prod",

    // Signing key (from Android raw resource)
    signingKeyRawResourceId = R.raw.wink_private_key,

    // Engine pre-warming (default: true)
    autoPreWarm = true
))

interface WinkAuthProvider {
    fun performBrowserSignIn(completion: (WinkAuthResult) -> Unit)
    fun revokeCurrentToken(completion: (Boolean) -> Unit)
}

class MyOktaProvider : WinkAuthProvider {
    override fun performBrowserSignIn(completion: (WinkAuthResult) -> Unit) {
        // Launch Okta sign-in (e.g. via Okta OIDC SDK), then:
        completion(WinkAuthResult(
            idToken = idToken,
            givenName = user.givenName,
            familyName = user.familyName,
            email = user.email,
            userId = user.sub
        ))
    }

    override fun revokeCurrentToken(completion: (Boolean) -> Unit) {
        // Revoke stored token. Best-effort.
        completion(true)
    }
}

// After configure():
WinkSDKAdapter.authProvider = MyOktaProvider()

WinkSDKAdapter.configure(applicationContext, WinkConfiguration(
    keyId = "your_key_id",
    merchantId = "your_merchant_id",
    oktaClientId = "your_okta_client_id",     // enables native Okta
    mfaOrder = listOf("Palm", "Voice", "Okta"), // include Okta in MFA chain
    iamFirst = true,                           // optional: show Okta login before biometrics
    iamFirstProvider = "okta",                 // required when iamFirst is true
    environment = "prod",
    signingKeyRawResourceId = R.raw.wink_private_key
))

WinkSDKAdapter.configure(applicationContext, WinkConfiguration(
    keyId = "your_key_id",
    merchantId = "your_merchant_id",
    signingKeyRawResourceId = R.raw.wink_private_key  // res/raw/wink_private_key.pem
))

// Import from a PEM string directly
WinkKeystoreSigner.shared.importPrivateKey(pemString)

// Or import from a raw resource
WinkKeystoreSigner.shared.importPrivateKeyFromResource(context, R.raw.wink_private_key)

// Check if a signing key is present
if (WinkKeystoreSigner.shared.hasSigningKey) {
    println("Signing key is ready")
}

// Remove the signing key (e.g. on logout)
WinkKeystoreSigner.shared.clearSigningKey()

val request = WinkEnrollRequest(
    requiredEnrollment = "face",   // "face", "voice", or "palm"
    firstName = "Jane",
    lastName = "Doe",
    email = "[email protected]"
)

WinkSDKAdapter.enroll(activity = this, request = request) { result ->
    if (result.isSuccess) {
        println("Enrolled! Token: ${result.winkToken}")
    } else {
        println("Enrollment failed: ${result.message}")
    }
}

WinkSDKAdapter.authenticate(activity = this) { result ->
    if (result.isSuccess) {
        println("Authenticated: ${result.winkToken}")
        println("Access Token: ${result.accessToken}")
    }
}

WinkSDKAdapter.verify(
    activity = this,
    winkTokenComp = "existing_wink_token",
    documentCheck = true
) { result ->
    if (result.isSuccess) {
        println("Verification passed")
    }
}

WinkSDKAdapter.profile(
    activity = this,
    accessToken = "user_access_token",
    displayMode = "combined"  // "profile", "wallet", or "combined"
) { result ->
    println("Profile closed")
}

WinkSDKAdapter.launch(
    activity = this,
    mode = WinkLaunchMode.COMBINED,  // ACCOUNT, WALLET, or COMBINED
    accessToken = "user_access_token"
) { result ->
    println("Launch complete")
}

val walletConfig = WinkWalletConfig(
    accessToken = "user_access_token",
    merchantId = "merchant_xyz",
    extra = mapOf("customField" to "value")  // additional fields forwarded to Flutter
)

WinkSDKAdapter.start(activity = this, config = walletConfig) { result ->
    if (result.isSuccess) {
        println("Payment status: ${result.status}")
        println("Transaction ID: ${result.transactionId}")
    }
}

WinkSDKAdapter.openWallet(
    activity = this,
    accessToken = "user_access_token",
    merchantId = "merchant_xyz"
) { result ->
    println("Wallet closed: ${result.status}")
}

// Authenticate
val result = WinkSDKAdapter.authenticateAsync(activity = this)

// Enroll
val enrollResult = WinkSDKAdapter.enrollAsync(
    activity = this,
    request = WinkEnrollRequest(requiredEnrollment = "face")
)

// Profile
val profileResult = WinkSDKAdapter.profileAsync(
    activity = this,
    accessToken = "token"
)

// Launch
val launchResult = WinkSDKAdapter.launchAsync(
    activity = this,
    mode = WinkLaunchMode.COMBINED,
    accessToken = "token"
)

// Open Wallet
val walletResult = WinkSDKAdapter.openWalletAsync(
    activity = this,
    accessToken = "token"
)

import com.wink.identity.compose.*

@Composable
fun LoginScreen() {
    var showAuth by remember { mutableStateOf(false) }
    var token by remember { mutableStateOf<String?>(null) }

    Button(onClick = { showAuth = true }) {
        Text("Sign In")
    }

    WinkAuthenticate(
        isPresented = showAuth,
        onResult = { result -> token = result.winkToken },
        onDismiss = { showAuth = false }
    )
}

var showEnroll by remember { mutableStateOf(false) }

Button(onClick = { showEnroll = true }) {
    Text("Enroll")
}

WinkEnroll(
    isPresented = showEnroll,
    request = WinkEnrollRequest(requiredEnrollment = "face"),
    onResult = { result -> println(result.winkToken ?: "cancelled") },
    onDismiss = { showEnroll = false }
)

var showProfile by remember { mutableStateOf(false) }

Button(onClick = { showProfile = true }) {
    Text("My Account")
}

WinkLaunch(
    isPresented = showProfile,
    mode = WinkLaunchMode.COMBINED,
    accessToken = accessToken,
    onResult = { result -> /* handle result */ },
    onDismiss = { showProfile = false }
)

var showVerify by remember { mutableStateOf(false) }

Button(onClick = { showVerify = true }) {
    Text("Verify Identity")
}

WinkVerify(
    isPresented = showVerify,
    winkTokenComp = winkToken,
    documentCheck = true,
    onResult = { result -> /* handle result */ },
    onDismiss = { showVerify = false }
)

var showPayment by remember { mutableStateOf(false) }

Button(onClick = { showPayment = true }) {
    Text("Pay")
}

WinkPayment(
    isPresented = showPayment,
    config = WinkWalletConfig(accessToken = accessToken),
    onResult = { result -> println(result.status ?: "") },
    onDismiss = { showPayment = false }
)

var showWallet by remember { mutableStateOf(false) }

Button(onClick = { showWallet = true }) {
    Text("Wallet")
}

WinkWallet(
    isPresented = showWallet,
    accessToken = accessToken,
    merchantId = "merchant_xyz",
    onResult = { result -> /* handle result */ },
    onDismiss = { showWallet = false }
)

WinkSDKAdapter.updateTokens(
    accessToken = newAccessToken,
    refreshToken = newRefreshToken
)

WinkSDKAdapter.onTokenRefreshRequested = {
    // Refresh your token (e.g. via your token manager)
    val newToken = TokenManager.refreshAccessToken()
    WinkSDKAdapter.updateTokens(accessToken = newToken, refreshToken = newRefresh)
}

// Pre-warm ahead of time (e.g. on the screen with a "Sign In" button)
WinkSDKAdapter.preWarmEngine(applicationContext)

// Tear down on memory pressure
override fun onTrimMemory(level: Int) {
    super.onTrimMemory(level)
    if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW) {
        WinkSDKAdapter.tearDownPreWarmedEngine()
    }
}

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.wink.identity.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 1. Configure the SDK
        WinkSDKAdapter.configure(applicationContext, WinkConfiguration(
            keyId = "your_key_id",
            merchantId = "your_merchant_id",
            signingKeyRawResourceId = R.raw.wink_private_key,
            environment = "prod"
        ))

        // 2. Set up token refresh callback
        WinkSDKAdapter.onTokenRefreshRequested = {
            // Your token refresh logic here
        }

        findViewById<Button>(R.id.signInButton).setOnClickListener {
            signIn()
        }
    }

    private fun signIn() {
        // 3. Authenticate
        WinkSDKAdapter.authenticate(activity = this) { result ->
            if (!result.isSuccess) {
                println("Auth failed: ${result.message}")
                return@authenticate
            }
            println("Welcome, ${result.firstName}!")
            println("Token: ${result.winkToken}")

            // 4. Open wallet after login
            val accessToken = result.accessToken ?: return@authenticate
            WinkSDKAdapter.openWallet(
                activity = this,
                accessToken = accessToken
            ) { paymentResult ->
                println("Wallet closed: ${paymentResult.status}")
            }
        }
    }
}

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import com.wink.identity.*
import com.wink.identity.compose.*

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

        WinkSDKAdapter.configure(applicationContext, WinkConfiguration(
            keyId = "your_key_id",
            merchantId = "your_merchant_id",
            signingKeyRawResourceId = R.raw.wink_private_key,
            environment = "prod"
        ))

        WinkSDKAdapter.onTokenRefreshRequested = {
            // Your token refresh logic here
        }

        setContent {
            MaterialTheme {
                MainScreen()
            }
        }
    }
}

@Composable
fun MainScreen() {
    var showAuth by remember { mutableStateOf(false) }
    var showWallet by remember { mutableStateOf(false) }
    var accessToken by remember { mutableStateOf<String?>(null) }

    Column(
        modifier = Modifier.fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Button(onClick = { showAuth = true }) {
            Text("Sign In")
        }

        WinkAuthenticate(
            isPresented = showAuth,
            onResult = { result ->
                if (result.isSuccess) {
                    accessToken = result.accessToken
                }
            },
            onDismiss = { showAuth = false }
        )

        accessToken?.let { token ->
            Spacer(modifier = Modifier.height(16.dp))

            Button(onClick = { showWallet = true }) {
                Text("Open Wallet")
            }

            WinkWallet(
                isPresented = showWallet,
                accessToken = token,
                onResult = { result ->
                    println("Wallet: ${result.status}")
                },
                onDismiss = { showWallet = false }
            )
        }
    }
}