import StripeTerminal
import Foundation

enum ReactNativeConstants: String, CaseIterable {
    case UPDATE_DISCOVERED_READERS = "didUpdateDiscoveredReaders"
    case FINISH_DISCOVERING_READERS = "didFinishDiscoveringReaders"
    case REPORT_AVAILABLE_UPDATE = "didReportAvailableUpdate"
    case UPDATE_REQUIREMENTS_AVAILABLE = "didUpdateRequirementsAvailable"
    case START_INSTALLING_UPDATE = "didStartInstallingUpdate"
    case REPORT_UPDATE_PROGRESS = "didReportReaderSoftwareUpdateProgress"
    case FINISH_INSTALLING_UPDATE = "didFinishInstallingUpdate"
    case FETCH_TOKEN_PROVIDER = "onFetchTokenProviderListener"
    case REQUEST_READER_INPUT = "didRequestReaderInput"
    case REQUEST_READER_DISPLAY_MESSAGE = "didRequestReaderDisplayMessage"
    case CHANGE_PAYMENT_STATUS = "didChangePaymentStatus"
    case CHANGE_CONNECTION_STATUS = "didChangeConnectionStatus"
    case START_READER_RECONNECT = "didStartReaderReconnect"
    case READER_RECONNECT_SUCCEED = "didSucceedReaderReconnect"
    case READER_RECONNECT_FAIL = "didFailReaderReconnect"
    case CHANGE_OFFLINE_STATUS = "didChangeOfflineStatus"
    case FORWARD_PAYMENT_INTENT = "didForwardPaymentIntent"
    case REPORT_FORWARDING_ERROR = "didReportForwardingError"
    case DISCONNECT = "didDisconnect"
    case UPDATE_BATTERY_LEVEL = "didUpdateBatteryLevel"
    case REPORT_LOW_BATTERY_WARNING = "didReportLowBatteryWarning"
    case REPORT_READER_EVENT = "didReportReaderEvent"
    case ACCEPT_TERMS_OF_SERVICE = "didAcceptTermsOfService"
    case PAYMENT_METHOD_SELECTION_REQUIRED = "onPaymentMethodSelectionRequired"
    case QR_CODE_DISPLAY_REQUIRED = "onQrCodeDisplayRequired"
}

@objc(StripeTerminalReactNative)
class StripeTerminalReactNative: RCTEventEmitter, DiscoveryDelegate, MobileReaderDelegate, TerminalDelegate, OfflineDelegate, InternetReaderDelegate, TapToPayReaderDelegate, ReaderDelegate, ReaderPaymentInteractionDelegate {

    var discoveredReadersList: [Reader]? = nil
    var paymentIntents: [AnyHashable : PaymentIntent] = [:]
    var setupIntents: [AnyHashable : SetupIntent] = [:]

    private struct BridgeError: Error {
        let nsError: NSError
    }

    private var hasListeners = false

    override func startObserving() {
        hasListeners = true
    }

    override func stopObserving() {
        hasListeners = false
    }

    override func sendEvent(withName name: String!, body: Any!) {
        guard hasListeners else {
            return
        }
        super.sendEvent(withName: name, body: body)
    }

    override func supportedEvents() -> [String]! {
        return ReactNativeConstants.allCases.map {
            $0.rawValue
        }
    }

    @objc override func constantsToExport() -> [AnyHashable : Any]! {
        return ReactNativeConstants.allCases.reduce(into: [String: String]()) {
            $0[String(describing: $1)] = $1.rawValue
        }
    }

    @objc override static func requiresMainQueueSetup() -> Bool {
        return false
    }

    var discoverCancelable: Cancelable? = nil
    var easyConnectCancelable: Cancelable? = nil
    var collectPaymentMethodCancelable: Cancelable? = nil
    var processRefundCancelable: Cancelable? = nil
    var collectSetupIntentCancelable: Cancelable? = nil
    var installUpdateCancelable: Cancelable? = nil
    var readReusableCardCancelable: Cancelable? = nil
    var cancelReaderConnectionCancellable: Cancelable? = nil
    var collectDataCancellable: Cancelable? = nil
    var collectInputsCancellable: Cancelable? = nil
    var confirmPaymentIntentCancelable: Cancelable? = nil
    var processPaymentIntentCancelable: Cancelable? = nil
    var confirmSetupIntentCancelable: Cancelable? = nil
    var processSetupIntentCancelable: Cancelable? = nil
    var loggingToken: String? = nil

    // Single callback storage for MPOS - only one payment flow at a time
    var paymentMethodSelectionCallback: PaymentMethodSelectionCompletionBlock?
    var qrCodeDisplayCallback: QrCodeDisplayCompletionBlock?

    // Registration flags - JS tells native whether it will handle callbacks
    var paymentMethodSelectionHandlerRegistered = false
    var qrCodeDisplayHandlerRegistered = false

    // Store available payment options to select from later
    var availablePaymentOptions: [PaymentOption] = []


    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
        discoveredReadersList = readers
        guard terminal.connectionStatus == .notConnected || terminal.connectionStatus == .discovering else { return }

        sendEvent(withName: ReactNativeConstants.UPDATE_DISCOVERED_READERS.rawValue, body: ["readers": Mappers.mapFromReaders(readers)])
    }

    @objc(initialize:resolver:rejecter:)
    func initialize(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        // iOS SDK doesn't support Apps On Devices
        if let error = Errors.validateAppsOnDevicesConnectionTokenProviderNotUsed(params) {
            resolve(error)
            return
        }

        var connectedReader: NSDictionary? = nil

        TokenProvider.delegate = self

        let logLevel = Mappers.mapToLogLevel(params["logLevel"] as? String)
        guard let localeParams = params["localeConfig"] as? NSDictionary else {
            resolve(Errors.createErrorFromRnCodeEnum(
                rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER,
                message: "You must provide a localeConfig"
            ))
            return
        }

        let localeConfig: LocaleConfig
        do {
            guard let mappedLocaleConfig = try Mappers.mapToLocaleConfig(localeParams) else {
                resolve(Errors.createErrorFromRnCodeEnum(
                    rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER,
                    message: "You must provide a valid localeConfig"
                ))
                return
            }
            localeConfig = mappedLocaleConfig
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        if (Terminal.isInitialized()) {
            if let reader = Terminal.shared.connectedReader {
                connectedReader = Mappers.mapFromReader(reader)
            }
            Terminal.shared.logLevel = logLevel
        } else {
            Terminal.initWithTokenProvider(
                TokenProvider.shared,
                delegate: self,
                offlineDelegate: self,
                logLevel: logLevel,
                localeConfig: localeConfig
            )
        }

        Terminal.shared.offlineDelegate = self

        if Terminal.shared.responds(to: NSSelectorFromString("setReactNativeSdkVersion:")) && params["reactNativeVersion"] != nil {
            Terminal.shared.performSelector(
                inBackground: NSSelectorFromString("setReactNativeSdkVersion:"),
                with: params["reactNativeVersion"]
            )
        }

        Terminal.shared.delegate = self
        ReaderDelegateForwarder.shared.target = self

        resolve(["reader": connectedReader])
    }

    @objc(cancelCollectPaymentMethod:rejecter:)
    func cancelCollectPaymentMethod(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = collectPaymentMethodCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "collectPaymentMethod could not be canceled because the command has already been canceled or has completed."))
            return
        }
        DispatchQueue.main.async {
            cancelable.cancel() { error in
                if let error = error as NSError? {
                    resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
                } else {
                    if self.collectPaymentMethodCancelable === cancelable {
                        self.collectPaymentMethodCancelable = nil
                    }
                    resolve([:])
                }
            }
        }
    }

    @objc(cancelProcessRefund:rejecter:)
    func cancelProcessRefund(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = processRefundCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "processRefund could not be canceled because the command has already been canceled or has completed."))
            return
        }
        DispatchQueue.main.async {
            cancelable.cancel() { error in
                if let error = error as NSError? {
                    resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
                } else {
                    if self.processRefundCancelable === cancelable {
                        self.processRefundCancelable = nil
                    }
                    resolve([:])
                }
            }
        }
    }

    @objc(cancelConfirmPaymentIntent:rejecter:)
    func cancelConfirmPaymentIntent(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = confirmPaymentIntentCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "cancelConfirmPaymentIntent could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                if self.confirmPaymentIntentCancelable === cancelable {
                    self.confirmPaymentIntentCancelable = nil
                }
                resolve([:])
            }
        }
    }

    @objc(cancelProcessPaymentIntent:rejecter:)
    func cancelProcessPaymentIntent(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = processPaymentIntentCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "processPaymentIntent could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                if self.processPaymentIntentCancelable === cancelable {
                    self.processPaymentIntentCancelable = nil
                }
                resolve([:])
            }
        }
    }

    @objc(cancelConfirmSetupIntent:rejecter:)
    func cancelConfirmSetupIntent(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = confirmSetupIntentCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "cancelConfirmSetupIntent could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                if self.confirmSetupIntentCancelable === cancelable {
                    self.confirmSetupIntentCancelable = nil
                }
                resolve([:])
            }
        }
    }

    @objc(cancelProcessSetupIntent:rejecter:)
    func cancelProcessSetupIntent(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = processSetupIntentCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "cancelProcessSetupIntent could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                if self.processSetupIntentCancelable === cancelable {
                    self.processSetupIntentCancelable = nil
                }
                resolve([:])
            }
        }
    }

    @objc(cancelCollectSetupIntent:rejecter:)
    func cancelCollectSetupIntent(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = collectSetupIntentCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "collectSetupIntent could not be canceled because the command has already been canceled or has completed."))
            return
        }
        DispatchQueue.main.async {
            cancelable.cancel() { error in
                if let error = error as NSError? {
                    resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
                } else {
                    if self.collectSetupIntentCancelable === cancelable {
                        self.collectSetupIntentCancelable = nil
                    }
                    resolve([:])
                }
            }
        }
    }

    @objc(setSimulatedCard:resolver:rejecter:)
    func setSimulatedCard(cardNumber: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        Terminal.shared.simulatorConfiguration.simulatedCard = SimulatedCard(testCardNumber: cardNumber)
        resolve([:])
    }

    @objc(setSimulatedOfflineMode:resolver:rejecter:)
    func setSimulatedOfflineMode(simulatedOffline: Bool, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        Terminal.shared.simulatorConfiguration.offlineEnabled = simulatedOffline;
        resolve([:])
    }

    @objc(setSimulatedCollectInputsResult:resolver:rejecter:)
    func setSimulatedCollectInputsResult(
      _ behavior: String,
      resolver resolve: @escaping RCTPromiseResolveBlock,
      rejecter reject: @escaping RCTPromiseRejectBlock
    ) {
        let allowedValues = ["all", "none", "timeout"]
        if !allowedValues.contains(behavior.lowercased()) {
            reject("Failed", "You must provide \(allowedValues) parameters.", nil)
            return
        }

        let result: SimulatedCollectInputsResult = Mappers.mapToSimulatedCollectInputsResult(behavior)
        Terminal.shared.simulatorConfiguration.simulatedCollectInputsResult = result
        resolve([:])
    }

    @objc(setConnectionToken:resolver:rejecter:)
    func setConnectionToken(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        let token = params["token"] as? String
        let error = params["error"] as? String

        TokenProvider.shared.setConnectionToken(token: token, error: error)
        resolve([:])
    }

    @objc(discoverReaders:resolver:rejecter:)
    func discoverReaders(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let simulated = params["simulated"] as? Bool
        let discoveryMethod = params["discoveryMethod"] as? String
        let timeout = params["timeout"] as? UInt ?? 0
        let locationId = params["locationId"] as? String
        let discoveryFilter = Mappers.mapToDiscoveryFilter(params["discoveryFilter"] as? NSDictionary)
        let config: DiscoveryConfiguration
        do {
            config = try Mappers.mapToDiscoveryConfiguration(discoveryMethod, simulated: simulated ?? false,  locationId: locationId, discoveryFilter: discoveryFilter, timeout: timeout)
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
          return
        }

        guard discoverCancelable == nil else {
            let message = Errors.createBusyMessage(command: "discoverReaders", by: "discoverReaders")
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.READER_BUSY, message: message))
            return
        }

        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            self.discoverCancelable = nil
            if let error = error as NSError? {
                let _error = Errors.createErrorFromNSError(nsError: error, source: .native)

                resolve(_error)
                self.sendEvent(withName: ReactNativeConstants.FINISH_DISCOVERING_READERS.rawValue, body: ["result": _error])
            } else {
                resolve([:])
                self.sendEvent(withName: ReactNativeConstants.FINISH_DISCOVERING_READERS.rawValue, body: ["result": ["error": nil]])
            }
        }
    }

    @objc(cancelDiscovering:rejecter:)
    func cancelDiscovering(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = discoverCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "discoverReaders could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                resolve([:])
            }
        }
    }

    @objc(easyConnect:resolver:rejecter:)
    func easyConnect(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let discoveryMethod = params["discoveryMethod"] as? String else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide a discoveryMethod"))
            return
        }

        let simulated = params["simulated"] as? Bool ?? false
        let timeout = params["timeout"] as? UInt ?? 0
        let locationId = params["locationId"] as? String
        let discoveryFilter = Mappers.mapToDiscoveryFilter(params["discoveryFilter"] as? NSDictionary)

        let autoReconnectOnUnexpectedDisconnect = params["autoReconnectOnUnexpectedDisconnect"] as? Bool ?? true
        let failIfInUse = params["failIfInUse"] as? Bool ?? false
        let merchantDisplayName = params["merchantDisplayName"] as? String
        let onBehalfOf = params["onBehalfOf"] as? String
        let tosAcceptancePermitted = params["tosAcceptancePermitted"] as? Bool ?? true

        let testReaderUpdate: TestReaderUpdate? = (params["testReaderUpdate"] as? NSDictionary).flatMap { Mappers.mapToTestReaderUpdate($0) }

        let discoveryConfig: DiscoveryConfiguration
        do {
            discoveryConfig = try Mappers.mapToDiscoveryConfiguration(discoveryMethod, simulated: simulated, locationId: locationId, discoveryFilter: discoveryFilter, timeout: timeout)
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }
        let connectionConfig: ConnectionConfiguration
        do {
            connectionConfig = try getConnectionConfig(
              locationId: locationId,
              autoReconnectOnUnexpectedDisconnect: autoReconnectOnUnexpectedDisconnect,
              failIfInUse: failIfInUse,
              merchantDisplayName: merchantDisplayName,
              onBehalfOf: onBehalfOf,
              tosAcceptancePermitted: tosAcceptancePermitted,
              testReaderUpdate: testReaderUpdate,
              discoveryMethod: Mappers.mapToDiscoveryMethod(discoveryMethod))!
        } catch let error as BridgeError {
            resolve(Errors.createErrorFromNSError(nsError: error.nsError, source: .rn))
            return
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let easyConnectConfig: EasyConnectConfiguration
        do {
            easyConnectConfig = try getEasyConnectConfiguration(
                discoveryConfig: discoveryConfig,
                connectionConfig: connectionConfig
            )
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .rn))
            return
        }

        guard easyConnectCancelable == nil else {
            let message = Errors.createBusyMessage(command: "easyConnect", by: "easyConnect")
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.READER_BUSY, message: message))
            return
        }
        self.easyConnectCancelable = Terminal.shared.easyConnect(easyConnectConfig) { reader, error in
            self.easyConnectCancelable = nil
            if let reader {
                resolve(["reader": Mappers.mapFromReader(reader)])
            } else if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            } else {
                resolve([:])
            }
        }
    }

    @objc(cancelEasyConnect:rejecter:)
    func cancelEasyConnect(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = easyConnectCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "easyConnect could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            } else {
                resolve([:])
                self.easyConnectCancelable = nil
            }
        }
    }

    @objc(connectReader:resolver:rejecter:)
    func connectReader(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let reader = params["reader"] as? NSDictionary else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide a reader object"))
            return
        }
        guard let discoveryMethod = params["discoveryMethod"] as? String else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide a discoveryMethod"))
            return
        }

        // since simulated readers don't contain `id` property we take serialNumber as a fallback
        let readerId = reader["serialNumber"] as? String
        let discoveryMethodType = Mappers.mapToDiscoveryMethod(discoveryMethod)
        guard let selectedReader = discoveredReadersList?.first(where: { $0.serialNumber == readerId }) else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "Could not find reader with id \(readerId ?? "")"))
            return

        }

        let locationId = params["locationId"] as? String
        let autoReconnectOnUnexpectedDisconnect = params["autoReconnectOnUnexpectedDisconnect"] as? Bool ?? true
        let failIfInUse: Bool = params["failIfInUse"] as? Bool ?? false
        let onBehalfOf: String? = params["onBehalfOf"] as? String
        let merchantDisplayName: String? = params["merchantDisplayName"] as? String
        let tosAcceptancePermitted: Bool = params["tosAcceptancePermitted"] as? Bool ?? true

        self.paymentMethodSelectionHandlerRegistered = params["hasPaymentMethodSelectionCallback"] as? Bool ?? false
        self.qrCodeDisplayHandlerRegistered = params["hasQrCodeDisplayCallback"] as? Bool ?? false

        let testReaderUpdate: TestReaderUpdate? = (params["testReaderUpdate"] as? NSDictionary).flatMap { Mappers.mapToTestReaderUpdate($0) }

        let connectionConfig: ConnectionConfiguration
        do {
            connectionConfig = try getConnectionConfig(
                locationId: locationId,
                autoReconnectOnUnexpectedDisconnect: autoReconnectOnUnexpectedDisconnect,
                failIfInUse: failIfInUse,
                merchantDisplayName: merchantDisplayName,
                onBehalfOf: onBehalfOf,
                tosAcceptancePermitted: tosAcceptancePermitted,
                testReaderUpdate: testReaderUpdate,
                discoveryMethod: discoveryMethodType)! // TODO find way to !
        } catch let error as BridgeError {
            resolve(Errors.createErrorFromNSError(nsError: error.nsError, source: .rn))
            return
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        Task { @MainActor in
            do {
                let reader = try await Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig)
                resolve(["reader": Mappers.mapFromReader(reader)])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    func getConnectionConfig(
        locationId: String?,
        autoReconnectOnUnexpectedDisconnect: Bool,
        failIfInUse: Bool,
        merchantDisplayName: String?,
        onBehalfOf: String?,
        tosAcceptancePermitted: Bool,
        testReaderUpdate: TestReaderUpdate?,
        discoveryMethod: DiscoveryMethod) throws -> ConnectionConfiguration? {
        let delegate = ReaderDelegateForwarder.shared
        switch discoveryMethod {
        case .bluetoothScan, .bluetoothProximity:
            guard let locationId else {
                throw BridgeError(nsError: NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "Location ID is required for Bluetooth connection"]))
            }
            let builder = BluetoothConnectionConfigurationBuilder(delegate: delegate, locationId: locationId)
               .setAutoReconnectOnUnexpectedDisconnect(autoReconnectOnUnexpectedDisconnect)
               .setReaderPaymentInteractionDelegate(self)
            if let testReaderUpdate {
                builder.setTestReaderUpdate(testReaderUpdate)
            }
            return try builder.build()
        case .internet:
            return try InternetConnectionConfigurationBuilder(delegate: delegate)
                .setFailIfInUse(failIfInUse)
                .build()
        case .tapToPay:
            guard let locationId else {
                throw BridgeError(nsError: NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "Location ID is required for Tap to Pay connection"]))
            }
            let builder = TapToPayConnectionConfigurationBuilder(delegate: delegate, locationId: locationId)
                .setMerchantDisplayName(merchantDisplayName)
                .setOnBehalfOf(onBehalfOf)
                .setAutoReconnectOnUnexpectedDisconnect(autoReconnectOnUnexpectedDisconnect)
                .setTosAcceptancePermitted(tosAcceptancePermitted)
                .setReaderPaymentInteractionDelegate(self)
            if let testReaderUpdate {
                builder.setTestReaderUpdate(testReaderUpdate)
            }
            return try builder.build()
        case .usb:
            guard let locationId else {
                throw BridgeError(nsError: NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "Location ID is required for USB connection"]))
            }
            let builder = UsbConnectionConfigurationBuilder(delegate: delegate, locationId: locationId)
                .setAutoReconnectOnUnexpectedDisconnect(autoReconnectOnUnexpectedDisconnect)
                .setReaderPaymentInteractionDelegate(self)
            if let testReaderUpdate {
                builder.setTestReaderUpdate(testReaderUpdate)
            }
            return try builder.build()
        @unknown default:
            return nil
        }
    }

    private func getEasyConnectConfiguration(
        discoveryConfig: DiscoveryConfiguration,
        connectionConfig: ConnectionConfiguration
    ) throws -> EasyConnectConfiguration {
        switch discoveryConfig {
        case let internetDiscoveryConfig as InternetDiscoveryConfiguration:
            guard let internetConnectionConfig = connectionConfig as? InternetConnectionConfiguration else {
                throw NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "Internet easyConnect requires Internet connection configuration"])
            }
            return InternetEasyConnectConfiguration(
                discoveryConfiguration: internetDiscoveryConfig,
                connectionConfiguration: internetConnectionConfig
            )

        case let tapToPayDiscoveryConfig as TapToPayDiscoveryConfiguration:
            guard let tapToPayConnectionConfig = connectionConfig as? TapToPayConnectionConfiguration else {
                throw NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "TapToPay easyConnect requires TapToPay connection configuration"])
            }
            return TapToPayEasyConnectConfiguration(
                discoveryConfiguration: tapToPayDiscoveryConfig,
                connectionConfiguration: tapToPayConnectionConfig
            )

        default:
            let configType = String(describing: type(of: discoveryConfig))
            throw NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "Easy connect is not supported for \(configType)"])
        }
    }

    @objc(disconnectReader:rejecter:)
    func disconnectReader(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        Task { @MainActor in
            let collectCancelable = self.collectPaymentMethodCancelable
            do {
                try await Terminal.shared.disconnectReader()
                if self.collectPaymentMethodCancelable === collectCancelable {
                    self.collectPaymentMethodCancelable = nil
                }
                self.clearAllIntentMaps()
                resolve([:])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    @objc(rebootReader:rejecter:)
    func rebootReader(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        Task { @MainActor in
            do {
                try await Terminal.shared.rebootReader()
                self.clearAllIntentMaps()
                resolve([:])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    func tapToPayReaderDidAcceptTermsOfService(_ reader: Reader) {
        sendEvent(withName: ReactNativeConstants.ACCEPT_TERMS_OF_SERVICE.rawValue, body: ["reader": reader])
    }

    @objc(createPaymentIntent:resolver:rejecter:)
    func createPaymentIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let amount = params["amount"] as? NSNumber ?? 0
        let currency = params["currency"] as? String ?? ""
        let setupFutureUsage = params["setupFutureUsage"] as? String
        let paymentMethodTypes = params["paymentMethodTypes"] as? [String] ?? []
        let onBehalfOf = params["onBehalfOf"] as? String
        let transferDataDestination = params["transferDataDestination"] as? String
        let applicationFeeAmount = params["applicationFeeAmount"] as? NSNumber

        let description = params["description"] as? String
        let statementDescriptor = params["statementDescriptor"] as? String
        let statementDescriptorSuffix = params["statementDescriptorSuffix"] as? String
        let receiptEmail = params["receiptEmail"] as? String
        let customer = params["customer"] as? String
        let transferGroup = params["transferGroup"] as? String
        let metadata = params["metadata"] as? [String : String]
        let paymentMethodOptions = params["paymentMethodOptions"] as? [AnyHashable : Any] ?? [:]
        let extendedAuth = paymentMethodOptions["requestExtendedAuthorization"] as? Bool ?? false
        let incrementalAuth = paymentMethodOptions["requestIncrementalAuthorizationSupport"] as? Bool ?? false
        let requestedPriority = paymentMethodOptions["requestedPriority"] as? String
        let requestPartialAuthorization = paymentMethodOptions["requestPartialAuthorization"] as? String
        let requestReauthorization = paymentMethodOptions["requestReauthorization"] as? String
        let cardPresentCaptureMethod = paymentMethodOptions["captureMethod"] as? String
        let captureDelayDays = paymentMethodOptions["captureDelayDays"] as? Int
        let requestMulticapture = paymentMethodOptions["requestMulticapture"] as? String
        let captureMethod = params["captureMethod"] as? String

        let paymentParamsBuilder = PaymentIntentParametersBuilder(amount: UInt(truncating: amount),currency: currency)
            .setSetupFutureUsage(setupFutureUsage)
            .setOnBehalfOf(onBehalfOf)
            .setTransferDataDestination(transferDataDestination)
            .setApplicationFeeAmount(applicationFeeAmount)
            .setStripeDescription(description)
            .setStatementDescriptor(statementDescriptor)
            .setStatementDescriptorSuffix(statementDescriptorSuffix)
            .setReceiptEmail(receiptEmail)
            .setCustomer(customer)
            .setTransferGroup(transferGroup)
            .setMetadata(metadata)

        if let resolvedCaptureMethod = Mappers.mapToCaptureMethod(captureMethod) {
            paymentParamsBuilder.setCaptureMethod(resolvedCaptureMethod)
        }

        if !paymentMethodTypes.isEmpty {
            paymentParamsBuilder.setPaymentMethodTypes(Mappers.mapPaymentIntentPaymentMethodTypes(paymentMethodTypes))
        }

        let cardPresentParamsBuilder = CardPresentParametersBuilder()
            .setRequestExtendedAuthorization(extendedAuth)
            .setRequestIncrementalAuthorizationSupport(incrementalAuth)
        switch requestedPriority {
        case "domestic":
            cardPresentParamsBuilder.setRequestedPriority(CardPresentRouting.domestic)
        case "international":
            cardPresentParamsBuilder.setRequestedPriority(CardPresentRouting.international)
        default:
            break
        }
        switch requestPartialAuthorization {
        case "if_available":
            cardPresentParamsBuilder.setRequestPartialAuthorization(CardPresentRequestPartialAuthorization.ifAvailable)
        case "never":
            cardPresentParamsBuilder.setRequestPartialAuthorization(CardPresentRequestPartialAuthorization.never)
        default:
            break
        }

        switch requestReauthorization {
        case "if_available":
            cardPresentParamsBuilder.setRequestReauthorization(CardPresentRequestReauthorization.ifAvailable)
        case "never":
            cardPresentParamsBuilder.setRequestReauthorization(CardPresentRequestReauthorization.never)
        default:
            break
        }

        switch cardPresentCaptureMethod {
          case "manual":
              cardPresentParamsBuilder.setCaptureMethod(CardPresentCaptureMethod.manual)
          case "manual_preferred":
              cardPresentParamsBuilder.setCaptureMethod(CardPresentCaptureMethod.manualPreferred)
          case "automatic_delayed":
              cardPresentParamsBuilder.setCaptureMethod(CardPresentCaptureMethod.automaticDelayed)
          default:
              break
        }

        if let captureDelayDays = captureDelayDays {
            cardPresentParamsBuilder.setCaptureDelayDays(captureDelayDays)
        }

        switch requestMulticapture {
          case "if_available":
              cardPresentParamsBuilder.setRequestMulticapture(CardPresentRequestMulticapture.ifAvailable)
          case "never":
              cardPresentParamsBuilder.setRequestMulticapture(CardPresentRequestMulticapture.never)
          default:
              break
        }

        do {
            if let installmentsParameters = try mapToInstallmentsParameters(paymentMethodOptions) {
                cardPresentParamsBuilder.setInstallments(installmentsParameters)
            }
        } catch let error as BridgeError {
            resolve(Errors.createErrorFromNSError(nsError: error.nsError, source: .rn))
            return
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let cardPresentParams: CardPresentParameters
        do {
            cardPresentParams = try cardPresentParamsBuilder.build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let paymentMethodOptionsParameters: PaymentMethodOptionsParameters
        do {
            paymentMethodOptionsParameters = try PaymentMethodOptionsParametersBuilder(cardPresentParameters: cardPresentParams).build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }
        paymentParamsBuilder.setPaymentMethodOptionsParameters(paymentMethodOptionsParameters)

        let paymentParams: PaymentIntentParameters
        do {
            paymentParams = try paymentParamsBuilder.build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let offlineBehavior = params["offlineBehavior"] as? String
        let offlineBehaviorFromTransactionLimit: OfflineBehavior = {
            switch offlineBehavior {
            case "prefer_online": return OfflineBehavior.preferOnline
            case "require_online": return OfflineBehavior.requireOnline
            case "force_offline": return OfflineBehavior.forceOffline
            default: return OfflineBehavior.preferOnline
            }
        }()

        let offlineCreateConfig: CreateConfiguration
        do {
            offlineCreateConfig = try CreateConfigurationBuilder().setOfflineBehavior(offlineBehaviorFromTransactionLimit).build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let uuid = UUID().uuidString
        Task { @MainActor in
            do {
                let paymentIntent = try await Terminal.shared.createPaymentIntent(paymentParams, createConfig: offlineCreateConfig)
                self.paymentIntents[uuid] = paymentIntent
                let mappedPaymentIntent = Mappers.mapFromPaymentIntent(paymentIntent, uuid: uuid)
                resolve(["paymentIntent": mappedPaymentIntent])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, uuid: uuid, source: .native))
            }
        }
    }

    func mapToInstallmentsParameters(_ paymentMethodOptions: [AnyHashable: Any]?) throws -> InstallmentsParameters? {
        guard let installments = paymentMethodOptions?["installments"] as? [AnyHashable: Any] else {
            return nil
        }

        let builder = InstallmentsParametersBuilder()
        if installments.keys.contains("enabled") {
            guard let enabled = installments["enabled"] as? Bool else {
                throw BridgeError(
                    nsError: NSError(
                        domain: "StripeTerminal",
                        code: -1,
                        userInfo: [NSLocalizedDescriptionKey: "installments.enabled must be a Boolean"]
                    )
                )
            }
            builder.setEnabled(enabled)
        }
        return try builder.build()
    }

    @objc(createSetupIntent:resolver:rejecter:)
    func createSetupIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let setupIntentParams: SetupIntentParameters
        do {
            setupIntentParams = try Mappers.mapToSetupIntent(params).build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let uuid = UUID().uuidString
        Task { @MainActor in
            do {
                let setupIntent = try await Terminal.shared.createSetupIntent(setupIntentParams)
                self.setupIntents[uuid] = setupIntent
                let mappedSetupIntent = Mappers.mapFromSetupIntent(setupIntent, uuid: uuid)
                resolve(["setupIntent": mappedSetupIntent])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, uuid: uuid, source: .native))
            }
        }
    }

    @objc(collectPaymentMethod:resolver:rejecter:)
    func collectPaymentMethod(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        self.paymentMethodSelectionCallback = nil
        self.qrCodeDisplayCallback = nil

        guard let (paymentIntent, uuid) = getPaymentIntentAndUuid(from: params, resolve: resolve) else {
            return
        }

        guard let collectConfig = buildCollectPaymentIntentConfiguration(from: params, resolve: resolve) else {
            return
        }

        self.collectPaymentMethodCancelable = Terminal.shared.collectPaymentMethod(
            paymentIntent,
            collectConfig: collectConfig
        ) { pi, collectError  in
            if let error = collectError as NSError? {
                self.collectPaymentMethodCancelable = nil
                resolve(Errors.createErrorFromNSError(nsError: error, uuid: uuid, source: .native))
            } else if let paymentIntent = pi {
                // Successful collection keeps the transaction session cancelable until confirmation.
                // Always store the latest instance of the PaymentIntent so we pass the latest instance back in
                // to the confirm call.
                self.paymentIntents[uuid] = paymentIntent
                let mappedPaymentIntent = Mappers.mapFromPaymentIntent(paymentIntent, uuid: uuid)
                resolve(["paymentIntent": mappedPaymentIntent])
            }
        }
    }

    @objc(retrievePaymentIntent:resolver:rejecter:)
    func retrievePaymentIntent(secret: String?, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let clientSecret = secret else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide cliectSecret."))
            return
        }

        let uuid = UUID().uuidString
        Task { @MainActor in
            do {
                let paymentIntent = try await Terminal.shared.retrievePaymentIntent(clientSecret: clientSecret)
                self.paymentIntents[uuid] = paymentIntent
                let mappedPaymentIntent = Mappers.mapFromPaymentIntent(paymentIntent, uuid: uuid)
                resolve(["paymentIntent": mappedPaymentIntent])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, uuid: uuid, source: .native))
            }
        }
    }

    @objc(processPaymentIntent:resolver:rejecter:)
    func processPaymentIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (paymentIntent, uuid) = getPaymentIntentAndUuid(from: params, resolve: resolve) else {
            return
        }

        guard let collectConfig = buildCollectPaymentIntentConfiguration(from: params, resolve: resolve) else {
            return
        }

        guard let confirmConfig = buildConfirmPaymentIntentConfiguration(from: params, resolve: resolve) else {
            return
        }

        self.processPaymentIntentCancelable = Terminal.shared.processPaymentIntent(paymentIntent, collectConfig: collectConfig, confirmConfig: confirmConfig) { processedPaymentIntent, processError in
            self.processPaymentIntentCancelable = nil
            if let error = processError as NSError? {
                self.updatePaymentIntentFromError(error, uuid: uuid)
                resolve(Errors.createErrorFromNSError(nsError: error, uuid: uuid, source: .native))
            } else if let processedPaymentIntent {
                self.paymentIntents[uuid] = processedPaymentIntent
                let pi = Mappers.mapFromPaymentIntent(processedPaymentIntent, uuid: uuid)
                resolve(["paymentIntent": pi])
            }
        }
    }

    @objc(getLocations:resolver:rejecter:)
    func getLocations(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let limit = params["limit"] as? NSNumber
        let endingBefore = params["endingBefore"] as? String
        let startingAfter = params["startingAfter"] as? String

        let listParametersBuilder = ListLocationsParametersBuilder()

        if let limitValue = limit {
            listParametersBuilder.setLimit(limitValue.uintValue)
        }
        if let endingBeforeValue = endingBefore {
            listParametersBuilder.setEndingBefore(endingBeforeValue)
        }
        if let startingAfterValue = startingAfter {
            listParametersBuilder.setStartingAfter(startingAfterValue)
        }

        let listParameters: ListLocationsParameters
        do {
            listParameters = try listParametersBuilder.build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        Task { @MainActor in
            do {
                let (locations, hasMore) = try await Terminal.shared.listLocations(parameters: listParameters)
                let list = Mappers.mapFromLocationsList(locations)
                resolve(["locations": list, "hasMore": hasMore])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    @objc(confirmPaymentIntent:resolver:rejecter:)
    func confirmPaymentIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (paymentIntent, uuid) = getPaymentIntentAndUuid(from: params, resolve: resolve) else {
            return
        }

        guard let confirmConfig = buildConfirmPaymentIntentConfiguration(from: params, resolve: resolve) else {
            return
        }

        self.confirmPaymentIntentCancelable = Terminal.shared.confirmPaymentIntent(paymentIntent,confirmConfig: confirmConfig) { pi, error in
            self.confirmPaymentIntentCancelable = nil
            if let error = error as NSError? {
                self.updatePaymentIntentFromError(error, uuid: uuid)
                resolve(Errors.createErrorFromNSError(nsError: error, uuid: uuid, source: .native))
            } else if let paymentIntent = pi {
                self.paymentIntents[uuid] = paymentIntent
                let mappedPaymentIntent = Mappers.mapFromPaymentIntent(paymentIntent, uuid: uuid)
                resolve(["paymentIntent": mappedPaymentIntent])
            }
        }
        self.collectPaymentMethodCancelable = nil
    }

    func terminal(_ terminal: Terminal, didChangePaymentStatus status: PaymentStatus) {
        let result = Mappers.mapFromPaymentStatus(status)
        sendEvent(withName: ReactNativeConstants.CHANGE_PAYMENT_STATUS.rawValue, body: ["result": result])
    }

    func terminal(_ terminal: Terminal, didChangeConnectionStatus status: ConnectionStatus) {
        if status == .notConnected {
            // Do not reuse a collection handle from the reader session that ended.
            self.collectPaymentMethodCancelable = nil
        }
        let result = Mappers.mapFromConnectionStatus(status)
        sendEvent(withName: ReactNativeConstants.CHANGE_CONNECTION_STATUS.rawValue, body: ["result": result])
    }

    func reader(_ reader: Reader, didStartReconnect cancelable: Cancelable, disconnectReason: DisconnectReason) {
        self.cancelReaderConnectionCancellable = cancelable
        let result = Mappers.mapFromReaderDisconnectReason(disconnectReason)
        let reader = Mappers.mapFromReader(reader)
        sendEvent(withName: ReactNativeConstants.START_READER_RECONNECT.rawValue, body: ["reason": result, "reader": reader])
    }

    func readerDidSucceedReconnect(_ reader: Reader) {
        let reader = Mappers.mapFromReader(reader)
        sendEvent(withName: ReactNativeConstants.READER_RECONNECT_SUCCEED.rawValue, body: ["reader": reader])
    }

    func readerDidFailReconnect(_ reader: Reader) {
        let reader = Mappers.mapFromReader(reader)
        sendEvent(withName: ReactNativeConstants.READER_RECONNECT_FAIL.rawValue, body: ["reader": reader])
    }

    @objc(cancelReaderReconnection:rejecter:)
    func cancelReaderReconnection(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = cancelReaderConnectionCancellable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "readerReconnection could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                resolve([:])
            }
        }
    }

    @objc(cancelPaymentIntent:resolver:rejecter:)
    func cancelPaymentIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (paymentIntent, uuid) = getPaymentIntentAndUuid(from: params, resolve: resolve) else {
            return
        }
        Task { @MainActor in
            do {
                let canceledPaymentIntent = try await Terminal.shared.cancelPaymentIntent(paymentIntent)
                self.paymentIntents[uuid] = nil
                let mappedPaymentIntent = Mappers.mapFromPaymentIntent(canceledPaymentIntent, uuid: uuid)
                resolve(["paymentIntent": mappedPaymentIntent])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, uuid: uuid, source: .native))
            }
        }
    }

    @objc(installAvailableUpdate:rejecter:)
    func installAvailableUpdate(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        Terminal.shared.installAvailableUpdate()
        resolve([:])
    }

    @objc(cancelInstallingUpdate:rejecter:)
    func cancelInstallingUpdate(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = installUpdateCancelable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "installAvailableUpdate could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                resolve([:])
            }
        }
    }

    @objc(setReaderDisplay:resolver:rejecter:)
    func setReaderDisplay(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let invalidParams = Errors.validateRequiredParameters(params: params, requiredParams: ["currency", "tax", "total"])

        guard invalidParams == nil else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide \(invalidParams!) parameters."))
            return
        }

        let currency = params["currency"] as? String
        let tax = params["tax"] as? NSNumber
        let total = params["total"] as? NSNumber

        let cartBuilder = CartBuilder(currency: currency!)
            .setTax(Int(truncating: tax!))
            .setTotal(Int(truncating: total!))

        let cartLineItems = Mappers.mapToCartLineItems(params["lineItems"] as? NSArray ?? NSArray())
        cartBuilder.setLineItems(cartLineItems)

        let cart: Cart
        do {
            cart = try cartBuilder.build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        Task { @MainActor in
            do {
                try await Terminal.shared.setReaderDisplay(cart)
                resolve([:])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    @objc(cancelSetupIntent:resolver:rejecter:)
    func cancelSetupIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (setupIntent, uuid) = getSetupIntentAndUuid(from: params, resolve: resolve) else {
            return
        }
        Task { @MainActor in
            do {
                let canceledSetupIntent = try await Terminal.shared.cancelSetupIntent(setupIntent)
                self.setupIntents[uuid] = nil
                let mappedSetupIntent = Mappers.mapFromSetupIntent(canceledSetupIntent, uuid: uuid)
                resolve(["setupIntent": mappedSetupIntent])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, uuid: uuid, source: .native))
            }
        }
    }

    @objc(clearReaderDisplay:rejecter:)
    func clearReaderDisplay(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        Task { @MainActor in
            do {
                try await Terminal.shared.clearReaderDisplay()
                resolve([:])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    @objc(retrieveSetupIntent:resolver:rejecter:)
    func retrieveSetupIntent(secret: String?, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let clientSecret = secret else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide cliectSecret."))
            return
        }
        let uuid = UUID().uuidString
        Task { @MainActor in
            do {
                let setupIntent = try await Terminal.shared.retrieveSetupIntent(clientSecret: clientSecret)
                self.setupIntents[uuid] = setupIntent
                let mappedSetupIntent = Mappers.mapFromSetupIntent(setupIntent, uuid: uuid)
                resolve(["setupIntent": mappedSetupIntent])
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, uuid: uuid, source: .native))
            }
        }
    }

    @objc(collectSetupIntentPaymentMethod:resolver:rejecter:)
    func collectSetupIntentPaymentMethod(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (setupIntent, uuid) = getSetupIntentAndUuid(from: params, resolve: resolve) else {
            return
        }

        guard let setupIntentConfiguration = buildCollectSetupIntentConfiguration(from: params, resolve: resolve) else {
            return
        }

        self.collectSetupIntentCancelable = Terminal.shared.collectSetupIntentPaymentMethod(setupIntent, setupConfig: setupIntentConfiguration) { si, collectError  in
            self.collectSetupIntentCancelable = nil
            if let error = collectError as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, uuid: uuid, source: .native))
            } else if let setupIntent = si {
                self.setupIntents[uuid] = setupIntent
                let mappedSetupIntent = Mappers.mapFromSetupIntent(setupIntent, uuid: uuid)
                resolve(["setupIntent": mappedSetupIntent])
            }
        }
    }

    @objc(confirmSetupIntent:resolver:rejecter:)
    func confirmSetupIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (setupIntent, uuid) = getSetupIntentAndUuid(from: params, resolve: resolve) else {
            return
        }

        self.confirmSetupIntentCancelable = Terminal.shared.confirmSetupIntent(setupIntent) { si, collectError  in
            self.confirmSetupIntentCancelable = nil
            if let error = collectError as NSError? {
                self.updateSetupIntentFromError(error, uuid: uuid)
                resolve(Errors.createErrorFromNSError(nsError: error, uuid: uuid, source: .native))
            } else if let setupIntent = si {
                self.setupIntents[uuid] = setupIntent
                let mappedSetupIntent = Mappers.mapFromSetupIntent(setupIntent, uuid: uuid)
                resolve(["setupIntent": mappedSetupIntent])
            }
        }
    }

    @objc(processSetupIntent:resolver:rejecter:)
    func processSetupIntent(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let (setupIntent, uuid) = getSetupIntentAndUuid(from: params, resolve: resolve) else {
            return
        }

        guard let collectConfig = buildCollectSetupIntentConfiguration(from: params, resolve: resolve) else {
            return
        }

        self.processSetupIntentCancelable = Terminal.shared.processSetupIntent(setupIntent, collectConfig: collectConfig) { processedSetupIntent, processError in
            self.processSetupIntentCancelable = nil
            if let error = processError as NSError? {
                self.updateSetupIntentFromError(error, uuid: uuid)
                resolve(Errors.createErrorFromNSError(nsError: error, uuid: uuid, source: .native))
            } else if let processedSetupIntent {
                self.setupIntents[uuid] = processedSetupIntent
                let mappedSetupIntent = Mappers.mapFromSetupIntent(processedSetupIntent, uuid: uuid)
                resolve(["setupIntent": mappedSetupIntent])
            }
        }
    }

    @objc(processRefund:resolver:rejecter:)
    func processRefund(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let invalidParams = Errors.validateRequiredParameters(params: params, requiredParams: ["amount", "currency"])

        guard invalidParams == nil else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide \(invalidParams!) parameters."))
            return
        }
        let chargeId = params["chargeId"] as? String
        let paymentIntentId = params["paymentIntentId"] as? String
        let clientSecret = params["clientSecret"] as? String
        let amount = params["amount"] as? NSNumber
        let currency = params["currency"] as? String
        let intAmount = UInt(truncating: amount!);
        let refundApplicationFee = params["refundApplicationFee"] as? NSNumber
        let reverseTransfer = params["reverseTransfer"] as? NSNumber
        let customerCancellation = Mappers.mapToCustomerCancellation(params["customerCancellation"] as? String)
        let metadata = params["metadata"] as? [String : String]

        let refundParams: ProcessRefundParameters
        do {
            if let paymentIntentId = paymentIntentId, let clientSecret = clientSecret, !paymentIntentId.isEmpty, !clientSecret.isEmpty {
                refundParams = try ProcessRefundParametersBuilder(paymentIntentId: paymentIntentId, clientSecret: clientSecret, amount: intAmount, currency: currency!)
                    .setReverseTransfer(reverseTransfer?.intValue == 1 ? true : false)
                    .setRefundApplicationFee(refundApplicationFee?.intValue == 1 ? true : false)
                    .setMetadata(metadata)
                    .build()
            } else if let chargeId = chargeId, !chargeId.isEmpty {
                refundParams = try ProcessRefundParametersBuilder(chargeId: chargeId, amount: intAmount, currency: currency!)
                    .setReverseTransfer(reverseTransfer?.intValue == 1 ? true : false)
                    .setRefundApplicationFee(refundApplicationFee?.intValue == 1 ? true : false)
                    .setMetadata(metadata)
                    .build()
            } else {
                resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide either a charge ID or a payment intent ID with clientSecret."))
                return
            }
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        let refundConfiguration: CollectRefundConfiguration
        let configurationBuilder = CollectRefundConfigurationBuilder()
        do {
            if let customerCancellation = customerCancellation {
                configurationBuilder.setCustomerCancellation(customerCancellation)
            }
            refundConfiguration = try configurationBuilder.build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        self.processRefundCancelable = Terminal.shared.processRefund(refundParams, collectConfig: refundConfiguration) { refund, error in
            self.processRefundCancelable = nil
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else if let refund = refund {
                let refund = Mappers.mapFromRefund(refund)
                resolve(["refund": refund])
            } else {
                resolve([:])
            }
        }
    }

    @objc(collectData:resolver:rejecter:)
    func collectData(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let collectDataTypeParam = params["collectDataType"] as? String ?? ""

        let collectDataType = Mappers.mapToCollectDataType(collectDataTypeParam)
        guard let collectDataType else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide a collectDataType."))
            return
        }

        let customerCancellation = Mappers.mapToCustomerCancellation(params["customerCancellation"] as? String)
        let collectDataConfig: CollectDataConfiguration
        let configurationBuilder = CollectDataConfigurationBuilder()
        do {
            if let customcustomerCancellation = customerCancellation {
                configurationBuilder.setCustomerCancellation(customcustomerCancellation)
            }
            collectDataConfig = try configurationBuilder.setCollectDataType(collectDataType)
                .build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        self.collectDataCancellable = Terminal.shared.collectData(collectDataConfig) { collectedData, error in
            self.collectDataCancellable = nil
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else if let collectedData {
                resolve(["collectedData": Mappers.mapFromCollectedData(collectedData)])
            } else {
                resolve([:])
            }
        }
    }

    @objc(cancelCollectData:rejecter:)
    func cancelCollectData(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = collectDataCancellable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "collectDataCancellable could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            }
            else {
                resolve([:])
            }
        }
    }

    @objc(print:resolver:rejecter:)
    func print(contentUri: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let image = Mappers.mapToUIImage(contentUri as String) else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide a valid base64 string or a 'data:' URI scheme"))
            return
        }
        let printContent: PrintContent
        do {
            printContent = try PrintContentBuilder(image: image).build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }
        Terminal.shared.print(printContent) { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            } else {
                resolve([:])
            }
        }
    }

    @objc(clearCachedCredentials:rejecter:)
    func clearCachedCredentials(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        Terminal.shared.clearCachedCredentials()
        self.clearAllIntentMaps()
        resolve([:])
    }

    @objc(getLoggingToken:rejecter:)
    func getLoggingToken(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        resolve(["token": self.loggingToken])
    }

    @objc(getOfflineStatus:rejecter:)
    func getOfflineStatus(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let result = Mappers.mapFromOfflineStatus(Terminal.shared.offlineStatus)

        resolve(result)
    }

    @objc(getPaymentStatus:rejecter:)
    func getPaymentStatus(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let result = Mappers.mapFromPaymentStatus(Terminal.shared.paymentStatus)

        resolve(result)
    }

    @objc(getConnectionStatus:rejecter:)
    func getConnectionStatus(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let result = Mappers.mapFromConnectionStatus(Terminal.shared.connectionStatus)

        resolve(result)
    }

    @objc(getConnectedReader:rejecter:)
    func getConnectedReader(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        if let connectedReader = Terminal.shared.connectedReader {
            let result = Mappers.mapFromReader(connectedReader)
            resolve(["reader": result])
        } else {
            resolve(["reader": NSNull()])
        }
    }


    @objc(collectInputs:resolver:rejecter:)
    func collectInputs(_ params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let invalidParams = Errors.validateRequiredParameters(params: params, requiredParams: ["inputs"])

        guard invalidParams == nil else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide \(invalidParams!) parameters."))
            return
        }

        let collectInputsParameters: CollectInputsParameters

        var inputs: [Input] = []
        let collectInputs = params["inputs"] as? [NSDictionary]
        if let collectInputs = collectInputs {
            for collectInput in collectInputs {
                let inputType = collectInput["formType"] as? String ?? ""
                guard let title = collectInput["title"] as? String else {
                    resolve(Errors.createErrorFromRnCodeEnum(rnCode: .INVALID_REQUIRED_PARAMETER, message: "Input title must be a string."))
                    return
                }
                switch (inputType) {
                case "email":
                    do {
                        let toggles = try Mappers.mapToToggles(collectInput["toggles"] as? [NSDictionary])
                        let input = try EmailInputBuilder(title: title)
                            .setRequired(collectInput["required"] as? Bool ?? false)
                            .setStripeDescription(collectInput["description"] as? String ?? "")
                            .setSkipButtonText(collectInput["skipButtonText"] as? String ?? "")
                            .setSubmitButtonText(collectInput["submitButtonText"] as? String ?? "")
                            .setToggles(toggles)
                            .build()
                        inputs.append(input)
                    } catch {
                        resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                        return
                    }
                    break
                case "numeric":
                    do {
                        let toggles = try Mappers.mapToToggles(collectInput["toggles"] as? [NSDictionary])
                        let input = try NumericInputBuilder(title: title)
                            .setRequired(collectInput["required"] as? Bool ?? false)
                            .setStripeDescription(collectInput["description"] as? String ?? "")
                            .setSkipButtonText(collectInput["skipButtonText"] as? String ?? "")
                            .setSubmitButtonText(collectInput["submitButtonText"] as? String ?? "")
                            .setToggles(toggles)
                            .build()
                        inputs.append(input)
                    } catch {
                        resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                        return
                    }
                    break
                case "phone":
                    do {
                        let toggles = try Mappers.mapToToggles(collectInput["toggles"] as? [NSDictionary])
                        let input = try PhoneInputBuilder(title: title)
                            .setRequired(collectInput["required"] as? Bool ?? false)
                            .setStripeDescription(collectInput["description"] as? String ?? "")
                            .setSkipButtonText(collectInput["skipButtonText"] as? String ?? "")
                            .setSubmitButtonText(collectInput["submitButtonText"] as? String ?? "")
                            .setToggles(toggles)
                            .build()
                        inputs.append(input)
                    } catch {
                       resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                       return
                    }
                    break
                case "text":
                    do {
                        let toggles = try Mappers.mapToToggles(collectInput["toggles"] as? [NSDictionary])
                        let input = try TextInputBuilder(title: title)
                            .setRequired(collectInput["required"] as? Bool ?? false)
                            .setStripeDescription(collectInput["description"] as? String ?? "")
                            .setSkipButtonText(collectInput["skipButtonText"] as? String ?? "")
                            .setSubmitButtonText(collectInput["submitButtonText"] as? String ?? "")
                            .setToggles(toggles)
                            .build()
                        inputs.append(input)
                    } catch {
                        resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                        return
                    }
                    break
                case "selection":
                    var selectionButtons: [SelectionButton] = []
                    let selections = collectInput["selectionButtons"] as? [NSDictionary]
                    if let selections = selections {
                        for it in selections {
                            guard let style = it["style"] as? String, let text = it["text"] as? String else {
                                resolve(Errors.createErrorFromRnCodeEnum(rnCode: .INVALID_REQUIRED_PARAMETER, message: "Selection button style and text must be strings."))
                                return
                            }
                            do {
                                let id = (it["id"] as? String) ?? ""
                                let button = try SelectionButtonBuilder(style: (style == "primary") ? .primary : .secondary,
                                                                        text: text,
                                                                        id: id
                                ).build()
                                selectionButtons.append(button)
                            } catch {
                                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                                return
                            }
                        }
                    }
                    do {
                        let toggles = try Mappers.mapToToggles(collectInput["toggles"] as? [NSDictionary])
                        let input = try SelectionInputBuilder(title: title)
                            .setRequired(collectInput["required"] as? Bool ?? false)
                            .setStripeDescription(collectInput["description"] as? String ?? "")
                            .setSkipButtonText(collectInput["skipButtonText"] as? String ?? "")
                            .setSelectionButtons(selectionButtons)
                            .setToggles(toggles)
                            .build()
                        inputs.append(input)
                    } catch {
                        resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                        return
                    }
                    break
                case "signature":
                    do {
                        let toggles = try Mappers.mapToToggles(collectInput["toggles"] as? [NSDictionary])
                        let input = try SignatureInputBuilder(title: title)
                            .setRequired(collectInput["required"] as? Bool ?? false)
                            .setStripeDescription(collectInput["description"] as? String ?? "")
                            .setSkipButtonText(collectInput["skipButtonText"] as? String ?? "")
                            .setSubmitButtonText(collectInput["submitButtonText"] as? String ?? "")
                            .setToggles(toggles)
                            .build()
                        inputs.append(input)
                    } catch {
                        resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
                        return
                    }
                    break
                default: break
                }
            }
        }

        do {
            collectInputsParameters = try CollectInputsParametersBuilder(inputs: inputs).build()
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        DispatchQueue.main.async {
            self.collectInputsCancellable = Terminal.shared.collectInputs(collectInputsParameters) { collectInputResults, error in
                self.collectInputsCancellable = nil
                if let error = error as NSError? {
                    resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
                } else {
                    resolve(Mappers.mapFromCollectInputsResults(collectInputResults ?? []))
                }
            }
        }
    }

    @objc(cancelCollectInputs:rejecter:)
    func cancelCollectInputs(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        guard let cancelable = collectInputsCancellable else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.cancelFailedAlreadyCompleted, message: "collectInputsCancellable could not be canceled because the command has already been canceled or has completed."))
            return
        }
        cancelable.cancel() { error in
            if let error = error as NSError? {
                resolve(Errors.createErrorFromNSError(nsError: error, source: .native))
            }
            else {
                resolve([:])
            }
        }
    }

    @objc(getReaderSettings:rejecter:)
    func getReaderSettings(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        Task {
            do {
                let result = try await Terminal.shared.retrieveReaderSettings()
                resolve(Mappers.mapFromReaderSettings(result))
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    @objc(setReaderSettings:resolver:rejecter:)
    func setReaderSettings(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let readerSettingsParameters = Mappers.mapToReaderSettingsParameters(params)
        if case let .invalid(message) = readerSettingsParameters {
            resolve(Errors.createErrorFromRnCodeEnum(
                rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER,
                message: message
            ))
            return
        }
        if case let .nativeError(error) = readerSettingsParameters {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return
        }

        Task {
            do {
                let result: ReaderSettings
                switch readerSettingsParameters {
                case let .accessibility(parameters):
                    result = try await Terminal.shared.setReaderSettings(parameters)
                case let .buzzerVolume(parameters):
                    result = try await Terminal.shared.setReaderSettings(parameters)
                case .invalid, .nativeError:
                    return
                }
                resolve(Mappers.mapFromReaderSettings(result))
            } catch {
                resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            }
        }
    }

    @objc(supportsReadersOfType:resolver:rejecter:)
    func supportsReadersOfType(params: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        let invalidParams = Errors.validateRequiredParameters(params: params, requiredParams: ["deviceType", "discoveryMethod"])

        if let invalidParams {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide \(invalidParams) parameters."))
            return
        }

        let deviceTypeParam = params["deviceType"] as? String ?? ""
        let simulated = params["simulated"] as? Bool ?? false
        let discoveryMethod = params["discoveryMethod"] as? String
        let deviceType = Mappers.mapToDeviceType(deviceTypeParam)
        guard let deviceType else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide correct deviceType parameter."))
            return
        }
        let result = Terminal.shared.supportsReaders(of: deviceType, discoveryMethod: Mappers.mapToDiscoveryMethod(discoveryMethod), simulated: simulated)
        switch result {
        case .success(_):
            resolve(["readerSupportResult": true])
            break
        case .failure(let error):
            resolve([
                "readerSupportResult": false,
                "error": Errors.mapToStripeErrorObject(nsError: error as NSError, source: .native),
            ])
            break
        }
    }

    @objc(getNativeSdkVersion:rejecter:)
    func getNativeSdkVersion(resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        resolve(SCPSDKVersion)
    }

    func reader(_ reader: Reader, didReportAvailableUpdate update: ReaderSoftwareUpdate) {
        sendEvent(withName: ReactNativeConstants.REPORT_AVAILABLE_UPDATE.rawValue, body: ["result": Mappers.mapFromReaderSoftwareUpdate(update) ?? [:]])
    }

    func reader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) {
        self.installUpdateCancelable = cancelable
        sendEvent(withName: ReactNativeConstants.START_INSTALLING_UPDATE.rawValue, body: [
            "result": Mappers.mapFromReaderSoftwareUpdate(update) ?? [:],
            "reader": Mappers.mapFromReader(reader),
        ])
    }

    func reader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) {
        let result: [AnyHashable : Any?] = [
            "progress": progress,
        ]
        sendEvent(withName: ReactNativeConstants.REPORT_UPDATE_PROGRESS.rawValue, body: ["result": result])
    }

    func reader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) {
        self.installUpdateCancelable = nil
        var body: [String: Any] = [:]
        if let result = Mappers.mapFromReaderSoftwareUpdate(update) {
            body["result"] = result
        }
        if let nsError = error as NSError? {
            let errorAsDictionary = Errors.createErrorFromNSError(nsError: nsError, source: .native)
            body = body.merging(errorAsDictionary, uniquingKeysWith: { _, error in
                error
            })
        }
        sendEvent(withName: ReactNativeConstants.FINISH_INSTALLING_UPDATE.rawValue, body: body)
    }

    func reader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) {
        let result = Mappers.mapFromReaderInputOptions(inputOptions)
        sendEvent(withName: ReactNativeConstants.REQUEST_READER_INPUT.rawValue, body: ["result": result])
    }

    func reader(_ reader: Reader, didRequestReaderDisplayMessage displayMessage: ReaderDisplayMessage) {
        let result = Mappers.mapFromReaderDisplayMessage(displayMessage)
        sendEvent(withName: ReactNativeConstants.REQUEST_READER_DISPLAY_MESSAGE.rawValue, body: ["result": result])
    }

    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        let result = Mappers.mapFromReaderDisconnectReason(reason)
        sendEvent(withName: ReactNativeConstants.DISCONNECT.rawValue, body: ["reason": result])
    }

    func terminal(_ terminal: Terminal, didChange offlineStatus: OfflineStatus) {
        let result = Mappers.mapFromOfflineStatus(offlineStatus)
        sendEvent(withName: ReactNativeConstants.CHANGE_OFFLINE_STATUS.rawValue, body: ["result": result])
    }

    func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) {
        let result = Mappers.mapFromPaymentIntent(intent, uuid: "")
        var body: [String: Any] = ["result": result]

        if let nsError = error as NSError? {
           let errorAsDictionary = Errors.createErrorFromNSError(nsError: nsError, source: .native)
            // createError will return a dictionary of ["error": {the error}]
            // so merge that with the result so we have [result:, error:]
            body = body.merging(errorAsDictionary, uniquingKeysWith: { _, error in
                error
            })
        }

        sendEvent(withName: ReactNativeConstants.FORWARD_PAYMENT_INTENT.rawValue, body: body)
    }

    func terminal(_ terminal: Terminal, didReportForwardingError error: Error) {
        let result = Errors.createErrorFromNSError(nsError: error as NSError, source: .native)
        sendEvent(withName: ReactNativeConstants.REPORT_FORWARDING_ERROR.rawValue, body: ["result": result])
    }

    func reader(_ reader: Reader, didReportReaderEvent event: ReaderEvent, info: [AnyHashable : Any]?) {
        let result = Mappers.mapFromReaderEvent(event)
        sendEvent(withName: ReactNativeConstants.REPORT_READER_EVENT.rawValue, body: ["result": result])
    }

    func reader(_ reader: Reader, didReportBatteryLevel batteryLevel: Float, status: BatteryStatus, isCharging: Bool) {
        let result: NSDictionary = [
            "batteryLevel": batteryLevel,
            "batteryStatus": Mappers.mapFromBatteryStatus(status),
            "isCharging": isCharging,
        ]
        sendEvent(withName: ReactNativeConstants.UPDATE_BATTERY_LEVEL.rawValue, body: ["result": result])
    }

    func readerDidReportLowBatteryWarning(_ reader: Reader) {
        let result = "LOW BATTERY"
        sendEvent(withName: ReactNativeConstants.REPORT_LOW_BATTERY_WARNING.rawValue, body: ["result": result])
    }

    // MARK: - Payment Interaction Delegate

    /**
     * Called when a payment interaction requires app-provided UI.
     * Payment method selection defaults to card when no JS handler is registered.
     * QR code display fails when no JS handler is registered.
     * These handlers are registered by connectReader, so React reloads require
     * reconnecting to register them with the new JavaScript runtime.
     */
    func reader(_ reader: Reader, didRequestInteraction interaction: PaymentInteraction) {
        if let selection = interaction as? PaymentMethodSelectionInteraction {
            self.availablePaymentOptions = selection.availableOptions
            if self.paymentMethodSelectionHandlerRegistered {
                self.paymentMethodSelectionCallback = { paymentOption, error in
                    selection.complete(paymentOption: paymentOption, error: error)
                }
                sendEvent(withName: ReactNativeConstants.PAYMENT_METHOD_SELECTION_REQUIRED.rawValue, body: [
                    "paymentIntent": Mappers.mapFromPaymentIntent(selection.paymentIntent, uuid: ""),
                    "availablePaymentOptions": Mappers.mapFromPaymentOptions(selection.availableOptions)
                ])
                return
            }

            if let cardOption = selection.availableOptions.first(where: { $0.type == .card }) {
                selection.complete(paymentOption: cardOption, error: nil)
            } else if let firstOption = selection.availableOptions.first {
                selection.complete(paymentOption: firstOption, error: nil)
            } else {
                selection.complete(
                    paymentOption: nil,
                    error: NSError(
                        domain: "StripeTerminalReactNative",
                        code: 0,
                        userInfo: [NSLocalizedDescriptionKey: "No payment options available"]
                    )
                )
            }
            return
        }

        if let qrCode = interaction as? QrCodeDisplayInteraction {
            if self.qrCodeDisplayHandlerRegistered {
                self.qrCodeDisplayCallback = { error in
                    qrCode.complete(error: error)
                }
                sendEvent(withName: ReactNativeConstants.QR_CODE_DISPLAY_REQUIRED.rawValue, body: [
                    "paymentIntent": Mappers.mapFromPaymentIntent(qrCode.paymentIntent, uuid: ""),
                    "qrData": Mappers.mapFromQrCodeDisplayData(qrCode.qrData)
                ])
            } else {
                qrCode.complete(
                    error: NSError(
                        domain: "StripeTerminalReactNative",
                        code: 0,
                        userInfo: [NSLocalizedDescriptionKey: "QR code display requires implementing onQrCodeDisplayRequired callback"]
                    )
                )
            }
        }
    }

    // MARK: - MPOS Handler Registration Methods


    // MARK: - MPOS Callback Response Methods

    @objc(selectPaymentOption:resolver:rejecter:)
    func selectPaymentOption(
        paymentOptionType: String,
        resolver resolve: @escaping RCTPromiseResolveBlock,
        rejecter reject: @escaping RCTPromiseRejectBlock
    ) {
        guard let completion = self.paymentMethodSelectionCallback else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.canceled, message: "No payment method selection callback available"))
            return
        }
        self.paymentMethodSelectionCallback = nil

        // Find the payment option by type
        let paymentOption: PaymentOption?
        if paymentOptionType == "card" {
            paymentOption = self.availablePaymentOptions.first(where: { $0.type == .card })
        } else {
            // For non-card options, match by paymentMethodType
            let targetType = Mappers.mapToPaymentMethodType(paymentOptionType)
            paymentOption = self.availablePaymentOptions.first(where: {
                $0.type == .nonCard && $0.paymentMethodType == targetType
            })
        }

        guard let selectedOption = paymentOption else {
            completion(nil, NSError(domain: "StripeTerminal", code: -1, userInfo: [NSLocalizedDescriptionKey: "Payment option not found: \(paymentOptionType)"]))
            resolve(Errors.createErrorFromCode(code: ErrorCode.canceled, message: "Payment option not found: \(paymentOptionType)"))
            return
        }

        completion(selectedOption, nil)
        resolve([:])
    }

    @objc(failPaymentMethodSelection:resolver:rejecter:)
    func failPaymentMethodSelection(
        errorMessage: String?,
        resolver resolve: @escaping RCTPromiseResolveBlock,
        rejecter reject: @escaping RCTPromiseRejectBlock
    ) {
        guard let completion = self.paymentMethodSelectionCallback else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.canceled, message: "No payment method selection callback available"))
            return
        }
        self.paymentMethodSelectionCallback = nil

        // Mirror Android's TerminalErrorCode.CANCELED: use the real Terminal error domain
        // and a valid ErrorCode, so this isn't misclassified as UNEXPECTED_SDK_ERROR.
        let error = NSError(
            domain: ErrorConstants.stripeTerminalDomain,
            code: ErrorCode.canceled.rawValue,
            userInfo: [NSLocalizedDescriptionKey: errorMessage ?? "Payment method selection canceled"]
        )
        completion(nil, error)
        resolve([:])
    }

    @objc(confirmQrCodeDisplayed:rejecter:)
    func confirmQrCodeDisplayed(
        resolver resolve: @escaping RCTPromiseResolveBlock,
        rejecter reject: @escaping RCTPromiseRejectBlock
    ) {
        guard let completion = self.qrCodeDisplayCallback else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.canceled, message: "No QR code display callback available"))
            return
        }
        self.qrCodeDisplayCallback = nil

        completion(nil)  // nil error means success
        resolve([:])
    }

    @objc(failQrCodeDisplay:resolver:rejecter:)
    func failQrCodeDisplay(
        errorMessage: String?,
        resolver resolve: @escaping RCTPromiseResolveBlock,
        rejecter reject: @escaping RCTPromiseRejectBlock
    ) {
        guard let completion = self.qrCodeDisplayCallback else {
            resolve(Errors.createErrorFromCode(code: ErrorCode.canceled, message: "No QR code display callback available"))
            return
        }
        self.qrCodeDisplayCallback = nil

        // Mirror Android's TerminalErrorCode.CANCELED: use the real Terminal error domain
        // and a valid ErrorCode, so this isn't misclassified as UNEXPECTED_SDK_ERROR.
        let error = NSError(
            domain: ErrorConstants.stripeTerminalDomain,
            code: ErrorCode.canceled.rawValue,
            userInfo: [NSLocalizedDescriptionKey: errorMessage ?? "QR code display failed"]
        )
        completion(error)
        resolve([:])
    }

    // MARK: - Visible for Testing

    func clearAllIntentMaps() {
        self.paymentIntents = [:]
        self.setupIntents = [:]
    }

    func updatePaymentIntentFromError(_ error: NSError, uuid: String) {
        if let confirmError = error as? ConfirmPaymentIntentError, let updatedPI = confirmError.paymentIntent {
            self.paymentIntents[uuid] = updatedPI
        }
    }

    func updateSetupIntentFromError(_ error: NSError, uuid: String) {
        if let confirmError = error as? ConfirmSetupIntentError, let updatedSI = confirmError.setupIntent {
            self.setupIntents[uuid] = updatedSI
        }
    }

    private func getPaymentIntentAndUuid(from params: NSDictionary, resolve: @escaping RCTPromiseResolveBlock) -> (PaymentIntent, String)? {
        guard let paymentIntentJSON = params["paymentIntent"] as? NSDictionary else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide paymentIntent."))
            return nil
        }
        guard let uuid = paymentIntentJSON["sdkUuid"] as? String else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "The PaymentIntent is missing sdkUuid field. This method requires you to use the PaymentIntent that was returned from either createPaymentIntent or retrievePaymentIntent."))
            return nil
        }
        guard let paymentIntent = self.paymentIntents[uuid] else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "No PaymentIntent was found with the sdkUuid \(uuid). The PaymentIntent provided must be re-retrieved with retrievePaymentIntent or a new PaymentIntent must be created with createPaymentIntent."))
            return nil
        }
        return (paymentIntent, uuid)
    }

    private func getSetupIntentAndUuid(from params: NSDictionary, resolve: @escaping RCTPromiseResolveBlock) -> (SetupIntent, String)? {
        guard let setupIntentJson = params["setupIntent"] as? NSDictionary else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "You must provide setupIntent."))
            return nil
        }
        guard let uuid = setupIntentJson["sdkUuid"] as? String else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "The SetupIntent is missing sdkUuid field. This method requires you to use the SetupIntent that was returned from either createSetupIntent or retrieveSetupIntent."))
            return nil
        }
        guard let setupIntent = self.setupIntents[uuid] else {
            resolve(Errors.createErrorFromRnCodeEnum(rnCode: Errors.RNErrorCode.INVALID_REQUIRED_PARAMETER, message: "No SetupIntent was found with the sdkUuid \(uuid). The SetupIntent provided must be re-retrieved with retrieveSetupIntent or a new SetupIntent must be created with createSetupIntent."))
            return nil
        }
        return (setupIntent, uuid)
    }

    private func busyMessage(command: String, by busyBy: String) -> String {
        return "Could not execute \(command) because the SDK is busy with another command: \(busyBy)."
    }

    private func buildCollectPaymentIntentConfiguration(from params: NSDictionary, resolve: @escaping RCTPromiseResolveBlock) -> CollectPaymentIntentConfiguration? {
        do {
            return try Mappers.buildCollectPaymentIntentConfiguration(from: params)
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return nil
        }
    }

    private func buildConfirmPaymentIntentConfiguration(from params: NSDictionary, resolve: @escaping RCTPromiseResolveBlock) -> ConfirmPaymentIntentConfiguration? {
        do {
            return try Mappers.buildConfirmPaymentIntentConfiguration(from: params)
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return nil
        }
    }

    private func buildCollectSetupIntentConfiguration(from params: NSDictionary, resolve: @escaping RCTPromiseResolveBlock) -> CollectSetupIntentConfiguration? {
        do {
            return try Mappers.buildCollectSetupIntentConfiguration(from: params)
        } catch {
            resolve(Errors.createErrorFromNSError(nsError: error as NSError, source: .native))
            return nil
        }
    }
}
