import PrismCapabilities

let bluetooth = PrismBluetoothClient()

// Check Bluetooth state
let state = await bluetooth.state
// .poweredOn, .poweredOff, .unauthorized, .unsupported, etc.

// Scan for peripherals
for await peripheral in bluetooth.scan(services: nil) {
    print("Found: \(peripheral.name ?? "Unknown")")
    print("RSSI: \(peripheral.rssi)")
    
    // Connect to a device
    try await bluetooth.connect(to: peripheral)
    break
}

let services = try await bluetooth.discoverServices(
    for: peripheral
)

for service in services {
    let characteristics = try await bluetooth.discoverCharacteristics(
        for: service
    )
    
    for char in characteristics {
        if char.isReadable {
            let data = try await bluetooth.readValue(
                for: char
            )
            print("Value: \(data)")
        }
    }
}

let nfc = PrismNFCClient()

guard nfc.isAvailable else {
    print("NFC not supported on this device")
    return
}

let tag = try await nfc.scan(message: "Hold near an NFC tag")

switch tag {
case .ndef(let records):
    for record in records {
        print("Payload: \(record.payload)")
    }
case .iso7816(let apdu):
    print("ISO 7816 tag: \(apdu)")
}

let multipeer = PrismMultipeerClient(
    serviceType: "my-app",
    displayName: "Alice's iPhone"
)

// Start advertising and browsing
try await multipeer.start()

// Discover peers
for await peer in multipeer.discoveredPeers {
    print("Found peer: \(peer.displayName)")
    try await multipeer.invite(peer)
}

// Send data to connected peers
let data = "Hello!".data(using: .utf8)!
try await multipeer.send(data, to: .all)

// Receive data
for await (data, sender) in multipeer.receivedData {
    let message = String(data: data, encoding: .utf8)!
    print("\(sender.displayName): \(message)")
}

let nearby = PrismNearbyClient()

guard nearby.isSupported else {
    print("Nearby Interaction not supported")
    return
}

for await update in nearby.peerUpdates {
    if let distance = update.distance {
        print("Distance: \(distance)m")
    }
    if let direction = update.direction {
        print("Direction: \(direction)")
    }
}

let calls = PrismCallClient()

try await calls.reportIncomingCall(
    uuid: UUID(),
    handle: "+1-555-0123",
    displayName: "John Doe",
    hasVideo: false
)

// Listen for call events
for await event in calls.callEvents {
    switch event {
    case .answered(let uuid):
        print("Call answered: \(uuid)")
    case .ended(let uuid):
        print("Call ended: \(uuid)")
    case .held(let uuid, let onHold):
        print("Call \(uuid) hold: \(onHold)")
    }
}

let motion = PrismMotionClient()

// Accelerometer stream
for await data in motion.accelerometerUpdates(interval: 0.1) {
    print("x: \(data.x), y: \(data.y), z: \(data.z)")
}

// Step counting
let steps = try await motion.pedometerData(
    from: Calendar.current.startOfDay(for: .now),
    to: .now
)
print("Steps today: \(steps.numberOfSteps)")
print("Distance: \(steps.distance ?? 0)m")

let gameCenter = PrismGameCenterClient()

// Authenticate the player
let player = try await gameCenter.authenticate()
print("Player: \(player.displayName)")

// Submit a score
try await gameCenter.submitScore(
    value: 42_000,
    leaderboardID: "high_scores"
)

// Report an achievement
try await gameCenter.reportAchievement(
    id: "first_win",
    percentComplete: 100
)