dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository") }
    }
}

dependencies {
    implementation("me.didit:didit-sdk:3.5.8")
}

android {
    packaging {
        resources {
            excludes += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
        }
    }
}

import me.didit.sdk.DiditSdk

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        DiditSdk.initialize(this)
    }
}

import me.didit.sdk.DiditSdk
import me.didit.sdk.DiditSdkState
import me.didit.sdk.VerificationResult

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

        // Observe SDK state to launch UI when ready
        lifecycleScope.launch {
            DiditSdk.state.collect { state ->
                when (state) {
                    is DiditSdkState.Ready -> DiditSdk.launchVerificationUI(this@MainActivity)
                    is DiditSdkState.Error -> Log.e("Didit", "Error: ${state.message}")
                    else -> { /* Loading, Idle, CreatingSession */ }
                }
            }
        }
    }

    private fun startVerification() {
        DiditSdk.startVerification(
            token = "your-session-token"
        ) { result ->
            when (result) {
                is VerificationResult.Completed -> {
                    Log.d("Didit", "Session: ${result.session.sessionId}")
                    Log.d("Didit", "Status: ${result.session.status.rawValue}")
                }
                is VerificationResult.Cancelled -> {
                    Log.d("Didit", "User cancelled")
                }
                is VerificationResult.Failed -> {
                    Log.e("Didit", "Failed: ${result.error.message}")
                }
            }
        }
    }
}

// Your backend creates the session and returns a token
DiditSdk.startVerification(
    token = "your-session-token"
) { result ->
    handleResult(result)
}

// SDK creates the session using your workflow ID
DiditSdk.startVerification(
    workflowId = "your-workflow-id",
    vendorData = "user-123"  // Optional: your user identifier
) { result ->
    handleResult(result)
}

import me.didit.sdk.Configuration
import me.didit.sdk.core.localization.SupportedLanguage

val configuration = Configuration(
    languageLocale = SupportedLanguage.SPANISH,  // Force Spanish language
    fontFamily = "my_custom_font",                // Custom font (must be in res/font/)
    loggingEnabled = true                         // Enable debug logging
)

DiditSdk.startVerification(
    token = "your-session-token",
    configuration = configuration
) { result ->
    handleResult(result)
}

// Use device locale (default)
val config = Configuration()

// Force specific language
val config = Configuration(languageLocale = SupportedLanguage.FRENCH)

import me.didit.sdk.models.ContactDetails

val contactDetails = ContactDetails(
    email = "user@example.com",
    sendNotificationEmails = true,  // Send status update emails
    emailLang = "en",               // Email language
    phone = "+14155552671"          // E.164 format
)

DiditSdk.startVerification(
    workflowId = "your-workflow-id",
    contactDetails = contactDetails
) { result ->
    handleResult(result)
}

import me.didit.sdk.models.ExpectedDetails

val expectedDetails = ExpectedDetails(
    firstName = "John",
    lastName = "Doe",
    dateOfBirth = "1990-05-15",   // YYYY-MM-DD format
    nationality = "USA",          // ISO 3166-1 alpha-3
    country = "USA"
)

DiditSdk.startVerification(
    workflowId = "your-workflow-id",
    expectedDetails = expectedDetails
) { result ->
    handleResult(result)
}

DiditSdk.startVerification(
    workflowId = "your-workflow-id",
    vendorData = "user-123",
    metadata = "{\"internalId\": \"abc123\", \"source\": \"mobile\"}"
) { result ->
    handleResult(result)
}

DiditSdk.startVerification(token = "your-token") { result ->
    when (result) {
        is VerificationResult.Completed -> {
            when (result.session.status) {
                VerificationStatus.APPROVED -> println("Approved!")
                VerificationStatus.PENDING -> println("Under review")
                VerificationStatus.DECLINED -> println("Declined")
            }
        }
        is VerificationResult.Cancelled -> {
            println("Cancelled: ${result.session?.sessionId ?: "unknown"}")
        }
        is VerificationResult.Failed -> {
            println("Error: ${result.error.message}")
        }
    }
}