data class CardEntity(
    val receivedCard: ReceivedCard,
    val cardArt: String?,
    val isReceiver: Boolean = false,
    val transactionHistory: List<Transaction>?,
    val transactionCurrency: String?,
    val transactionHasNext: Boolean?,
    val transactionNextPageStartingAfter: String?,
    val events: List<CardEvent>?,
    val assetType: AssetType?,
    val metadata: CardMetadata?
)

// Fetch cards
val cards: List<CardEntity> = sdk.getCards()

// Access card details
val card = cards.first()
val label = card.receivedCard.cardLabel
val balance = card.receivedCard.balance
val last4 = card.receivedCard.last4

data class ReceivedCard(
    val giftCardId: String,
    val expiryDate: String,
    val cardArtId: String,
    val balance: Double?,
    val name: String?,
    val lastName: String?,
    val last4: String?,
    val message: CardMessage?,
    val status: ActivationStatus?,
    val cardLabel: String?
)

val receivedCard = cardEntity.receivedCard

// Display card label
val displayName = receivedCard.cardLabel ?: receivedCard.giftCardId

// Format masked PAN
val maskedPan = receivedCard.last4?.let { "•••• $it" } ?: "N/A"

// Format balance
val formattedBalance = receivedCard.balance?.let { 
    "${sdk.styleConfiguration.currencySymbol}%.2f".format(it)
} ?: "N/A"

data class Transaction(
    val transactionType: String,          // e.g. "LOAD", "DEDUCTION", "AUTHORISATION"
    val transactionTypeDetail: String?,   // Sub-type detail or MCC code
    val transactionDate: String,          // ISO date-time string
    val transactionAmount: Double,        // Absolute transaction amount
    val transactionId: String,            // Unique transaction ID
    val transactionDescription: String?  // Optional description / merchant name
)

// Fetch transactions
val result = sdk.getTransactionHistory(
    card = card,
    periodStart = "2026-01-01T00:00:00",
    periodEnd   = "2026-01-31T23:59:59"
)
val transactions = result.transactionHistory ?: emptyList()

// Display transaction
transactions.forEach { txn ->
    val label = txn.transactionDescription ?: txn.transactionType
    println("${txn.transactionAmount} on ${txn.transactionDate}: $label")
}

// Filter by type
val loads = transactions.filter { it.transactionType == "LOAD" }
val deductions = transactions.filter { it.transactionType == "DEDUCTION" }

data class CardEvent(
    val eventTime: String,
    val eventType: CardEventType,
    val initialBalance: Double
)

enum class CardEventType {
    Purchased,
    FundsLoaded,
    Sent,
    Activated,
    Declined,
    Expired
}

// Fetch events
val cardWithEvents = sdk.getEventHistory(card)
val events = cardWithEvents.events ?: emptyList()

// Display recent events
events.take(5).forEach { event ->
    println("${event.eventType} at ${event.eventTime}: balance=${event.initialBalance}")
}

// Filter by type
val fundsLoaded = events.filter { it.eventType == CardEventType.FundsLoaded }
val activations = events.filter { it.eventType == CardEventType.Activated }

data class CardMessage(
    val receiver: String?,
    val text: String?
)

val message = cardEntity.receivedCard.message
if (message != null) {
    println("To: ${message.receiver ?: "You"}")
    println(message.text ?: "")
}

enum class ActivationStatus {
    Sent,
    Activated,
    Declined,
    Expired,
    InActivation,
    NotActivated,
    Rejected,
    InProgress,
    Failed,
    Blocked
}

val status = cardEntity.receivedCard.status

when (status) {
    ActivationStatus.Activated  -> showCard()
    ActivationStatus.Blocked    -> showLockedState()
    ActivationStatus.Expired    -> showExpiredMessage()
    ActivationStatus.Declined,
    ActivationStatus.Rejected,
    ActivationStatus.Failed     -> showErrorState()
    else                        -> showPendingState()
}

enum class AssetType {
    GIFT_CARD,
    PREPAID_CARD,
    DEBIT_CARD,
    CREDIT_CARD,
    VIRTUAL_CARD,
    OTHER
}

data class CardMetadata(
    val properties: Map<String, String>
)

val metadata = cardEntity.metadata
val customField = metadata?.properties?.get("customField")

data class CardListItemUi(
    val label: String,          // Card display name or ID
    val number: String,         // Masked PAN, e.g. "•••• 1234"
    val balance: String,        // Formatted balance string
    val imageBase64: String?,   // Base64-encoded card artwork
    val entity: CardEntity      // Underlying model — pass to details/transactions
)

typealias CardListItem = CardListItemUi

data class CardOverviewProperties(
    val cardInfo: CardInfo = CardInfo.Brief,
    val actionButton: Boolean = true,
    val cardStatus: CardStatus = CardStatus.Default,
    val cardWidgetStyle: CardWidgetStyle = CardWidgetStyle.Large,
    val slider: Boolean = false,
    val currencySymbol: String? = null
)

enum class CardInfo {
    Brief,   // Balance only
    Detail   // Balance + masked PAN + expiry
}

enum class CardStatus {
    Default,  // Normal state
    Details,  // Secure fields visible
    Locked    // Card locked state
}

enum class CardWidgetStyle {
    Default,  // Compact
    Large     // Full-width
}

data class TransactionsCardProperties(
    val title: Boolean = true  // Show the "Transactions" section header
)

import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class CardActivity : ComponentActivity() {
    private lateinit var sdk: DigitalCardEngineSDK

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

        sdk = (application as MyApp).sdk

        lifecycleScope.launch {
            try {
                // Fetch all cards
                val cards = sdk.getCards()
                val card = cards.firstOrNull() ?: return@launch

                // Access card properties
                val receivedCard = card.receivedCard
                println("Card: ${receivedCard.cardLabel}")
                println("Balance: ${receivedCard.balance}")
                println("Last 4: ${receivedCard.last4}")
                println("Status: ${receivedCard.status}")

                // Fetch transactions (requires periodStart / periodEnd)
                val result = sdk.getTransactionHistory(
                    card = card,
                    periodStart = "2026-01-01T00:00:00",
                    periodEnd   = "2026-01-31T23:59:59"
                )
                result.transactionHistory?.forEach { txn ->
                    println("${txn.transactionType}: ${txn.transactionAmount} on ${txn.transactionDate}")
                }

                // Fetch events
                val cardWithEvents = sdk.getEventHistory(card)
                cardWithEvents.events?.forEach { event ->
                    println("${event.eventType} at ${event.eventTime}: balance=${event.initialBalance}")
                }

            } catch (e: Exception) {
                Log.e("CardActivity", "Error: ${e.message}")
            }
        }
    }
}

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

fun formatTransactionDate(isoDateTime: String): String {
    val dt = LocalDateTime.parse(isoDateTime)
    val formatter = DateTimeFormatter.ofPattern("MMM dd, yyyy HH:mm")
    return dt.format(formatter)
}

// Usage
val displayDate = formatTransactionDate(transaction.transactionDate)

import java.text.NumberFormat
import java.util.Locale

fun formatAmount(amount: Double, currencySymbol: String?): String {
    val formatted = NumberFormat.getInstance(Locale.US).format(amount)
    return "${currencySymbol ?: ""}$formatted"
}

// Usage
val displayAmount = formatAmount(
    transaction.transactionAmount,
    sdk.styleConfiguration.currencySymbol
)