/// <summary>
 /// Does the authentication module supports pre-authentication?
 /// </summary>
 /// <param name="client">Client executing this request</param>
 /// <param name="request">Request to authenticate</param>
 /// <param name="credentials">The credentials to be used for the authentication</param>
 /// <returns>true when the authentication module supports pre-authentication</returns>
 public bool CanPreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
 {
     var cred = credentials?.GetCredential(client.BuildUri(request, false), AuthenticationMethod);
     if (cred == null)
         return false;
     return true;
 }

 protected override bool IsCanProcessRequest(IRestRequest request)
 {
     return (request.Verb == HttpVerb.Post || request.Verb == HttpVerb.Put)
         && request.GetType() == typeof(RestRequest)
         && request.Parameters != null
         && request.Parameters.Any(p => p.Value is FileParameter);
 }

        public void ApplyOptions(IRestRequest request, bool isGet)
        {
            if (_options == null)
            {
                return;
            }
            ApplyOptionsStrategy applyOptionsStrategy = isGet
                                                            ? (ApplyOptionsStrategy)
                                                              new GetApplyOptionsStrategy(request, _options)
                                                            : new PostApplyOptionsStrategy(request, _options);
            if (_options.Pretty)
            {
                applyOptionsStrategy.ApplyPretty();
            }

            if (_options.Fields != null && _options.Fields.Count > 0)
            {
                applyOptionsStrategy.ApplyFields();
            }

            if (_options.Expand != null && _options.Expand.Count > 0)
            {
                applyOptionsStrategy.ApplyExpand();
            }
            applyOptionsStrategy.Finish();
        }

 private void PopulateSubEntities(IRestRequest request)
 {
     new LobImageFilePopulator(_definition.Front, "front").Populate(request);
     new LobImageFilePopulator(_definition.Back, "back").Populate(request);
     if (_definition.Data != null) new DataPopulator(_definition.Data).Populate(request);
     if (_definition.MetaData != null) new MetaDataPopulator(_definition.MetaData).Populate(request);
 }

 private void ReplaceAcceptWithJson(IRestRequest restRequest)
 {
     foreach (var parameter in restRequest.Parameters.Where(p => p.Name == "Accept"))
     {
         parameter.Value = "application/json";
     }
 }

 public RestException(IRestRequest request, IRestResponse response)
     : base(string.Format("The endpoint at '{0}' didn't respond with 'OK'. Instead it was '{1}'.",
         response.ResponseUri, response.StatusCode), response.ErrorException??new Exception(response.Content))
 {
     Request = request;
     Response = response;
 }

 public BaseRestService(IRestHandler restHandler, IFormat formator, IRestRequest restRequest)
 {
     _restHandler = restHandler;
     _formator = formator;
     _restRequest = restRequest;
     Initialize();
 }

        /// <summary>
        /// Gets the basic content (without files) for a request
        /// </summary>
        /// <param name="client">The REST client that will execute the request</param>
        /// <param name="request">REST request to get the content for</param>
        /// <returns>The HTTP content to be sent</returns>
        internal static IHttpContent GetBasicContent([CanBeNull] this IRestClient client, IRestRequest request)
        {
            IHttpContent content;
            var parameters = client.MergeParameters(request);
            var body = parameters.FirstOrDefault(x => x.Type == ParameterType.RequestBody);
            if (body != null)
            {
                content = request.GetBodyContent(body);
            }
            else
            {
                if (client.GetEffectiveHttpMethod(request) == Method.POST)
                {
                    var getOrPostParameters = parameters.GetGetOrPostParameters().ToList();
                    if (getOrPostParameters.Count != 0)
                    {
                        content = new PostParametersContent(getOrPostParameters);
                    }
                    else
                    {
                        content = null;
                    }
                }
                else
                {
                    content = null;
                }
            }

            return content;
        }

 /// <summary>
 /// Modifies the request to ensure that the authentication requirements are met.
 /// </summary>
 /// <param name="client">Client executing this request</param>
 /// <param name="request">Request to authenticate</param>
 public void Authenticate(IRestClient client, IRestRequest request)
 {
     // only add the Authorization parameter if it hasn't been added by a previous Execute
     if (request.Parameters.Any(p => p.Name != null && p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
         return;
     request.AddParameter("Authorization", this._authHeader, ParameterType.HttpHeader);
 }

        public HttpRequestMessage Build(IRestRequest request, IDictionary<string, string> persistentHeaders)
        {
            if (!this.IsCanProcessRequest(request))
                return null;

            HttpRequestMessage message = this.BuildMessage(request);

            // Set headers
            message.Headers.Add("Accept", "application/json");

            // Add persistent headers
            if (request.Headers != null) {
                foreach (var header in request.Headers)
                    this.AddHeader(header.Key, header.Value, message);
            }

            // Add message headers
            if (persistentHeaders != null) {
                foreach (var header in persistentHeaders)
                    if (request.Headers == null || !request.Headers.ContainsKey(header.Key))
                        this.AddHeader(header.Key, header.Value, message);
            }

            return message;
        }

 internal void Apply(IRestRequest request)
 {
     _ops.ForEach((op) =>
     {
         request.AddQueryParameter(op.Type.ToString(), op.Value);
     });
 }

        public void Authenticate(IRestClient client, IRestRequest request)
        {
            if (request.Parameters.Exists(p => p.Name.Equals("Cookie", StringComparison.InvariantCultureIgnoreCase)))
                return;

            request.AddParameter("cookie", _authHeader, ParameterType.HttpHeader);
        }

 /// <summary>
 /// Assembles URL to call based on parameters, method and resource
 /// </summary>
 /// <param name="client">RestClient performing the execution</param>
 /// <param name="request">RestRequest to execute</param>
 /// <returns>Assembled System.Uri</returns>
 /// <remarks>
 /// RestClient's BuildUri purposefully leaves off the parameters from the uri it builds when the request 
 /// is a POST, PUT, or PATCH.  This extension method aims to undo this feature for debugging reasons
 /// </remarks>
 public static Uri BuildDebugUri(this IRestClient client, IRestRequest request)
 {
     var uri = client.BuildUri(request);
     if (request.Method != Method.POST &&
         request.Method != Method.PUT &&
         request.Method != Method.PATCH)
     {
         return uri;
     }
     else
     {
         var queryParameters = from p in request.Parameters
                               where p.Type == ParameterType.GetOrPost
                               select string.Format("{0}={1}", Uri.EscapeDataString(p.Name), Uri.EscapeDataString(p.Value.ToString()));
         if (!queryParameters.Any())
         {
             return uri;
         }
         else
         {
             var path = uri.OriginalString.TrimEnd('/');
             var query = string.Join("&", queryParameters);
             return new Uri(path + "?" + query);
         }
     }
 }

 private void ApplyOptions(IRestRequest request, bool isGet)
 {
     if (_asanaOptionsApplier != null)
     {
         _asanaOptionsApplier.ApplyOptions(request, true);
     }
 }

        private void LogRequest(RestClient restClient, IRestRequest request, IRestResponse response, long durationMs)
        {
            var requestToLog = new
            {
                resource = request.Resource,
                // Parameters are custom anonymous objects in order to have the parameter type as a nice string
                // otherwise it will just show the enum value
                parameters = request.Parameters.Select(parameter => new
                {
                    name = parameter.Name,
                    value = parameter.Value,
                    type = parameter.Type.ToString()
                }),
                // ToString() here to have the method as a nice string otherwise it will just show the enum value
                method = request.Method.ToString(),
                // This will generate the actual Uri used in the request
                uri = restClient.BuildUri(request),
            };

            var responseToLog = new
            {
                statusCode = response.StatusCode,
                content = response.Content,
                headers = response.Headers,
                // The Uri that actually responded (could be different from the requestUri if a redirection occurred)
                responseUri = response.ResponseUri,
                errorMessage = response.ErrorMessage,
            };

            Trace.Write(string.Format("Request completed in {0} ms, Request: {1}, Response: {2}",
                    durationMs,
                    JsonConvert.SerializeObject(requestToLog),
                    JsonConvert.SerializeObject(responseToLog)));
        }

        /// <summary>
        /// Gets the content for a request
        /// </summary>
        /// <param name="client">The REST client that will execute the request</param>
        /// <param name="request">REST request to get the content for</param>
        /// <returns>The HTTP content to be sent</returns>
        internal static IHttpContent GetContent([CanBeNull] this IRestClient client, IRestRequest request)
        {
            HttpContent content;
            var parameters = client.MergeParameters(request);
            var collectionMode = request?.ContentCollectionMode ?? ContentCollectionMode.MultiPartForFileParameters;
            if (collectionMode != ContentCollectionMode.BasicContent)
            {
                var fileParameters = parameters.GetFileParameters().ToList();
                if (collectionMode == ContentCollectionMode.MultiPart || fileParameters.Count != 0)
                {
                    content = client.GetMultiPartContent(request);
                }
                else
                {
                    content = client.GetBasicContent(request);
                }
            }
            else
            {
                content = client.GetBasicContent(request);
            }

            if (content == null)
                return null;

            return new DefaultHttpContent(content);
        }

        public void Authenticate(IRestClient client, IRestRequest request)
        {
            DateTime signingDate = DateTime.UtcNow;
            SetContentMd5(request);
            SetContentSha256(request);
            SetHostHeader(client, request);
            SetDateHeader(request, signingDate);
            SortedDictionary<string, string> headersToSign = GetHeadersToSign(request);
            string signedHeaders = GetSignedHeaders(headersToSign);
            string region = Regions.GetRegion(client.BaseUrl.Host);
            string canonicalRequest = GetCanonicalRequest(client, request, headersToSign);
            byte[] canonicalRequestBytes = System.Text.Encoding.UTF8.GetBytes(canonicalRequest);
            string canonicalRequestHash = BytesToHex(ComputeSha256(canonicalRequestBytes));
            string stringToSign = GetStringToSign(region, canonicalRequestHash, signingDate);
            byte[] signingKey = GenerateSigningKey(region, signingDate);

            byte[] stringToSignBytes = System.Text.Encoding.UTF8.GetBytes(stringToSign);

            byte[] signatureBytes = SignHmac(signingKey, stringToSignBytes);

            string signature = BytesToHex(signatureBytes);

            string authorization = GetAuthorizationHeader(signedHeaders, signature, signingDate, region);
            request.AddHeader("Authorization", authorization);
        }

		private async Task<IRestResponse> ExecuteInternal(IRestRequest request, string httpMethod, Func<IHttp, string, Task<HttpResponse>> getResponse)
		{
			AuthenticateIfNeeded(this, request);

			// add Accept header based on registered deserializers
			var accepts = string.Join(", ", AcceptTypes.ToArray());
			this.AddDefaultParameter("Accept", accepts, ParameterType.HttpHeader);

			IRestResponse response = new RestResponse();
			try
			{
				var http = HttpFactory.Create();

				ConfigureHttp(request, http);

                //TODO: Add support for Proxy
				//ConfigureProxy(http);

				response = ConvertToRestResponse(request, await getResponse(http, httpMethod));
				response.Request = request;
				response.Request.IncreaseNumAttempts();

			}
			catch (Exception ex)
			{
				response.ResponseStatus = ResponseStatus.Error;
				response.ErrorMessage = ex.Message;
				response.ErrorException = ex;
			}

			return response;
		}

        private BillingConnectorResponse PostApi(string segment, IRestRequest request)
        {
            try
            {
                log.InfoFormat("Invoking billing API on {0} with segment {1}", configuration.Url, segment);

                request.AddHeader("apikey", configuration.ApiKey);

                var response = client.Post(request);

                if (response.StatusCode == HttpStatusCode.OK)
                    return new BillingConnectorResponse(true);

                var failureMessage =
                    string.Format(
                        "Call to billing API return non OK status code. The status code was {0}. The response status code was {1}. The error description is {2}",
                        response.StatusCode, response.ResponseStatus, response.ErrorMessage);

                log.ErrorFormat(failureMessage);
            }
            catch (Exception e)
            {
                log.ErrorFormat("Failed to invoke billing API on {0} because {1}", configuration.Url, e);
            }
            return new BillingConnectorResponse(false);
        }

 public When(IRestClient client, IRestRequest request, IRestResponse response)
 {
     this.client = client;
     this.request = request;
     this.response = response;
     data = new Object();
 }