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: false)
        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]) {
        // In your app, display the discovered reader(s) to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }
}

#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 {
    // In your app, display the discovered reader(s) to the user.
    // Call `connectReader` after the user selects a reader to connect to.
}

@end

public void onDiscoverReaders() {
  DiscoveryConfiguration config = new DiscoveryConfiguration(0, DeviceType.CHIPPER_2X, false);
  Terminal.getInstance().discoverReaders(config, readers -> {
    // Display the discovered readers to the user
  }, new Callback() {
    @Override
    public void onSuccess() {
      System.out.println("Finished discovering readers");
    }

    @Override
    public void onFailure(TerminalException e) {
      e.printStackTrace();
    }
  }
}

fun onDiscoverReaders() {
  var config = DiscoveryConfiguration(0, DeviceType.CHIPPER_2X, false)
  Terminal.getInstance().discoverReaders(config, { readers: List<Reader> ->
      // Display the discovered readers to the user
  }, object : Callback {
    override fun onSuccess() {
      System.out.println("Finished discovering readers")
    }

    override fun onFailure(e: TerminalException) {
      e.printStackTrace()
    }
  })
}

// 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)")
    }
})

// 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);
    }
}];

// after selecting a reader to connect to
Terminal.getInstance().connectReader(firstReader, new ReaderCallback() {
  @Override
  public void onSuccess(Reader r) {
    System.out.println("Connected to reader");
  }

  @Override
  public void onFailure(@Nonnull TerminalException e) {
    e.printStackTrace();
  }
});

// after selecting a reader to connect to
Terminal.getInstance().connectReader(firstReader, object : ReaderCallback {
    override fun onSuccess(r: Reader?) {
        System.out.println("Connected to reader")
    }

    override fun onFailure(e: TerminalException) {
        e.printStackTrace()
    }
})

override func viewDidLoad() {
    super.viewDidLoad()
    Terminal.shared.delegate = self
}

// ...

// MARK: TerminalDelegate

func terminal(_ terminal: Terminal, didReportUnexpectedReaderDisconnect reader: Reader) {
    print("Disconnected from reader: \(reader)")
}

- (void)viewDidLoad {
    [super viewDidLoad];
    [SCPTerminal shared].delegate = self;
}

// ...

#pragma mark – SCPTerminalDelegate

- (void)terminal:(SCPTerminal *)terminal didReportUnexpectedReaderDisconnect:(SCPReader *)reader {
    NSLog(@"Disconnected from reader: %@", reader);
}

// Note: TokenProvider is a class defined by your app implementing the ConnectionTokenProvider interface
Terminal.initTerminal(applicationContext, LogLevel.VERBOSE, new TokenProvider(), new TerminalListener() {
  @Override
  public void onUnexpectedReaderDisconnect(Reader reader) {
    System.out.println("Disconnected from reader");
  }
})

// Note: TokenProvider is a class defined by your app implementing the ConnectionTokenProvider interface
Terminal.initTerminal(appliactionContext, LogLevel.VERBOSE, TokenProvider(), object: TerminalListener {
  override fun onUnexpectedReaderDisconnect(reader: Reader) {
    System.out.println("Disconnected from reader")
  }
})