import StripeTerminal

// Example API client class for communicating with your backend
class APIClient: ConnectionTokenProvider {

    // For simplicity, this example class is a singleton
    static let shared = APIClient()

    // Fetches a ConnectionToken from your backend
    func fetchConnectionToken(_ completion: @escaping ConnectionTokenCompletionBlock) {
        let config = URLSessionConfiguration.default
        let session = URLSession(configuration: config)
        guard let url = URL(string: "https://{YOUR BACKEND URL}/connection_token") else {
            fatalError("Invalid backend URL")
        }
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        let task = session.dataTask(with: request) { (data, response, error) in
            if let data = data {
                do {
                    // Warning: casting using `as? [String: String]` looks simpler, but isn't safe:
                    let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
                    if let secret = json?["secret"] as? String {
                        completion(secret, nil)
                    }
                    else {
                        let error = NSError(domain: "com.stripe-terminal-ios.example",
                                            code: 2000,
                                            userInfo: [NSLocalizedDescriptionKey: "Missing `secret` in ConnectionToken JSON response"])
                        completion(nil, error)
                    }
                }
                catch {
                    completion(nil, error)
                }
            }
            else {
                let error = NSError(domain: "com.stripe-terminal-ios.example",
                                    code: 1000,
                                    userInfo: [NSLocalizedDescriptionKey: "No data in response from ConnectionToken endpoint"])
                completion(nil, error)
            }
        }
        task.resume()
    }
}

#import <StripeTerminal/StripeTerminal.h>

// Example API client class for communicating with your backend
@interface APPAPIClient : NSObject <SCPConnectionTokenProvider>

// For simplicity, this example class is a singleton
+ (instancetype)shared;

@end

#import "APPAPIClient.h"

@implementation APPAPIClient

+ (instancetype)shared {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _shared = [APPAPIClient new];
    });
    return _shared;
}

// Fetches a ConnectionToken from your backend
- (void)fetchConnectionToken:(SCPConnectionTokenCompletionBlock)completion {
    NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
    NSURLSession *session = [NSURLSession sessionWithConfiguration:config];
    NSURL *url = [NSURL URLWithString:@"https://{YOUR BACKEND URL}/connection-token"];
    if (!url) {
        NSAssert(NO, @"Invalid backend URL");
    }
    NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url];
    request.HTTPMethod = @"POST";
    NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
        id jsonObject = nil;
        NSError *jsonSerializationError;
        if (data) {
            jsonObject = [NSJSONSerialization JSONObjectWithData:data options:(NSJSONReadingOptions)kNilOptions error:&jsonSerializationError];
        }
        else {
            NSError *error = [NSError errorWithDomain:@"com.stripe-terminal-ios.example"
                                                 code:1000
                                             userInfo:@{NSLocalizedDescriptionKey: @"No data in response from ConnectionToken endpoint"}];
            completion(nil, error);
        }
        if (!(jsonObject && [jsonObject isKindOfClass:[NSDictionary class]])) {
            completion(nil, jsonSerializationError);
            return;
        }
        NSDictionary *json = (NSDictionary *)jsonObject;
        id secret = json[@"secret"];
        if (!(secret && [secret isKindOfClass:[NSString class]])) {
            NSError *error = [NSError errorWithDomain:@"com.stripe-terminal-ios.example"
                                                 code:2000
                                             userInfo:@{NSLocalizedDescriptionKey: @"Missing `secret` in ConnectionToken JSON response"}];
            completion(nil, error);
            return;
        }
        completion((NSString *)secret, nil);
    }];
    [task resume];
}

// ...

@end

import UIKit
import StripeTerminal

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        Terminal.setTokenProvider(APIClient.shared)
        // ...
        return true
    }

    // ...

}

#import "APPAppDelegate.h"
#import <StripeTerminal/StripeTerminal.h>
#import "APPAPIClient.h"

@implementation APPAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [SCPTerminal setTokenProvider:[APPAPIClient shared]];
    // ...
    return YES;
}

// ...

@end

import UIKit
import StripeTerminal

class ReaderViewController: UIViewController, DiscoveryDelegate, TerminalDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Connect Reader" button
    func connectReaderAction() {
        let config = DiscoveryConfiguration(deviceType: .chipper2X,
                                            discoveryMethod: .bluetoothProximity,
                                            simulated: true)
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self, completion: { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            }
            else {
                print("discoverReaders succeeded")
            }
        })
    }

    // ...

    // MARK: DiscoveryDelegate

    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
        // Just select the first reader in this example.
        guard let selectedReader = readers.first else { return }
        // Only connect if we aren't currently connected.
        guard terminal.connectionStatus == .notConnected else { return }

        // In your app, display the discovered reader(s) to the user.
        // Call `connectReader` with the selected reader.
        Terminal.shared.connectReader(selectedReader, completion: { reader, error in
            if let reader = reader {
                print("Successfully connected to reader: \(reader)")
            }
            else if let error = error {
                print("connectReader failed: \(error)")
            }
        })
    }
}

#import "APPReaderViewController.h"
#import <StripeTerminal/StripeTerminal.h>

@interface APPReaderViewController () <SCPDiscoveryDelegate, SCPTerminalDelegate>

@property (nonatomic, nullable, strong) SCPCancelable *discoverCancelable;

// ...

@end

@implementation APPReaderViewController

// Action for a "Connect Reader" button
- (void)connectReaderAction {
    SCPDiscoveryConfiguration *config = [[SCPDiscoveryConfiguration alloc] initWithDeviceType:SCPDeviceTypeChipper2X
                                                                              discoveryMethod:SCPDiscoveryMethodBluetoothProximity
                                                                                    simulated:YES];
    self.discoverCancelable = [[SCPTerminal shared] discoverReaders:config delegate:self completion:^(NSError *error) {
        if (error != nil) {
            NSLog(@"discoverReaders failed: %@", error);
        }
        else {
            NSLog(@"discoverReaders succeeded");
        }
    }];
}

// ...

#pragma mark - SCPDiscoveryDelegate

- (void)terminal:(SCPTerminal *)terminal didUpdateDiscoveredReaders:(NSArray<SCPReader *> *)readers {
    // Just select the first reader in this example
    SCPReader *selectedReader = [readers firstObject];
    // Only connect if we aren't currently connected.
    if (terminal.connectionStatus != SCPConnectionStatusNotConnected) {
        return;
    }

    // In your app, display the discovered reader(s) to the user.
    // Call `connectReader` with the selected reader.
    [[SCPTerminal shared] connectReader:selectedReader completion:^(SCPReader *reader, NSError *error) {
        if (reader != nil) {
            NSLog(@"Successfully connected to reader: %@", reader);
        }
        else {
            NSLog(@"connectReader failed: %@", error);
        }
    }];
}