NSSet *events = [NSSet setWithObjects: ECPSdkEventConstants.ECPDeviceConfigStatusEvent, ECPSdkEventConstants.ECPDeviceConfigProgressEvent, ECPSdkEventConstants.ECPConnectionChangedEvent, ECPSdkEventConstants.ECPDeviceMessageEvent,
                                 ECPSdkEventConstants.ECPDeviceCardEvent, ECPSdkEventConstants.ECPDeviceBatteryEvent, nil];

@property (nonatomic, copy) void (^userClientTokenBlock)(void (^completionHandler)(NSString *clientToken, NSError *error));

self.userClientTokenBlock = ^(void (^completionHandler)(NSString *clientToken, NSError *error)) {
        NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
        NSURLSession *session = [NSURLSession sessionWithConfiguration:config];
        
  			// When using Client Token Authorization strategy, your backend server should be using 
  			// https://api.paysimple.com/ps/auth/reseller_client_token endpoint to help generate
  			// the token. See https://documentation.paysimple.com/v2019/docs/authorization#client-token-authorization-rarely-used
        NSURL *url =  [ NSURL URLWithString:@"{CALL TO YOUR BACKEND URL FOR RESELLER AUTH ENDPOINT}"];
        
        NSMutableURLRequest *sampleRequest = [[NSMutableURLRequest alloc]initWithURL:url];
        
        sampleRequest.HTTPMethod = @"GET";
        
       // Make sure to add any authorization headers or any other authentication needed for your server prior to sending request
        
        NSURLSessionDataTask *task = [session dataTaskWithRequest:sampleRequest 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.test-app-ios.test"
                                                     code:1000
                                                 userInfo:@{NSLocalizedDescriptionKey: @"No data in response from API endpoint"}];
                completionHandler(nil, error);
                return;
            }
            if (!(jsonObject && [jsonObject isKindOfClass:[NSDictionary class]])) {
                completionHandler(nil, jsonSerializationError);
                return;
            }
            NSDictionary *json = (NSDictionary *)jsonObject;
            id token = json[@"token"];
            if (!(token && [token isKindOfClass:[NSString class]])) {
                NSError *error = [NSError errorWithDomain:@"com.test-app-ios.test"
                                                     code:2000
                                                 userInfo:@{NSLocalizedDescriptionKey: @"Missing `token` in JSON response"}];
                completionHandler(nil, error);
                return;
            }
            completionHandler((NSString *)token, nil);
        }];
        [task resume];
    };

               [self.sharedECPSdk initializeSdk:env
									subscribedEvents:events
                  clientTokenBlock:self.userClientTokenBlock
                  completionHandler:^(BOOL isSdkInitialized, NSError *error) {}

+ (ECPSdk *)sharedInstance;

@property (nonatomic, strong) ECPSdk *sharedECPSdk;

@implementation HomePageViewController


- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    self.sharedECPSdk = [ECPSdk sharedInstance];
}

// later on in another method, use this shared instance
- (void) callInitialized {

NSString *env = @"PROD";
self.userClientTokenBlock = [self codeToDefineAndSetUserClientTokenBlock];

NSSet *events = [NSSet setWithObjects: ECPSdkEventConstants.ECPDeviceConfigStatusEvent, ECPSdkEventConstants.ECPDeviceConfigProgressEvent, ECPSdkEventConstants.ECPConnectionChangedEvent, ECPSdkEventConstants.ECPDeviceMessageEvent,
                                 ECPSdkEventConstants.ECPDeviceCardEvent, ECPSdkEventConstants.ECPDeviceBatteryEvent, nil];


[self.sharedECPSdk initializeSdk:env
									 subscribedEvents:events
                    clientTokenBlock:self.userClientTokenBlock
                    completionHandler:^(BOOL isSdkInitialized, NSError *error) {
                          if(!isSdkInitialized {
                          //  SDK failed to initialize and report on error
                          } else {
                          // SDK is now officially initialized
                          }];.

}

- (void) initializeSdk:(NSString *)environment
                subscribedEvents:(NSSet *)events
                clientTokenBlock:(void (^)(void (^)(NSString *clientToken, NSError *error)))fetchClientTokenBlock
                completionHandler:(void(^)(BOOL isSdkInitialized, NSError *error))handler;

@interface HomePageViewController()
@property (nonatomic, copy) void (^userClientTokenBlock)(void (^completionHandler)(NSString *clientToken, NSError *error));                

@implementation HomePageViewController()

// class methods here.....

(void)method1 {
 // ...
}

(void)method2 {
  // ...
}

(void) initializeECPSdk {
  
NSString *env = @"PROD";
self.userClientTokenBlock = [self methodToDefineAndSetUserClientTokenBlock];

NSSet *events = [NSSet setWithObjects: ECPSdkEventConstants.ECPDeviceConfigStatusEvent, ECPSdkEventConstants.ECPDeviceConfigProgressEvent, ECPSdkEventConstants.ECPConnectionChangedEvent, ECPSdkEventConstants.ECPDeviceMessageEvent,
                                 ECPSdkEventConstants.ECPDeviceCardEvent, ECPSdkEventConstants.ECPDeviceBatteryEvent, nil];

[self.sharedECPSdk initializeSdk:env
									 subscribedEvents:events
                    clientTokenBlock:self.userClientTokenBlock
                    completionHandler:^(BOOL isSdkInitialized, NSError *error) {
                          if(!isSdkInitialized) {
                          //  SDK failed to initialize and report on error
                          } else {
                          // SDK is now officially initialized
                          }];
                             
 }

- (BOOL)isInitialized

// somewhere in your class you have stored the sdk, accessing it via sharedECPSdk variable

if([self.sharedECPSdk isInitialized] {
	// follow up logic here
}

- (void) resetSdk:(void(^)(BOOL isSdkReset, NSError *error))handler

    [self.sharedECPSdk resetSdk:^(BOOL isSdkReset, NSError *error) {
        if(isSdkReset) {
	  	// SDK successfully reset, follow up code here
        }
        } else {
      // SDK not reset, follow up code here
        }
    }];

- (void) discoverDevices:(NSUInteger)scanTime completionHandler:(void(^)(NSArray<ECPDevice *> *, NSError *error))handler

    [self.sharedECPSdk discoverDevices:5 completionHandler:^(NSArray<ECPDevice *> *devices, NSError *error) {
        if ( devices.count > 0){
           // devices found. If you would like, you can continue and handle connection logic
          //  within here. Device info can be accessed on the devices array
        }
        else{
           // Handle error or no devices found here
        }
    }];

- (void) connectDevice:(ECPDevice *)device
        connectTimeout:(NSUInteger)timeout
completionHandler:(void(^)(BOOL isDeviceConnected, ECPDevice* device, NSError *error))handler

    [self.sharedECPSdk discoverDevices:5 completionHandler:^(NSArray<ECPDevice *> *devices, NSError *error) {
        if ( devices.count > 0){
          // could use some sort of logic to determine which device to connect to.
          // for simplicity, here is an example selecting the first device that was
          // populated in the devices NSArray.
           ECPDevice * device = devices[0];
            [self.sharedECPSdk connectDevice:device connectTimeout:10 completionHandler:^(BOOL isDeviceConnected, ECPDevice *device, NSError *error) {
                    if (isDeviceConnected){
             	       // logic after device connected
                    }
                    else{
                     // logic after failed device connect
                    }
                }];
        }
        else{
           // Handle error or no devices found here
        }
    }];

    [self.sharedECPSdk disconnectDevice:^(BOOL didDisconnect, NSError *error) {
        if(didDisconnect) {
				// device disconnected, perform disconnect logic
        } else {
				// disconnect failed, perform error handling logic for this scenario 
        }
    }];

- (void) makeSale:(ECPPaymentParameters*) parameters completionHandler:(void(^)(ECPSaleResponse *saleResponse, NSError *error))handler

ECPPaymentParameters* params = [[ECPPaymentParameters alloc]initWithAmount:amount];
    [params setPaymentDescription:@"test stmt descript"];
    [params setPaymentDescriptionSuffix:@"test suffix"];
    
    NSString *externalId = self.ExternalIdTextBox.text;
    [params setExternalId:externalId];
        
    [self.sharedECPSDK makeSale:params completionHandler:^(ECPSaleResponse *saleResponse, NSError *error) {
      if ([saleResponse.outcome.result isEqual: @"success"]){
            dispatch_async(dispatch_get_main_queue(), ^{
                [self.NotificationsLabel setText:@"payment succeeded"];
                NSLog(@"success");
                
            });
        }
        else{
            dispatch_async(dispatch_get_main_queue(), ^{
                [self.NotificationsLabel setText:@"payment declined/failed"];
                NSLog(@"payment failed: %@", error);
             
            });
        }
    }];

- (IBAction)cancelPaymentButtonPressed:(id)sender
{
    [self.sharedECPSDK stopCurrentFlow:^(BOOL didCancel, NSError *error) {
        if (didCancel)
        {
            dispatch_async(dispatch_get_main_queue(), ^{
                [self.NotificationsLabel setText:@"payment cancelled successfully."];             
            });
        }
        else
        {
            dispatch_async(dispatch_get_main_queue(), ^{
                [self.NotificationsLabel setText:@"payment could not be cancelled."];
                NSLog(@"error cancelling payment: %@", error);
            });
        }
    }];
}

    [self.sharedECPSdk getDeviceInfo:^(BOOL isDeviceConnected, ECPDevice *device, NSError *error) {
            if(isDeviceConnected && device) {
               // Display device information using a UI label of your choosing.
               // you can access device properties on the device object. See example below:
                dispatch_async(dispatch_get_main_queue(), ^{
                    NSString *deviceInfo = [NSString stringWithFormat:@"GetDeviceInfo - id:%@, manufacturer:%@, model:%@, battery:%@, isDeviceConnected:%d", device.id_number, device.manufacturer, device.model, device.battery_percentage, isDeviceConnected];
                    [self.NotificationsLabel setText:deviceInfo];
                });
            } else {
                dispatch_async(dispatch_get_main_queue(), ^{
                    NSString *errorMessage = [NSString stringWithFormat:@"GetDeviceInfoError - %@", error.localizedFailureReason];
                    [self.NotificationsLabel setText:errorMessage];
                });
            }
        }];

	#import <UIKit/UIKit.h>
	#import <EverCommercePaymentsIosSdk/EverCommercePaymentsIosSdk.h>
	@interface HomePageViewController : UIViewController<ECPSdkDelegate>
  // continue class definition below ...

	-(void)onDeviceEvent:(ECPSdkEvent *)event {
}

self.sharedECPSdk.delegate = self; 

-(void)onDeviceEvent:(ECPSdkEvent *)event

-(void)onDeviceEvent:(ECPSdkEvent *)event {
    __weak typeof(self) weakSelf = self;
    __strong typeof(self) strongSelf = weakSelf;
    if([event isKindOfClass:[ECPDeviceConfigStatusEvent class]]) {
        ECPDeviceConfigStatusEvent *statusEvent = (ECPDeviceConfigStatusEvent*)event;
        if(statusEvent.error) {
            NSString *error = [NSString stringWithFormat:@"Logging error: %@", [statusEvent.error localizedDescription]];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.DelegatesLabel setText:error];
            });
        } else {
            NSString *configStatus = [NSString stringWithFormat:@"Reporting config event enum: %lu", (unsigned long)statusEvent.event_status];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.DelegatesLabel setText:configStatus];
            });
        }
    } else if([event isKindOfClass:[ECPDeviceConfigProgressEvent class]]) {
        ECPDeviceConfigProgressEvent *progressEvent = (ECPDeviceConfigProgressEvent*)event;
        NSString *configProgress = [NSString stringWithFormat:@"Reporting config progress event %f", progressEvent.progress];
        dispatch_async(dispatch_get_main_queue(), ^{
            [strongSelf.DelegatesLabel setText:configProgress];
        });
    } else if([event isKindOfClass:[ECPConnectionChangedEvent class]]) {
        ECPConnectionChangedEvent *connectionEvent = (ECPConnectionChangedEvent*)event;
        switch(connectionEvent.connection_status) {
            case ECP_CONNECTION_STATUS_CONNECTED: {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [strongSelf.DelegatesLabel setText:@"ConnectionChangedEvent - CONNECTED!"];
                });
                break;
            }
            case ECP_CONNECTION_STATUS_CONNECTING: {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [strongSelf.DelegatesLabel setText:@"ConnectionChangedEvent - CONNECTING!"];
                });
                break;
            }
            case ECP_CONNECTION_STATUS_NOT_CONNECTED: {
                dispatch_async(dispatch_get_main_queue(), ^{
                    [strongSelf.DelegatesLabel setText:@"ConnectionChangedEvent - NOT_CONNECTED!"];
                });
                break;
            }
            default:
                break;
        }
    } else if([event isKindOfClass:[ECPDeviceBatteryEvent class]]) {
        ECPDeviceBatteryEvent *batteryEvent = (ECPDeviceBatteryEvent*)event;
        NSMutableString *batteryInfo;
        if(batteryEvent.battery_status == ECP_BATTERY_EVENT_LOW) {
            batteryInfo = [NSMutableString stringWithString:@"DeviceBatteryEvent - Low"];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.DelegatesLabel setText:batteryInfo];
            });
        }
    }  else if([event isKindOfClass:[ECPDeviceMessageEvent class]]) {
        ECPDeviceMessageEvent *promptEvent = (ECPDeviceMessageEvent*)event;
        if ([promptEvent.inputMessage length] != 0)
        {
            NSString *message = [NSString stringWithFormat:@"Display: %@", promptEvent.inputMessage];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.InputMessage setText:message];
            });
        }
        
        if ([promptEvent.promptMessage length] != 0)
        {
            NSString *message = [NSString stringWithFormat:@"Display: %@", promptEvent.promptMessage];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.delegatesLabel setText:message];
            });
        }
    } else if([event isKindOfClass:[ECPDeviceCardEvent class]]) {
        ECPDeviceCardEvent *deviceCardEvent = (ECPDeviceCardEvent*)event;
        NSMutableString *message;
        if(deviceCardEvent.event_status == ECP_CARD_EVENT_REMOVED) {
            message =  [NSMutableString stringWithString:@"DeviceCardEvent - REMOVED"];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.cardDelegateLabel setText:message];
            });
        }else if(deviceCardEvent.event_status == ECP_CARD_EVENT_INSERTED) {
            message = [NSMutableString stringWithString:@"DeviceCardEvent - INSERTED"];
            dispatch_async(dispatch_get_main_queue(), ^{
                [strongSelf.cardDelegateLabel setText:message];
            });
        }
    }
}