public static byte[] ExecuteUrl(string url, RequestMethod method = RequestMethod.Post, NameValueCollection Parameters = null)
        {
            using (var webClient = new WebClient())
            {
                try
                {

                    if (RequestMethod.Post == method)
                    {
                        var resBytes = webClient.UploadValues(url, Parameters);
                        return resBytes;
                    }
                    else
                    {
                        var resBytes = webClient.DownloadData(url);
                        return resBytes;
                    }

                }
                catch (Exception e)
                {

                    return null;
                }
            }
        }

        public static RequestInfo Create(
            RequestMethod method, string target, string uriTemplate, Dictionary<string, object> parameters,
            string userAgent, Dictionary<string, string> headers, ContentType requestContentType,
            ContentType responseContentType, TimeSpan cacheDuration,
            int timeout, int retryCount,
            Uri uri, string requestBody, IRequestFactory requestFactory)
        {
            var result = new RequestInfo
                             {
                                 Target = target,
                                 UriTemplate = uriTemplate,
                                 AllowedRetries = retryCount,
                                 Uri = uri,
                                 Method = method,
                                 UserAgent = userAgent,
                                 _headers = new Dictionary<string, string>(headers ?? new Dictionary<string, string>()),
                                 RequestBody = requestBody,
                                 Parameters = new Dictionary<string, object>(parameters ?? new Dictionary<string, object>()),
                                 CacheDuration = cacheDuration,
                                 RequestContentType = requestContentType,
                                 ResponseContentType = responseContentType,
                                 Timeout = timeout
                             };

            return result;
        }

        private HttpWebResponse GetResponseFromWattRequest(Uri requestUrl, RequestMethod method, string postData = "")
        {
            try
            {
                var httpWebRequest = (HttpWebRequest)WebRequest.Create(requestUrl);

                httpWebRequest.Credentials = CredentialCache.DefaultCredentials;
                httpWebRequest.CookieContainer = _cookieJar;
                httpWebRequest.UserAgent = "CSharp HTTP Sample";
                httpWebRequest.KeepAlive = true;
                httpWebRequest.Headers.Set("Pragma", "no-cache");
                httpWebRequest.Timeout = 300000;
                httpWebRequest.Method = method.ToString();
                if (method == RequestMethod.Post)
                {
                    httpWebRequest.ContentType = "application/x-www-form-urlencoded";
                    byte[] bytes = Encoding.ASCII.GetBytes(postData);
                    httpWebRequest.ContentLength = bytes.Length;
                    Stream requestStream = httpWebRequest.GetRequestStream();
                    requestStream.Write(bytes, 0, bytes.Length);
                    requestStream.Close();
                }
                return (HttpWebResponse)httpWebRequest.GetResponse();
            }
            catch
            {
                return null;
            }
        }

 public RestMethodAttribute(string url, RequestMethod method = RequestMethod.Get, string accept = null, string contentType = null)
 {
     this.Url = url;
     this.Method = method;
     this.Accept = accept;
     this.ContentType = contentType;
 }

        public string PrepareRequestData(object parameters, RequestMethod method)
        {
            var result = string.Empty;

            if (parameters == null)
            {
                return result;
            }

            if (method == RequestMethod.Post)
            {
                switch (ContentType)
                {
                    case ContentType.Json:
                        return JsonConvert.SerializeObject(parameters);

                    case ContentType.Xml:
                        using (var sw = new System.IO.StringWriter())
                        {
                            var serializer = new XmlSerializer(parameters.GetType());
                            serializer.Serialize(sw, this);
                            return sw.ToString();
                        }
                }
            }

            result = ((Dictionary<string, object>)parameters).Aggregate(
                result,
                (current, parameter) => current + (parameter.Key + '=' + parameter.Value.ToString() + '&'));

            return result.Trim(new[] {'&'});
        }

 /// <summary>
 /// Creates the HTTP json request.
 /// </summary>
 /// <param name="self">The self.</param>
 /// <param name="url">The URL.</param>
 /// <param name="method">The method.</param>
 /// <param name="metadata">The metadata.</param>
 /// <param name="credentials">The credentials.</param>
 /// <returns></returns>
 public static HttpJsonRequest CreateHttpJsonRequest(object self, Uri url, RequestMethod method, JObject metadata,
                                                     ICredentials credentials)
 {
     var request = new HttpJsonRequest(url, method, metadata, credentials);
     ConfigureRequest(self, new WebRequestEventArgs {Request = request.webRequest});
     return request;
 }

        public static Method Map(RequestMethod method)
        {
            Method mthd;
            Enum.TryParse(method.ToString().ToUpperInvariant(), out mthd);

            return mthd;
        }

 public Request()
 {
     this.contentLength = 0;
     this.contentType = MimeType.Default;
     this.cookies = new CookieCollection();
     this.hasEntityBody = false;
     this.headers = new HeaderCollection();
     this.isAuthenticated = false;
     this.isLocal = false;
     this.isSecureConnection = false;
     this.keepAlive = false;
     this.localEndPoint = null;
     this.method = RequestMethod.Unknown;
     this.protocolType = null;
     this.protocolVersion = null;
     this.rawMethod = null;
     this.rawRequest = null;
     this.rawUrl = null;
     this.referrer = null;
     this.remoteEndPoint = null;
     this.requestData = new RequestDataCollection();
     this.url = null;
     this.userAgent = null;
     this.userHostName = null;
 }

 public WebRequestWrapper(Uri uri, RequestMethod requestMethod, string contentType, ref CookieContainer cookieJar, string dataToPost = null)
 {
     this.Uri = uri;
     this.RequestMeth = requestMethod;
     this.ContentType = contentType;
     this.CookieJar = cookieJar;
     this.DataToPost = dataToPost;
 }

 public PollServiceEventArgs(RequestMethod pRequest, HasEventsMethod pHasEvents, GetEventsMethod pGetEvents, NoEventsMethod pNoEvents,UUID pId)
 {
     Request = pRequest;
     HasEvents = pHasEvents;
     GetEvents = pGetEvents;
     NoEvents = pNoEvents;
     Id = pId;
 }

 public HtmlForm(RequestMethod method, string action, IDictionary<string, string> errors = null)
     : base("form", null)
 {
     SetAttribut("name", "form");
     SetAttribut("method", method.ToString());
     SetAttribut("action", action);
     SetAttribut("onsubmit", "return FormIsValid()");
     _errors = errors;
 }

        public BoxRequest(RequestMethod method, Uri hostUri, string path)
        {
            Method = method;
            Host = hostUri;
            Path = path;

            HttpHeaders = new List<KeyValuePair<string, string>>();
            Parameters = new Dictionary<string, string>();
        }

        public RequestSetting(RequestMethod method, string url)
        {
            _protocolVersion = HttpVersion.Version11;
            _method = method;
            _url = url;

            _accept = "text/html,application/xhtml+xml,*/*";
            _userAgent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/6.0)";
        }

        public Stream Execute(string uri, NameValueCollection data, Dictionary<string, Stream> files, RequestMethod method = RequestMethod.POST)
        {
            String boundary = "SMSAPI-" + DateTime.Now.ToString("yyyy-MM-dd_HH:mm:ss") + (new Random()).Next(int.MinValue, int.MaxValue).ToString() + "-boundary";

            WebRequest webRequest = WebRequest.Create(baseUrl + uri);
            webRequest.Method = RequestMethodToString(method);

            if (basicAuthentication != null)
            {
                webRequest.Headers.Add("Authorization", "Basic " + System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(basicAuthentication.GetUsername() + ":" + basicAuthentication.GetPassword())));
            }

            if (RequestMethod.POST.Equals(method) || RequestMethod.PUT.Equals(method))
            {
                Stream stream;

                if (files != null && files.Count > 0)
                {
                    webRequest.ContentType = "multipart/form-data; boundary=" + boundary;
                    stream = PrepareMultipartContent(boundary, data, files);
                }
                else
                {
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    stream = PrepareContent(data);
                }

                webRequest.ContentLength = stream.Length;

                try
                {
                    stream.Position = 0;
                    CopyStream(stream, webRequest.GetRequestStream());
                    stream.Close();
                }
                catch (System.Net.WebException e)
                {
                    throw new ProxyException(e.Message, e);
                }
            }

            MemoryStream response = new MemoryStream();

            try
            {
                CopyStream(webRequest.GetResponse().GetResponseStream(), response);
            }
            catch (System.Net.WebException e)
            {
                throw new ProxyException("Failed to get response from " + webRequest.RequestUri.ToString(), e);
            }

            response.Position = 0;
            return response;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="requestUri"></param>
        /// <param name="method"></param>
        /// <param name="request"></param>
        protected void CreateContext(Uri requestUri, RequestMethod method, out HttpJsonRequest request)
        {
            Guard.Assert(() => requestUri != null);

            var metadata = new JObject();

            request = HttpJsonRequest.CreateHttpJsonRequest(this, new Uri(requestUri.AbsoluteUri + Guid.NewGuid()),
                                                            method, metadata, Credentials);

            ContextStorage.Add(request, SynchronizationContext.Current);
        }

 public string RequestMethodToString(RequestMethod m)
 {
     switch(m)
     {
         case RequestMethod.rmGet: return "GET";
         case RequestMethod.rmPut: return "PUT";
         case RequestMethod.rmDelete: return "DELETE";
         default:
             throw new Exception(string.Format("Request method {0} not recognized", m));
     }
 }

        private bool ParseRequestLine()
        {
            string[] RequestLineDel = new string[] {" "};
            string[] splittedRequestLine = splittedRequest[0].Split(RequestLineDel, StringSplitOptions.None);

            string methodCheck = splittedRequestLine[0];
            if (methodCheck == "GET")
            {
                this.method = RequestMethod.GET;
            }

            if (methodCheck == "POST")
            {
                this.method = RequestMethod.POST;
            }


            if (methodCheck == "HEAD")
            {
                this.method = RequestMethod.HEAD;
            }


            string version = splittedRequestLine[2];
            if (version == "HTTP/1.0")
            {
                this.httpVersion = HTTPVersion.HTTP10;
            }

            else if (version == "HTTP/1.1")
            {
                this.httpVersion = HTTPVersion.HTTP11;

            }

            else 
            {
                this.httpVersion = HTTPVersion.HTTP09;
            }

            relativeURI = splittedRequestLine[1];
            bool URI = ValidateIsURI(relativeURI);
            if (URI == true)
            {
                return true;
            }
            else
            {
                return false;
            }

            
         //   throw new NotImplementedException();
        }

 private void AddEditRoute(string name, RequestMethod method, string path, bool isAsync, bool isSigned, int editIndex)
 {
     if (name.Length > 0 && path.Length > 0) {
         if (editIndex == -1) {
             // Add the route
             this.routes.Add (new Route (name, method, path, isAsync, isSigned));
         } else {
             // Replace existing route
             this.routes [editIndex] = new Route (name, method, path, isAsync, isSigned);
         }
     }
 }

        /// <summary>
        ///     Method is invoked when the application needs to communicate to 
        ///     the server.
        /// </summary>
        /// <param name="method">The type of http call being sent to the server.</param>
        /// <param name="requestUrl">The command being sent to the server.</param>
        /// <param name="json">The parameters being sent to the server.</param>
        /// <returns>The response from the server as a string.</returns>

        public static async Task<string> GetDataV2WithJson(RequestMethod method, string requestUrl, string json)
        {
            //var authKeys = new Dictionary<string, string> { { "key", App.ApiKey }, { "id", BryxHelper.GetUniqueId() } };
            //var authHeader = BryxHelper.EncodeTo64(JsonConvert.SerializeObject(authKeys, Formatting.None));

            var httpClient = new HttpClient(new HttpClientHandler());
            HttpResponseMessage response;
            switch (method)
            {
                case RequestMethod.Post:
                    if (!requestUrl.Contains("authorization"))
                    {
                        httpClient.DefaultRequestHeaders.Add("X-Auth-Token", authHeader);
                    }
                    response = await httpClient.PostAsync(requestUrl, new StringContent(json));
                    if (response.IsSuccessStatusCode == false)
                    {
                        throw new HttpRequestException(((int)response.StatusCode).ToString());
                    }
                    break;
                case RequestMethod.Put:
                    httpClient.DefaultRequestHeaders.Add("X-Auth-Token", authHeader);
                    response =
                        await httpClient.PutAsync(requestUrl, new StringContent(json));
                    if (response.IsSuccessStatusCode == false)
                    {
                        throw new HttpRequestException(((int)response.StatusCode).ToString());
                    }
                    break;
                case RequestMethod.Get:
                    httpClient.DefaultRequestHeaders.Add("X-Auth-Token", authHeader);
                    response =
                        await httpClient.GetAsync(requestUrl);
                    if (response.IsSuccessStatusCode == false)
                    {
                        throw new HttpRequestException(((int)response.StatusCode).ToString());
                    }
                    break;
                case RequestMethod.Delete:
                    httpClient.DefaultRequestHeaders.Add("X-Auth-Token", authHeader);
                    var req = new HttpRequestMessage(HttpMethod.Delete, requestUrl);
                    req.Content = new StringContent(json);
                    response = await httpClient.SendAsync(req);
                    if (response.IsSuccessStatusCode == false)
                    {
                        throw new HttpRequestException(((int)response.StatusCode).ToString());
                    }
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(method), method, null);
            }
            return await response.Content.ReadAsStringAsync();
        }

 internal static RequestMethod PureRequestMethod(RequestMethod method)
 {
     switch (method)
     {
         case RequestMethod.ACL_GET:
             return RequestMethod.GET;
         case RequestMethod.ACL_SET:
             return RequestMethod.PUT;
         default:
             return method;
     }
 }