import com.evercommerceandroid.evercommercepaymentsandroidsdk.clienttoken.ClientTokenProvider;
import com.evercommerceandroid.evercommercepaymentsandroidsdk.clienttoken.ClientTokenProviderCallback;
import com.evercommerceandroid.evercommercepaymentsandroidsdk.models.ECPSdkCallbackError;
// any other needed imports


public class TokenService implements ClientTokenProvider {


    public TokenService() {
    }
    @Override
    public void getClientToken(ClientTokenProviderCallback callback) {

        try {
            ClientTokenManager clientTokenManager = new ClientTokenManager();
            clientTokenManager.getAndOutputToken(new TokenManager.TokenResponseListener() {
                @Override
                public void onError(Error error) {
                    callback.onComplete(null, new ECPSdkCallbackError("Failed to fetch client token in TokenService"));
                }

                @Override
                public void onResponse(String token) {
                    callback.onComplete(token, null);
                }
            });

        }catch (Exception e) {
            callback.onComplete(null, new ECPSdkCallbackError("Failed to fetch client token. Exception caught."));
        }

    }

}

TokenService tokenService  = new TokenService();

_ecpSdk = SharedECPSdk.getInstance(StripeLandingActivity.this);

 HashSet<ECPEventType> subscribedEvents = new HashSet<ECPEventType>();

 subscribedEvents.add(ECPEventType.CONNECTION_CHANGED_EVENT);
 subscribedEvents.add(ECPEventType.DEVICE_BATTERY_EVENT);
 subscribedEvents.add(ECPEventType.DEVICE_CARD_EVENT);
 subscribedEvents.add(ECPEventType.DEVICE_MESSAGE_EVENT);
 subscribedEvents.add(ECPEventType.CONFIG_STATUS_EVENT);
 subscribedEvents.add(ECPEventType.CONFIG_PROGRESS_EVENT);

_ecpSdk.initializeSdk(StripeLandingActivity.this, environment, tokenService, subscribedEvents, this, new InitializeSdkCallback() {
             @Override
             public void onComplete(boolean isInitializeSdkSuccess, ECPSdkCallbackError errorResponse) {
												// code after initialize here
                    }
                });

HashSet<ECPEventType> subscribedEvents = new HashSet<ECPEventType>();
// use ECPEventType.ALL if you would like to subscribe to all events by default. 
// subscribedEvents.add(ECPEventType.ALL);
subscribedEvents.add(ECPEventType.CONNECTION_CHANGED_EVENT);
subscribedEvents.add(ECPEventType.DEVICE_BATTERY_EVENT);
subscribedEvents.add(ECPEventType.DEVICE_CARD_EVENT);
subscribedEvents.add(ECPEventType.DEVICE_MESSAGE_EVENT);
subscribedEvents.add(ECPEventType.CONFIG_STATUS_EVENT);
subscribedEvents.add(ECPEventType.CONFIG_PROGRESS_EVENT);

HashSet<ECPSdkReaderConfigType> selectedReaderTypes = new HashSet<>();
selectedReaderTypes.add(ECPSdkReaderConfigType.BLUETOOTH);
selectedReaderTypes.add(ECPSdkReaderConfigType.TAPTOPAY);

public static synchronized ISharedECPSdk getInstance(Context context);

private ISharedECPSdk _ecpSdk;

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    		
        _ecpSdk = SharedECPSdk.getInstance(MyActivity.this);
    
    }

    void initializeSdk(Context context, 
                       ECPEnvironment environment, 
                       ClientTokenProvider clientTokenBlock, 
                       HashSet<ECPEventType> subscribedEvents, 
                       ECPSdkListener listener, InitializeSdkCallback callback);

public class StripeLandingActivity extends AppCompatActivity implements ECPSdkListener {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
  	
    ECPEnvironment environment = ECPEnvironment.PROD;
    HashSet<ECPEventType> subscribedEvents = new HashSet<ECPEventType>();
    subscribedEvents.add(ECPEventType.ALL);
    TokenService tokenService = new TokenService();
    
    _ecpSdk.initializeSdk(StripeLandingActivity.this, environment, tokenService, subscribedEvents, this, new InitializeSdkCallback() {
     
      @Override
      public void onComplete(boolean isInitializeSdkSuccess, ECPSdkCallbackError errorResponse) {
        // Handle callback
      }
    });
    
  }
  
}

void subscribeToEvents(ECPSdkListener ecpSdkListener, ECPCallback callback);

// somewhere in your class you have stored the sdk, accessing it via sharedECPSdk variable
// the class this is called from in this example implements ECPSdkListener.

_ecpSdk.subscribeToEvents(this, new ECPCallback() {
  @Override
  public void onComplete(boolean success, ECPSdkCallbackError error) {
    Log.i(TAG, "Subscribed to events: " + success);
  }
});

void unsubscribeFromEvents(ECPSdkListener ecpSdkListener, ECPCallback ecpCallback);

// somewhere in your class you have stored the sdk, accessing it via sharedECPSdk variable
// the class this is called from in this example implements ECPSdkListener.

_ecpSdk.unsubscribeFromEvents(this, new ECPCallback() {
  @Override
  public void onComplete(boolean success, ECPSdkCallbackError error) {
    Log.i(TAG, "Unsubscribed from events: " + success);
  }
});

void configureReaderTypes(HashSet<ECPSdkReaderConfigType> configuredReaderTypes, ConfiguredReadersCallback configuredReadersCallback);

HashSet<ECPSdkReaderConfigType> selectedReaderTypes = new HashSet<>();
selectedReaderTypes.add(ECPSdkReaderConfigType.BLUETOOTH);
selectedReaderTypes.add(ECPSdkReaderConfigType.TAPTOPAY);

        _ecpSdk.configureReaderTypes(selectedReaderTypes, new ConfiguredReadersCallback() {
            @Override
            public void onComplete(boolean isReaderTypesConfigured, HashSet<ECPSdkReaderConfigType> hashSet, ECPSdkCallbackError ecpSdkCallbackError) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        String displayMessage;
                        if(isReaderTypesConfigured)
                        {
                            displayMessage = "successfully configured reader types: " + createStringFromHashSet(hashSet);
                        }
                        else
                        {
                            displayMessage = "failed to configure reader types: " + ecpSdkCallbackError.errorDescription;
                        }
                        responseView.setText(displayMessage);
                    }
                });
            }
        });

HashSet<ECPSdkReaderConfigType> getConfiguredReaderTypes();

HashSet<ECPSdkReaderConfigType> configTypes = _ecpSdk.getConfiguredReaderTypes();

boolean isInitialized();

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

if (_ecpSdk.isInitialized()) {
	// Your logic here
}

String getECPSdkVersion();

// ecpSdkVersion for version 2.1.0 will get assigned a string value of "2.1.0" . 
String ecpSdkVersion = _ecpSdk.getECPSdkVersion();

void resetSdk(ResetSdkCallback resetSdkCallback);

private void resetSdk(){
  _ecpSdk.resetSdk(new ResetSdkCallback() {
   
    @Override
    public void onComplete(boolean isReset, ECPSdkCallbackError error) {
      // handle callback
    }
  });
}

    void discoverDevices(int scanTime, DiscoverCallback discoverCallback);

	_ecpSdk.discoverDevices(5, new DiscoverCallback<Reader>() {
		@Override
		public void onComplete(ArrayList<ECPDevice<Reader>> devices, ECPSdkCallbackError error) {
			if (error == null && devices != null && devices.size() > 0) {
				String[] deviceSerials = new String[devices.size()];

				StringBuilder devicesFoundInfo = new StringBuilder("Found the following devices on Scan:");

				for (int i = 0; i < devices.size(); i++) {
					deviceSerials[i] = devices.get(i).id_number;
					devicesFoundInfo = devicesFoundInfo.append("\n" + "  Id: " + devices.get(i).id_number +
							" Manufacturer: " + devices.get(i).manufacturer +
							" Model: " + devices.get(i).model +
							" Battery Percentage: " + devices.get(i).battery_percentage + "\n");
				}
				String finalDevicesFoundString = devicesFoundInfo.toString();
				runOnUiThread(new Runnable() {
					@Override
					public void run() {
						AlertDialog.Builder builder = new AlertDialog.Builder(StripeLandingActivity.this);
						builder.setTitle("Devices");
						responseView.setText(finalDevicesFoundString);
						builder.setItems(deviceSerials, new DialogInterface.OnClickListener() {
							@Override
							public void onClick(DialogInterface dialogInterface, int i) {
								// access clicked deviceSerial through deviceSerials[i]
								java.util.Optional<ECPDevice<Reader>> ecpDeviceOptional = devices.stream().filter(p -> p.id_number.equals(deviceSerials[i])).findFirst();
								if (!ecpDeviceOptional.isPresent()) {
									Toast.makeText(StripeLandingActivity.this, "Error connecting to device id: " + deviceSerials[i], Toast.LENGTH_SHORT).show();
									return;
								}

								ECPDevice<Reader> ecpDevice = ecpDeviceOptional.get();
								_ecpSdk.connectDevice(ecpDevice, new ConnectCallback() {
									@Override
									public void onComplete(boolean connected, ECPSdkCallbackError error) {
										Log.i(TAG, "connected: " + connected);
										runOnUiThread(new Runnable() {
											@Override
											public void run() {
												if (connected) {
													Toast.makeText(StripeLandingActivity.this, "Device connected!", Toast.LENGTH_SHORT).show();
												} else {
													Toast.makeText(StripeLandingActivity.this, "Device connection failed!", Toast.LENGTH_SHORT).show();
												}
											}
										});
									}
								});
							}
						});

						builder.show();
					}
				});
			} else {
				runOnUiThread(new Runnable() {
					@Override
					public void run() {
						responseView.setText("No devices found to report info on from scan");
						AlertDialog.Builder builder = new AlertDialog.Builder(StripeLandingActivity.this);
						if (error != null && error.errorDescription != null) {
							builder.setTitle("No devices found! Discover error was " + error.errorDescription);
						} else {
							builder.setTitle("No devices found!");
						}
						builder.show();
					}
				});
			}
		}
	});

<T> void connectDevice(ECPDevice<T> ecpDevice, ConnectCallback connectCallback);

_ecpSdk.connectDevice(ecpDevice, new ConnectCallback() {
  @Override
  public void onComplete(boolean connected, ECPSdkCallbackError error) {
    Log.i(TAG, "connected: " + connected);
    runOnUiThread(new Runnable() {
      @Override
      public void run() {
        if (connected) {
          Toast.makeText(StripeLandingActivity.this, "Device connected!", Toast.LENGTH_SHORT).show();
        } else {
          Toast.makeText(StripeLandingActivity.this, "Device connection failed!", Toast.LENGTH_SHORT).show();
        }
      }
    });
  }
});

void disconnectDevice(DisconnectCallback disconnectCallback);

_ecpSdk.disconnectDevice(new DisconnectCallback() {
  @Override
  public void onComplete(boolean didDisconnect, ECPSdkCallbackError error) {
    // Your logic here
  }
});

void makeSale(ECPPaymentParameters parameters, MakeSaleCallback makeSaleCallback);

ECPPaymentParameters params = new ECPPaymentParameters();
params.amount = "100.00";
params.external_id = "TestExternalId";
params.paymentDescription = "Test Description";
params.paymentDescriptionSuffix = "Test Suffix";

_ecpSdk.makeSale(params, new MakeSaleCallback() {
  @Override
  public void onComplete(boolean success, ECPSaleResponse saleResponse, ECPSdkCallbackError error) {
    Log.i(TAG, "make sale completed. Success: " + success);
  }
});

void stopCurrentFlow(ECPCallback callback);

_ecpSdk.stopCurrentFlow(new ECPCallback() {
  @Override
  public void onComplete(boolean success, ECPSdkCallbackError error) {
  	// Your logic here
  }
});

    void getDeviceInfo(DeviceInfoCallback deviceInfoCallback);

deviceInfoBtn.setOnClickListener(v -> {
            _ecpSdk.getDeviceInfo(new DeviceInfoCallback() {
                @Override
                public void onComplete(boolean isDeviceConnected, ECPDevice ecpDevice, ECPSdkCallbackError error) {
                    if (isDeviceConnected && ecpDevice != null && error == null) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                StringBuilder deviceInfo = new StringBuilder("Get Device Info Result: \n "
                                        + "isDeviceConnected :" + isDeviceConnected + "\n"
                                        + "id: " + ecpDevice.id_number + "\n"
                                        + "manufacturer: " + ecpDevice.manufacturer + "\n"
                                        + "model: " + ecpDevice.model + "\n"
                                        + "battery_percentage: " + ecpDevice.battery_percentage + "\n"
                                        + "type: " + ecpDevice.reader.getClass());

                                responseView.setText(deviceInfo);
                            }
                        });
                    } else {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                StringBuilder deviceInfoError = new StringBuilder("Error on Get Device Info: " + "\n"
                                        + "isDeviceConnected : " + isDeviceConnected + "\n"
                                        + "error: " + error.errorDescription != null ? error.errorDescription : "");
                                responseView.setText(deviceInfoError);
                            }
                        });
                    }
                }
            });
        });

public class LandingActivity extends AppCompatActivity implements ECPSdkListener {
 ////.....
  
 exampleMethod() {																																							// here is listener
     _ecpSdk.initializeSdk(StripeLandingActivity.this, environment, tokenService, subscribedEvents, this, new InitializeSdkCallback() {
     }
  }
//.... more code here
// .....
// .....    
                           
                           
                           
// Later on down in your file, you can implement onDeviceEvent to listen to events coming in. 
  @Override
    public void onDeviceEvent(ECPSdkEvent event) {
		//code goes here to  process each ECPSdkEvent coming in
    }
}

   @Override
    public void onDeviceEvent(ECPSdkEvent event) {
        Log.i(TAG, "On Device Event triggered for event: " + event.message);
        if (event instanceof ECPConnectionChangedEvent) {
            ECPConnectionChangedEvent connectionChangedEvent = (ECPConnectionChangedEvent) event;
            StringBuffer stringBuffer = new StringBuffer("ECPConnectionChangedEvent object details: ");
            stringBuffer.append("\n" + "ECPConnectionChangedEvent Status: " + connectionChangedEvent.status);
            stringBuffer.append("\n" + "ECPConnectionChangedEvent Message: " + connectionChangedEvent.message);
            if(event.error != null) {
                stringBuffer.append("\n" + "ECPConnectionChangedEvent Error present. Error message: " + event.error.errorMessage);
            }

            switch (connectionChangedEvent.status) {
                case NOT_CONNECTED:
                    stringBuffer.append("\n" + "ConnectionChangedEvent - device not connected");
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            responseView.setText(stringBuffer);
                        }
                    });
                    break;
                case CONNECTING:
                    stringBuffer.append("\n" + "ConnectionChangedEvent - device connecting");
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            responseView.setText(stringBuffer);
                        }
                    });
                    break;
                case CONNECTED:
                    stringBuffer.append("\n" + "ConnectionChangedEvent - device connected");
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            responseView.setText(stringBuffer);
                        }
                    });
                    break;
                case UNEXPECTED_DISCONNECT:
                    stringBuffer.append("\n" + "ConnectionChangedEvent - unexpected disconnect");
                    new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            responseView.setText(stringBuffer);
                        }
                    }, 1000);
                    break;
                case UNKNOWN_STATUS:
                    stringBuffer.append("\n" + "ConnectionChangedEvent - unknown status");
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            responseView.setText(stringBuffer);
                        }
                    });
                    break;
                default:
                    break;
            }
        } else if (event instanceof ECPDeviceConfigStatusEvent) {

            if (((ECPDeviceConfigStatusEvent) event).status == ECPDeviceConfigStatus.UPDATE_STARTING) {

                if(event.error == null) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(StripeLandingActivity.this, "Device has updates to install. Message: " + event.message, Toast.LENGTH_SHORT).show();
                            responseView.setText("Update starting...");
                        }
                    });
                } else {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(StripeLandingActivity.this, "ECPDeviceConfigStatusEvent update starting event has error. Error message: " + event.error.errorMessage , Toast.LENGTH_SHORT);
                            responseView.setText("Error object on ECPDeviceConfigStatusEvent with status of starting");
                        }
                    });
                }
            } else if (((ECPDeviceConfigStatusEvent) event).status == ECPDeviceConfigStatus.UPDATE_FINISHED) {
                if(event.error == null) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(StripeLandingActivity.this, "Device has finished updating. Message: " + event.message, Toast.LENGTH_SHORT).show();
                            responseView.setText("Update complete");
                        }
                    });
                } else {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(StripeLandingActivity.this, "ECPDeviceConfigStatusEvent update finished event has error. Error message: " + event.error.errorMessage, Toast.LENGTH_SHORT);
                            responseView.setText("Error object on ECPDeviceConfigStatusEvent with status of finished");
                        }
                    });
                }
            }
        } else if (event instanceof ECPDeviceConfigProgressEvent) {

            if(event.error == null) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        responseView.setText("Update in progress: " + ((ECPDeviceConfigProgressEvent) event).progress);
                    }
                });
            } else {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        responseView.setText("Error object on ECPDeviceConfigProgressEvent. Error message was: "
                                + event.error.errorMessage);
                    }
                });
            }

        } else if (event instanceof ECPDeviceMessageEvent) {
            StringBuffer sb = new StringBuffer();
            sb.append("Device Message: ").append(event.message);
            sb.append("\nCode: ")
                    .append(((ECPDeviceMessageEvent) event).messageCode == null ? "null" : ((ECPDeviceMessageEvent) event).messageCode.toString());
            Log.i(TAG, "message code: " + ((ECPDeviceMessageEvent) event).messageCode.toString());
            if (((ECPDeviceMessageEvent) event).inputOptions != null) {
                for (ECPInputOption option : ((ECPDeviceMessageEvent) event).inputOptions) {
                    Log.i(TAG, "Input option: " + option.toString());
                    sb.append("\nInput option: ").append(option);
                }
            }

            if(event.error != null) {
                sb.append("\nECPDeviceMessageEvent error present. Error message: " + event.error.errorMessage);
            }
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    responseView.setText(sb.toString());
                }
            });
        } else if (event instanceof ECPDeviceCardEvent) {
            StringBuffer sb = new StringBuffer();
            sb.append("Card Event: ").append(event.message);
            sb.append("\nStatus: ")
                    .append(((ECPDeviceCardEvent) event).eventStatus == null ? "null" : ((ECPDeviceCardEvent) event).eventStatus.toString());
            if (event.error != null) {
                sb.append("\nECPDeviceCardEvent error present. Error message: " + event.error.errorMessage);
            }
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    responseView.setText(sb.toString());
                }
            });
        }
        else if(event instanceof ECPDeviceBatteryEvent) {
            ECPDeviceBatteryEvent batteryEvent = (ECPDeviceBatteryEvent) event;
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("Battery Event object details: ");
            stringBuffer.append("\n" + "ECPDeviceBatteryEvent Status: " + batteryEvent.status);
            stringBuffer.append("\n" + "ECPDeviceBatteryEvent Message: " + batteryEvent.message);
            if(event.error != null) {
                stringBuffer.append("\n" + "ECPDeviceBatteryEvent Error present. Error message: " + batteryEvent.error.errorMessage);
            }
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    responseView.setText(stringBuffer);
                }
            });
        }
    }