/// Scan for Bluetooth `CardReader` devices. Automatically scans for 5 seconds, returning the devices it finds in real time.
          /// - Returns: `AsyncThrowingStream` of all readers as they are discovered.
          /// - Throws: `CloverError` and closes the stream if it encounters an issue. The stream closes when the scan completes.
    public func scan() -> AsyncThrowingStream<CardReader, Error>
          /// Get all previously connected card readers
          /// - Returns: async single array of `CardReader` objects containing any previously connected reader.
    public func getPreviousConnectedReaders() async throws -> [CardReader]
          /// Get the last connected reader. This is the object in the getPreviousConnectedReaders return that the SDK most recently connected to.
          /// - Returns: async single `CardReader` object
    public func getPreviousConnectedReader() async throws -> CardReader

var cardReaders = [CardReader]()

   override func viewDidAppear(_ animated: Bool) {
      super.viewDidAppear(animated)

      Task { @MainActor in
         do {
            for try await cardReader in CloverPaymentSDK.shared.scan() {
               print("Found Reader: \(cardReader.name ?? cardReader.id)")
               cardReaders.append(cardReader)
            }
         } catch {
            print("Error scanning for readers: \(error)")
         }
      }
   }

//hold the SDK observer subscriptions
private var subscriptions = Set<AnyCancellable>()
 
override func viewDidLoad() {
    super.viewDidLoad()
      
    //observe changes to the battery level
    CloverPaymentSDK.shared.readerBatteryPct.sink { pct in
        // ...
        // update label or graphical indication of battery level
        // ...
    }.store(in: &subscriptions)
      
    //observe changes to the connection state of the reader
    CloverPaymentSDK.shared.readerStatus.sink { state in
        switch state {
        case .initializing:
            // Update status label to display "Initializing" state
        case .updatingFW:
            // Update status label to display "Firmware Updating" state
        case .lowBattery:
            // Update status label to display a "Low Battery" warning
        case .ready:
            // Update status label to display a "Connected" state
        case .disconnected:
            // Handle disconnection event and display the disconnected state
        default:
            break
        }
    }.store(in: &subscriptions)
}

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
   Task { @MainActor in
      do {
         // Pass in a specific CardReader object to connect to that reader
         try await CloverPaymentSDK.shared.connect(reader: self.cardReaders[indexPath.row])
 
         print("Connected to reader")
      } catch {
         print("Error connecting to reader: \(error)")
      }
   }
}

func reconnectPreviousReader() {
    Task { @MainActor in
       do {
          // Passing nil for the reader instructs the SDK to connect to the last connected device
          try await CloverPaymentSDK.shared.connect(reader: nil)
           
          print("Connected to previous reader")
       } catch {
          print("Error connecting to reader: \(error)")
       }
    }
 }

/// Connect to a bluetooth `CardReader`
/// - Parameters:
///   - reader: The specific `CardReader` to connect to.  If no `CardReader` is provided, then we will attempt to connect to the last connected reader, if available.
/// - Throws: `CloverError` and closes the stream if it encounters an error.
/// - Precondition: `SDKState` must be `.ready`.
/// - Precondition: `isLoggedIn` must be `true`
/// - Precondition: The SDK must not be connected to a `CardReader`
public func connect(reader: CardReader?) async throws

/// Get the currently connected card reader.  Also provides a Publisher of the CardReader so you can subscribe to changes to this object.
/// - Returns: An optional, observable CardReader that publishes changes when the reader connects or disconnects (present vs nil), the reader's `.state`, and `.batteryLevel`
/// - Remark: Recommended for SwiftUI consumption, due to its nature as a @Published property.  Can also reference the projected value as a simple property.
/// - Warning: If you subscribe to this property and either the `readerState` or `readerBatteryPct` publishers, you'll receive duplicate notifications from both subscribers.
/// - Precondition: `SDKState` must be `.ready`
/// - Precondition: `isLoggedIn` must be `true`
@Published public internal(set) var connectedReader: CardReader?

/// Get the state of the CardReader now and over time.  Once connected, the `.connectedReader` property will contain a fully hydrated `CardReader` object that can be inspected.
/// - Remark: This is intended primarily for UIKit-based subscribers.
/// - Remark: Defaults to `.disconnected` before a connection is attempted, and returns to `.disconnected` once a reader session ends— the `.connectedReader` becomes nil and you should clean up any references that you hold to that reader.
/// - Warning: If you subscribe to this property and observe/subscribe to the `$connectedReader` publisher, you'll receive duplicate notifications about reader state changes from both publishers.
public let readerStatus = CurrentValueSubject<ReaderStatus, Never>(.disconnected)

/// Get the battery level of the currently connected card reader now and over time. Default value of nil when no reader is connected.
/// - Remark: This is intended primarily for UIKit-based subscribers.
/// - Warning: If you subscribe to this property and observe/subscribe to the `$connectedReader` publisher, you'll receive duplicate notifications about battery level changes from both publishers.
public let readerBatteryPct = CurrentValueSubject<Int?, Never>(nil)