/// <summary>
/// Create a new Service client
/// </summary>
public ClientService(IOptions<AppSettings> settings, IHttpClientFactory httpClientFactory, IJsonConverterService jsonConverterService, IValidatorService validatorService)
{
	Settings = settings.Value;
	ApiKey = Settings.ApiToken;

	HttpClientFactory = httpClientFactory;
	JsonConverterService = jsonConverterService;
	ValidatorService = validatorService;
}

// Neccesary for use of IHttpClientFactory
services.AddHttpClient();

// Actual registration of the ClientService
services.AddSingleton<IClientService, ClientService>();

IClientService clientService = new ClientService("{yourApiKey}");

IPaymentClient paymentClient = new PaymentClient(clientService);

IPaymentClient paymentClient = new PaymentClient(clientService);
PaymentRequest paymentRequest = new PaymentRequest() {
    Amount = new Amount(Currency.EUR, "100.00"),
    Description = "Test payment of the example project",
    RedirectUrl = "http://google.com"
};

PaymentResponse paymentResponse = await paymentClient.CreatePaymentAsync(paymentRequest);

IPaymentClient paymentClient = new PaymentClient(clientService);
BankTransferPaymentRequest paymentRequest = new BankTransferPaymentRequest();
// Set bank transfer specific BillingEmail property
paymentRequest.BillingEmail = "{billingEmail}";
BankTransferPaymentResponse response = (BankTransferPaymentResponse)await paymentClient.CreatePaymentAsync(paymentRequest);

IPaymentClient paymentClient = new PaymentClient(clientService);
PaymentResponse result = await paymentClient.GetPaymentAsync(paymentResponse.Id);

// Custom metadata class that contains the data you want to include in the metadata class. 
CustomMetadataClass metadataRequest = new CustomMetadataClass() {
    OrderId = 1,
    Description = "{customDescription}"
};

// Create a new payment
PaymentRequest paymentRequest = new PaymentRequest() {
    Amount = new Amount(Currency.EUR, "100.00"),
    Description = "{description}",
    RedirectUrl = this.DefaultRedirectUrl,
};

// Set the metadata
paymentRequest.SetMetadata(metadataRequest);

// When we retrieve the payment response, we can convert our metadata back to our custom class
IPaymentClient paymentClient = new PaymentClient(clientService);
PaymentResponse result = await paymentClient.CreatePaymentAsync(paymentRequest);
CustomMetadataClass metadataResponse = result.GetMetadata<CustomMetadataClass>();

IPaymentClient paymentClient = new PaymentClient(clientService);
ListResponse<PaymentResponse> response = await paymentClient.GetPaymentListAsync("{offset}", "{count}");

IPaymentMethodClient _paymentMethodClient = new PaymentMethodClient(clientService);
ListResponse<PaymentMethodListData> paymentMethodList = await this._paymentMethodClient.GetPaymentMethodListAsync();
foreach (PaymentMethodResponse paymentMethod in paymentMethodList.Items) {
	// Your code here
}

IPaymentMethodClient _paymentMethodClient = new PaymentMethodClient(clientService);
PaymentMethodResponse paymentMethodResponse = await paymentMethodClient.GetPaymentMethodAsync(PaymentMethod.Ideal);

RefundResponse refundResponse = await this._refundClient.CreateRefundAsync("{paymentId}", new RefundRequest() {
	Amount = new Amount(Currency.EUR, "100"),
	Description = "{description}"
});

IRefundClient refundClient = new RefundClient(clientService);
RefundResponse refundResponse = await this._refundClient.GetRefundAsync("{paymentId}", "{refundId}");

IRefundClient refundClient = new RefundClient(clientService);
ListResponse<RefundListData> refundList = await this._refundClient.GetRefundListAsync("{paymentId}", "{offset}", "{count}");

IRefundClient refundClient = new RefundClient(clientService);
await refundClient.CancelRefundAsync("{paymentId}", "{refundId}");

CustomerRequest customerRequest = new CustomerRequest() {
	Email = "{email}",
	Name = "{name}",
	Locale = Locale.nl_NL
};

ICustomerClient customerClient = new CustomerClient(clientService);
CustomerResponse customerResponse = await customerClient.CreateCustomerAsync(customerRequest);

ICustomerClient customerClient = new CustomerClient(clientService);
CustomerResponse customerResponse = await customerClient.GetCustomerAsync(customerId);

ICustomerClient customerClient = new CustomerClient(clientService);
ListResponse<CustomerResponse> response = await customerClient.GetCustomerListAsync();

ICustomerClient customerClient = new CustomerClient(clientService);
CustomerRequest updateParameters = new CustomerRequest() {
	Name = "{customerName}"
};
CustomerResponse result = await customerClient.UpdateCustomerAsync("{customerIdToUpdate}", updateParameters);

ICustomerClient customerClient = new CustomerClient(clientService);
await customerClient.DeleteCustomerAsync("{customerIdToDelete}");

IMandateClient mandateclient = new MandateClient(clientService);
MandateRequest mandateRequest = new MandateRequest() {
	ConsumerAccount = "{iban}",
	ConsumerName = "{customerName}"
};
MandateResponse mandateResponse = await this._mandateClient.CreateMandateAsync("{customerId}", mandateRequest);

IMandateClient mandateclient = new MandateClient(clientService);
MandateResponse mandateResponse = await mandateclient.GetMandateAsync("{customerId}", "{mandateId}");

IMandateClient mandateclient = new MandateClient(clientService);
ListResponse<MandateResponse> response = await mandateclient.GetMandateListAsync("{customerId}");

IMandateClient mandateclient = new MandateClient(clientService);
await mandateclient.RevokeMandateAsync("{customerId}", "{mandateId}");

ISubscriptionClient subscriptionClient = new SubscriptionClient(clientService);
SubscriptionRequest subscriptionRequest = new SubscriptionRequest() {
	Amount = new Amount(Currency.EUR, "100.00"),
	Times = 5,
    	Interval = "1 month",
	Description = "{uniqueIdentifierForSubscription}"
};
SubscriptionResponse subscriptionResponse = await subscriptionClient.CreateSubscriptionAsync("{customerId}", subscriptionRequest);

ISubscriptionClient subscriptionClient = new SubscriptionClient(clientService);
SubscriptionResponse subscriptionResponse = await subscriptionClient.GetSubscriptionAsync("{customerId}", "{subscriptionId}");

ISubscriptionClient subscriptionClient = new SubscriptionClient(clientService);
ListResponse<SubscriptionResponse> response = await subscriptionClient.GetSubscriptionListAsync("{customerId}", null, {numberOfSubscriptions});

ISubscriptionClient subscriptionClient = new SubscriptionClient(clientService);
await subscriptionClient.CancelSubscriptionAsync("{customerId}", "{subscriptionId}");

ISubscriptionClient subscriptionClient = new SubscriptionClient(clientService);
SubscriptionUpdateRequest updatedSubscriptionRequest = new SubscriptionUpdateRequest() {
	Description = $"Updated subscription {DateTime.Now}"
};
await subscriptionClient.UpdateSubscriptionAsync("{customerId}", "{subscriptionId}", updatedSubscriptionRequest);

IOrderClient orderClient = new OrderClient(clientService);
OrderRequest orderRequest = new OrderRequest() {
	Amount = new Amount(Currency.EUR, "100.00"),
	OrderNumber = "16738",
	Lines = new List<OrderLineRequest>() {
		new OrderLineRequest() {
			Name = "A box of chocolates",
			Quantity = 1,
			UnitPrice = new Amount(Currency.EUR, "100.00"),
			TotalAmount = new Amount(Currency.EUR, "100.00"),
			VatRate = "21.00",
			VatAmount = new Amount(Currency.EUR, "17.36")
		}
	},
	BillingAddress = new OrderAddressDetails() {
		GivenName = "John",
		FamilyName = "Smit",
		Email = "johnsmit@gmail.com",
		City = "Rotterdam",
		Country = "NL",
		PostalCode = "0000AA",
		Region = "Zuid-Holland",
		StreetAndNumber = "Coolsingel 1"
	},
	RedirectUrl = "http://www.google.nl",
	Locale = Locale.nl_NL
};

OrderResponse result = await orderClient.CreateOrderAsync(orderRequest);

IOrderClient orderClient = new OrderClient(clientService);
OrderResponse retrievedOrder = await orderClient.GetOrderAsync({orderId});

IOrderClient orderClient = new OrderClient(clientService);
OrderUpdateRequest orderUpdateRequest = new OrderUpdateRequest() {
	OrderNumber = "1337" 
};
OrderResponse updatedOrder = await orderClient.UpdateOrderAsync({orderId}, orderUpdateRequest);

IOrderClient orderClient = new OrderClient(clientService);
 OrderResponse canceledOrder = await this._orderClient.GetOrderAsync({orderId});

IOrderClient orderClient = new OrderClient(clientService);
OrderLineUpdateRequest updateRequest = new OrderLineUpdateRequest() {
	Name = "A fluffy bear"
};
OrderResponse updatedOrder = await orderClient.UpdateOrderLinesAsync({orderId}, createdOrder.Lines.First().Id, updateRequest);

IOrderClient orderClient = new OrderClient(clientService);
ListResponse<OrderResponse> response = await orderClient.GetOrderListAsync();