Models and State

data class BagIdConfig(
    val apiBaseUrl: String,
    val sourceAppKey: String,
    val tokenProvider: suspend () -> String,
    val theme: BagIdTheme? = null,
    val localization: BagIdLocalization? = null,
)

// The Kotlin `suspend () -> String` is exposed as an `async throws` closure.
let config = BagIdConfig(
    apiBaseUrl: "https://api.bagid.com",
    sourceAppKey: "your-issued-client-key",
    tokenProvider: { try await AuthBridge.federatedToken() },
    theme: nil,
    localization: nil
)

data class BagIdTheme(
    val primaryColor: String? = null,
    val backgroundColor: String? = null,
    val textColor: String? = null,
    val errorColor: String? = null,
    val fontFamily: String? = null,
    val borderRadius: Int? = null,
    val inputStyle: InputStyle? = null,
    val buttonStyle: ButtonStyle? = null,
)

enum class InputStyle { OUTLINED, FILLED, UNDERLINED }
enum class ButtonStyle { FILLED, OUTLINED, TEXT }

// Nullable Int in Kotlin is bridged as `KotlinInt?` in Swift.
let theme = BagIdTheme(
    primaryColor: "#003366",
    backgroundColor: "#FFFFFF",
    textColor: "#111111",
    errorColor: "#B00020",
    fontFamily: "System",
    borderRadius: 8,
    inputStyle: .outlined,
    buttonStyle: .filled
)

data class BagIdLocalization(
    val locale: String? = null,
    val overrides: Map<String, String>? = null,
)

let localization = BagIdLocalization(
    locale: "nb-NO",
    overrides: [
        "verification.title": "Bekreft eier"
    ]
)

sealed class InitResult {
    data object Authenticated : InitResult()
    data class Unavailable(val reason: UnavailableReason) : InitResult()
}

enum class UnavailableReason {
    TOKEN_PROVIDER_FAILED,
    FEDERATION_REJECTED,
    NETWORK_ERROR,
}

// Exhaustive matching on the sealed class via SKIE's onEnum(of:).
switch onEnum(of: result) {
case .authenticated:
    break // continue
case .unavailable(let unavailable):
    switch unavailable.reason {
    case .tokenProviderFailed: print("Token provider failed")
    case .federationRejected:  print("Federation rejected")
    case .networkError:        print("Network error")
    }
}

sealed class LoadJourneyRequest {
    data class Bcbp(val scanData: String, val airline: String? = null) : LoadJourneyRequest()
    data class AirlinePayload(
        val passengers: List<AirlinePassenger>,
    ) : LoadJourneyRequest()
}

// Construct either variant through its nested type:
let bcbpRequest: LoadJourneyRequest = LoadJourneyRequestBcbp(scanData: "M1SNOW/JON...", airline: nil)

let airlineRequest: LoadJourneyRequest = LoadJourneyRequestAirlinePayload(
    passengers: [airlinePassenger]
)

data class AirlinePassenger(
    val passenger: Passenger,
    val pnr: String,
    val surname: String,
    val flights: List<FlightInfo>,
    val baggage: List<AirlineBaggageInput>? = null,
)

let airlinePassenger = AirlinePassenger(
    passenger: Passenger(surname: "Snow", givenName: "Jon", title: "Mr"),
    pnr: "A13712",
    surname: "Snow",
    flights: [flightInfo],
    baggage: nil
)

data class Journey(
    val journeyId: Int,
    val passengers: List<Passenger>,
    val flights: List<FlightInfo>,
    val baggage: List<BaggageRecord>,
)

// `Int32` in Swift because Kotlin `Int` bridges to 32-bit.
let journeyId: Int32 = journey.journeyId
let passengers: [Passenger] = journey.passengers
let flights: [FlightInfo] = journey.flights
let baggage: [BaggageRecord] = journey.baggage

data class Passenger(
    val surname: String? = null,
    val givenName: String? = null,
    val title: String? = null,
)

let passenger = Passenger(
    surname: "Snow",
    givenName: "Jon",
    title: "Mr"
)

data class FlightInfo(
    val flightNumber: String,
    val departureAirport: String,
    val destinationAirport: String,
    val departureAt: String?,
)

let flight = FlightInfo(
    flightNumber: "WF459",
    departureAirport: "BGO",
    destinationAirport: "OSL",
    departureAt: "2023-01-21T10:00:00+01:00"
)

data class BaggageRecord(
    val baggageId: Int,
    val baggageTagNumber: String?,
    val airline: String?,
    val destinationAirport: String?,
)

let id: Int32 = baggage.baggageId
let tag: String? = baggage.baggageTagNumber
let airline: String? = baggage.airline
let destination: String? = baggage.destinationAirport

data class CreateBaggageTagRequest(
    val journeyId: Int,
    val passengerList: List<Passenger>,
)

let request = CreateBaggageTagRequest(
    journeyId: journey.journeyId,
    passengerList: [passenger]
)

data class CreateAirlineBaggageRequest(
    val journeyId: Int,
    val baggageTagNumber: String,
    val airline: String,
    val destinationAirport: String,
)

let request = CreateAirlineBaggageRequest(
    journeyId: journey.journeyId,
    baggageTagNumber: "0701913714",
    airline: "WF",
    destinationAirport: "OSL"
)

sealed class BagIdScanEvent : ScanEvent {
    data class DeviceFound(val device: DiscoveredEbtBleDevice) : BagIdScanEvent(), ScanEvent.DeviceFound
    data class ScanError(override val message: String) : BagIdScanEvent(), ScanEvent.ScanError
}

for await event in BagIdSdk.shared.scanForEbtTags() {
    switch onEnum(of: event) {
    case .deviceFound(let e):
        print("Found: \(e.device.deviceId)")
    case .scanError(let e):
        print("Scan error: \(e.message)")
    }
}

data class DiscoveredEbtBleDevice(
    val identity: EbtTagIdentity,
    val deviceId: String,
    val signalStrength: Int,
)

let id: String = device.deviceId
let rssi: Int32 = device.signalStrength
let identity: EbtTagIdentity = device.identity

sealed class EbtTagIdentity {
    data class BagId(val model: BagIdDeviceType) : EbtTagIdentity()
    data class BagIdBleV21(val model: BagIdDeviceType) : EbtTagIdentity()
    data class OtherVendor(val modelHint: String?) : EbtTagIdentity()
}

enum class BagIdDeviceType {
    BAGID_GO,
    BAGID_2FM,
    BAGID_2ST,
}

data class ConnectedEbtDevice(
    val uuid: String,
    val deviceId: String,
    val identity: EbtTagIdentity,
    val batteryLevel: Int?,
    val firmwareVersion: FirmwareVersion?,
    val serialNumber: String?,
)

data class EbtBleDeviceState(
    val connectedDevice: ConnectedEbtDevice?,
    val lastError: String?,
)

data class TransferTagRequest(
    val deviceId: String,
    val uniqueDeviceId: String,
    val baggageId: Int,
    val journeyId: Int,
    val recordLocator: String? = null,
    val custodyProofSurname: String? = null,
    val displayTicket: EbtTicket? = null,
    val journey: Journey? = null,
)

let request = TransferTagRequest(
    deviceId: selectedDevice.deviceId,
    uniqueDeviceId: connected.uuid,
    baggageId: baggage.baggageId,
    journeyId: journey.journeyId,
    recordLocator: nil,
    custodyProofSurname: nil,
    displayTicket: nil,
    journey: journey
)

data class TransferResult(
    val bleWriteSuccess: Boolean,
    val attachmentSuccess: Boolean,
    val pendingRetry: Boolean,
    val device: DeviceInfo,
)

let wrote: Bool = transfer.bleWriteSuccess
let attached: Bool = transfer.attachmentSuccess
let pending: Bool = transfer.pendingRetry
let device: DeviceInfo = transfer.device

data class ClearTagRequest(
    val deviceId: String,
    val uniqueDeviceId: String,
)

let request = ClearTagRequest(
    deviceId: selectedDevice.deviceId,
    uniqueDeviceId: connected.uuid
)

data class ClearResult(
    val success: Boolean,
    val unlocked: Boolean,
)

let success: Bool = result.success
let unlocked: Bool = result.unlocked

data class DeviceInfo(
    val deviceId: String,
    val serialNumber: String?,
    val batteryLevel: Int?,
    val firmwareVersion: String?,
)

let deviceId: String = info.deviceId
let serial: String? = info.serialNumber
let battery: Int? = info.batteryLevel.map { Int(truncating: $0) }   // KotlinInt? → Int?
let firmware: String? = info.firmwareVersion

data class BagIdState(
    val authenticated: Boolean,
    val sessionExpired: Boolean,
    val connectedDevice: DeviceInfo?,
    val lastError: String?,
    val bleLastError: String?,
    val identifiedEbtTagIdentity: EbtTagIdentity? = null,
)

// `StateFlow<BagIdState>` is bridged to `AsyncSequence` by SKIE.
for await state in BagIdSdk.shared.state {
    let authenticated: Bool = state.authenticated
    let sessionExpired: Bool = state.sessionExpired
    let device: DeviceInfo? = state.connectedDevice
    let lastError: String? = state.lastError
    let bleLastError: String? = state.bleLastError
    let tagIdentity: EbtTagIdentity? = state.identifiedEbtTagIdentity
}