import TerminalC2C

// Create payment data
let payment = Payment(
  orderID: "ORDER_123",
  amount: 10000.0,
  paymentMethod: BRIPaymentMethod.contactless
)

// Execute payment
Task {
  do {
    let result = try await TerminalC2C.shared.createPayment(payment: payment)
    print("Payment successful: \(result.status)")
  } catch let error as TerminalException {
    print("Payment failed: \(error.message)")
  } catch {
    print("Error: \(error.localizedDescription)")
  }
}

import TerminalC2C

// Optional: enable simulation globally
TerminalC2C.shared.isSimulation = true

// Or pass the flag per request when creating a payment
Task {
  do {
    let result = try await TerminalC2C.shared.createPayment(
      payment: payment,
      isSimulation: true
    )
    print("Simulated payment: \(result.status)")
  } catch {
    print("Simulation failed: \(error.localizedDescription)")
  }
}

import TerminalC2C

// Create cancel data
let cancel = Cancel(
  paymentMethod: BRIPaymentMethod.contactless, // Optional
  terminalReference: "123456" // Reference from previous transaction
)

Task {
  do {
    let result = try await TerminalC2C.shared.cancelPayment(cancel: cancel)
    print("Cancellation successful: \(result.status)")
  } catch let error as TerminalException {
    print("Cancellation failed: \(error.message)")
  }
}

import TerminalC2C

// Create receipt data
let receipt = Receipt(
  paymentMethod: BRIPaymentMethod.contactless, // Optional
  terminalReference: "123456" // Reference from previous transaction
)

Task {
  do {
    let result = try await TerminalC2C.shared.printReceipt(receipt: receipt)
    print("Receipt print command sent: \(result.status)")
  } catch let error as TerminalException {
    print("Receipt print failed: \(error.message)")
  }
}

import TerminalC2C

// Create settlement data
let settlement = Settlement(
  paymentMethod: BRIPaymentMethod.contactless // Optional: pass nil for all payment methods
)

Task {
  do {
    let result = try await TerminalC2C.shared.performSettlement(settlement: settlement)
    print("Settlement successful: \(result.status)")
  } catch let error as TerminalException {
    print("Settlement failed: \(error.message)")
  }
}

import TerminalC2C

// Create histories data with optional filters
let histories = Histories(
  commands: [CommandType.pay, CommandType.cancel], // Optional: filter by command types
  statuses: [Status.success], // Optional: filter by statuses
  from: "2024-01-01T00:00:00Z", // Optional: ISO 8601 format start date
  to: "2024-01-31T23:59:59Z" // Optional: ISO 8601 format end date
)

Task {
  do {
    let history = try await TerminalC2C.shared.getHistory(histories: histories)
    print("Retrieved history: \(history)")
    
    for transaction in history.transactions {
      print("Transaction: \(transaction.status)")
    }
  } catch let error as TerminalException {
    print("Failed to retrieve history: \(error.message)")
  }
}

import TerminalC2C

let payment = Payment(
  orderID: "ORDER_123",
  amount: 10000.0,
  paymentMethod: BRIPaymentMethod.contactless
)

let job = TerminalC2C.shared.createPaymentAsync(payment: payment) { value, error in
  if let result = value {
    print("Payment successful: \(result.status)")
  } else if let error = error {
    if let terminalError = error as? TerminalException {
      print("Terminal error: \(terminalError.message)")
    } else {
      print("Error: \(error.localizedDescription)")
    }
  }
}

// Cancel the coroutine if the user backs out of the flow
job.cancel()

import TerminalC2C

let cancel = Cancel(
  paymentMethod: BRIPaymentMethod.contactless,
  terminalReference: "123456"
)

let cancelJob = TerminalC2C.shared.cancelPaymentAsync(cancel: cancel) { value, error in
  if let result = value {
    print("Cancellation successful: \(result.status)")
  } else if let error = error {
    print("Cancellation failed: \(error.localizedDescription)")
  }
}

// Cancel when the request is no longer needed
cancelJob.cancel()

import TerminalC2C

let receipt = Receipt(
  paymentMethod: BRIPaymentMethod.contactless,
  terminalReference: "123456"
)

let receiptJob = TerminalC2C.shared.printReceiptAsync(receipt: receipt) { value, error in
  if let result = value {
    print("Receipt print command sent: \(result.status)")
  } else if let error = error {
    print("Receipt print failed: \(error.localizedDescription)")
  }
}

// Optionally cancel if the user exits the receipt screen
receiptJob.cancel()

import TerminalC2C

let settlement = Settlement(
  paymentMethod: BRIPaymentMethod.contactless
)

let settlementJob = TerminalC2C.shared.performSettlementAsync(settlement: settlement) { value, error in
  if let result = value {
    print("Settlement successful: \(result.status)")
  } else if let error = error {
    print("Settlement failed: \(error.localizedDescription)")
  }
}

// Cancel if the settlement action is no longer required
settlementJob.cancel()

import TerminalC2C

let histories = Histories(
  commands: [CommandType.pay, CommandType.cancel],
  statuses: [Status.success],
  from: "2024-01-01T00:00:00Z",
  to: "2024-01-31T23:59:59Z"
)

let historyJob = TerminalC2C.shared.getHistoryAsync(histories: histories) { value, error in
  if let historyResult = value {
    print("Retrieved history: \(historyResult)")
    for transaction in historyResult.transactions {
      print("Transaction: \(transaction.status)")
    }
  } else if let error = error {
    print("Failed to retrieve history: \(error.localizedDescription)")
  }
}

// Cancel the history request if you no longer need updates
historyJob.cancel()

import TerminalC2C

let payment = Payment(
  orderID: "ORDER_123",
  amount: 10000.0,
  paymentMethod: BRIPaymentMethod.contactless
)

do {
  let result = try await TerminalC2C.shared.createPayment(payment: payment)
} catch let error as TerminalException {
  let apiError = error.error
  switch apiError.code {
  case "FAILED_TO_CONNECT":
    print("Cannot connect to Terminal Gateway")
  case "AUTHENTICATION_FAILED":
    print("Authentication failed")
  case "TERMINAL_BUSY":
    print("Terminal is busy")
  default:
    print("Error: \(apiError.message)")
  }
} catch {
  print("Unexpected error: \(error.localizedDescription)")
}

### Error Structure

```swift
struct TerminalException: Error {
  let httpStatus: Int
  let error: ApiError
}

struct ApiError {
  let code: String
  let message: String
}

func processPaymentSafely(orderID: String, amount: Double) async throws -> TerminalResult {
  let payment = Payment(
    orderID: orderID,
    amount: amount,
    paymentMethod: BRIPaymentMethod.contactless
  )
    
  do {
    return try await TerminalC2C.shared.createPayment(payment: payment)
  } catch let error as TerminalException {
    let apiError = error.error
    switch apiError.code {
    case "TERMINAL_BUSY":
      // Retry after delay
      try await Task.sleep(nanoseconds: 5_000_000_000) // 5 seconds
      return try await processPaymentSafely(orderID: orderID, amount: amount)
    case "FAILED_TO_CONNECT":
      // Check connectivity and retry
      throw error
    default:
      throw error
    }
  }
}

### Task Management

Properly manage async tasks:

```swift
class PaymentViewController: UIViewController {
  private var paymentTask: Task<Void, Never>?
  
  func processPayment() {
    let payment = Payment(
      orderID: "ORDER_123",
      amount: 10000.0,
      paymentMethod: BRIPaymentMethod.contactless
    )
    
    paymentTask = Task {
      do {
        let result = try await TerminalC2C.shared.createPayment(payment: payment)
        await MainActor.run {
          // Update UI on main thread
          self.updateUI(with: result)
        }
      } catch {
        await MainActor.run {
          // Handle error on main thread
          self.showError(error)
        }
      }
    }
  }
  
  deinit {
    paymentTask?.cancel()
  }
}

class TerminalManager {
  private var devices: [String: TerminalDevice] = [:]
  
  func registerDevice(id: String, ip: String, provider: String) {
    // Using generic create method
    devices[id] = TerminalDevice.companion.create(id: id, ipAddress: ip, provider: provider)
    
    // Or using provider-specific method
    // devices[id] = TerminalDevice.companion.bri(id: id, ipAddress: ip)
    // devices[id] = TerminalDevice.companion.cashup(id: id, ipAddress: ip)
    // devices[id] = TerminalDevice.companion.ntt(id: id, ipAddress: ip)
  }
  
  func processPaymentOnDevice(deviceId: String, orderID: String, amount: Double) async throws -> TerminalResult {
    guard let device = devices[deviceId] else {
      throw NSError(domain: "TerminalManager", code: -1, userInfo: [NSLocalizedDescriptionKey: "Device not found"])
    }
    
    let payment = Payment(
      orderID: orderID,
      amount: amount,
      paymentMethod: BRIPaymentMethod.contactless
    )
    
    // Set device and make payment
    TerminalC2C.shared.setTerminalDevice(device)
    return try await TerminalC2C.shared.createPayment(payment: payment)
  }
}