static async void upload_image(string path)
        {
            Console.WriteLine("Uploading {0}", path);
            try {
                using (var client = new HttpClient()) {
                    using (var stream = File.OpenRead(path)) {
                        var content = new MultipartFormDataContent();
                        var file_content = new ByteArrayContent(new StreamContent(stream).ReadAsByteArrayAsync().Result);
                        file_content.Headers.ContentType = new MediaTypeHeaderValue("image/png");
                        file_content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                        {
                            FileName = "screenshot.png",
                            Name = "foo",
                        };
                        content.Add(file_content);
                        client.BaseAddress = new Uri("https://pajlada.se/poe/imgup/");
                        var response = await client.PostAsync("upload.php", content);
                        response.EnsureSuccessStatusCode();
                        Console.WriteLine("Done");
                    }
                }

            } catch (Exception) {
                Console.WriteLine("Something went wrong while uploading the image");
            }
        }

        public string SendAddressesToApi(string csvPath)
        {
            using (var client = new HttpClient())
            {
                client.BaseAddress = new Uri(CensusBatchGeoCodeUri);
                var content = new MultipartFormDataContent();

                var fileContent = new ByteArrayContent(System.IO.File.ReadAllBytes("addresses.csv"));
                fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "addressFile",
                    FileName = "addresses.csv"
                };
                fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
                content.Add(fileContent);

                // Not a FormUrlEncodedContent class due to an ostensible bug in census API that
                // rejects key/value formatting and requires 'benchmark' in a 'name' field
                var benchMarkContent = new StringContent("9");
                benchMarkContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "benchmark"
                };
                content.Add(benchMarkContent);

                var result = client.PostAsync("", content).Result;
                string resultContent = result.Content.ReadAsStringAsync().Result;
                return resultContent;
            }
        }

        public void CreateBlob(Guid id, byte[] content, string fileName)
        {
            var bytes = new ByteArrayContent(content);
            bytes.Headers.ContentDisposition = new ContentDispositionHeaderValue("file") { FileName = fileName };
            bytes.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");

            var request = new HttpRequestMessage(HttpMethod.Post, String.Format("/blobs/{0}", id)) { Content = bytes };

            var response = _httpClient.SendAsync(request);

            try
            {
                var result = response.Result;
                var statusCode = result.StatusCode;
                if (statusCode == HttpStatusCode.Created)
                {
                    return;
                }

                RaiseResponseError(request, result);
            }
            finally
            {
                Dispose(request, response);
            }
        }

        public void ContentLength_UsePartialSourceArray_LengthMatchesArrayLength()
        {
            var contentData = new byte[10];
            var content = new ByteArrayContent(contentData, 5, 3);

            Assert.Equal(3, content.Headers.ContentLength);
        }

        public void ContentLength_UseWholeSourceArray_LengthMatchesArrayLength()
        {
            var contentData = new byte[10];
            var content = new ByteArrayContent(contentData);

            Assert.Equal(contentData.Length, content.Headers.ContentLength);
        }

        /// <summary>
        /// Create Multipart form-data HTTP Post to upload file to S3.
        /// </summary>
        /// <param name="s3Bucket">The Amazon S3 bucket name.</param>
        /// <param name="formData">The JSON object containing the pre-signed URL data.</param>
        /// <param name="mimeType">The MIME type of the file to be uploaded.</param>
        /// <param name="compressedFile">The gzipped file contents.</param>
        /// <returns>BlipResponse object with a status code and body text if applicable.</returns>
        private static BlipResponse PostFile(string s3Bucket, string formData, string mimeType, byte[] compressedFile)
        {
            HttpResponseMessage response;
            dynamic data = JsonConvert.DeserializeObject(formData);

            using (var client = new HttpClient())
            {
                var url = $"https://s3.amazonaws.com/{s3Bucket}";
                var requestContent = new MultipartFormDataContent();
                var fileContent = new ByteArrayContent(compressedFile);
                fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(mimeType);
                
                // Special parsing required due to a hyphen in the key
                string contentMd5 = JObject.Parse(data.ToString())["content-md5"];

                requestContent.Add(new StringContent(data.acl.ToString()), "acl");
                requestContent.Add(new StringContent(data.bucket.ToString()), "bucket");
                requestContent.Add(new StringContent(data.key.ToString()), "key");
                requestContent.Add(new StringContent(contentMd5), "content-md5");
                requestContent.Add(new StringContent(data.policy.ToString()), "policy");
                requestContent.Add(new StringContent(data.signature.ToString()), "signature");
                requestContent.Add(new StringContent(data.AWSAccessKeyId.ToString()), "AWSAccessKeyId");
                requestContent.Add(new StringContent(mimeType), "content-type");
                requestContent.Add(fileContent, "file"); // The file must be added last
                
                response = client.PostAsync(url, requestContent).Result;
            }

            var statusCode = (int)response.StatusCode;

            // If the upload is not successful return the error message from S3 else return success response
            return statusCode != 204 ? new BlipResponse(statusCode, response.Content.ToString()) : new BlipResponse(statusCode, "");
        }

        protected override HttpRequestMessage BuildMessage(IRestRequest request)
        {
            // Create message content
            var content = new MultipartFormDataContent();
            foreach (var param in request.Parameters) {
                var file = param.Value as FileParameter;

                if (file != null) {
                    var contentPart = new ByteArrayContent(file.Content);
                    contentPart.Headers.Add("Content-Type", file.ContentType);
                    content.Add(contentPart, param.Key, file.Name);
                }
                else {
                    var contentPart = new StringContent(param.Value.ToString());
                    content.Add(contentPart, param.Key);
                }
            }

            // Build message
            var message = new HttpRequestMessage(request.Verb.ToHttpMethod(), request.Command) {
                Content = content
            };

            return message;
        }

        public async Task<bool> UploadBytes(string url, byte[] data)
        {
            try
            {
                if (_networkInformation.QuickNetworkCheck())
                {
                    var native = new NativeMessageHandler();

                    var httpClient = new HttpClient(native);
                    var message = new HttpRequestMessage(HttpMethod.Post, url);

                    native.RegisterForProgress(message, (bytes, totalBytes, expected) => new TransferProgressMessage(url, bytes, totalBytes, expected, true).Send());

                    var content = new ByteArrayContent(data);

                    message.Content = content;

                    var result = await httpClient.SendAsync(message);
                    return result.IsSuccessStatusCode;
                }
            }
            catch
            {
                Debug.WriteLine("WARNING: Could not upload: {0}", url);
            }

            return false;
        }

        /// <summary>
        /// Assincronouslly send the fields in the list to webServer in url parameter
        /// NextStep: add a percentage of uploaded data!
        /// </summary>
        /// <param name="fields"></param>
        /// <param name="url"></param>
        /// <returns></returns>
        internal static async Task<string> send(List<field> fields, string url)
        {
            HttpClient httpClient = new HttpClient();
            MultipartFormDataContent form = new MultipartFormDataContent();

            foreach(field f in fields)
            {
                if(f.kind == fieldKind.text)
                {
                    form.Add(new StringContent(f.content), f.name);
                }
                else if (f.kind == fieldKind.file)
                {
                    HttpContent content = new ByteArrayContent(f.bytes);
                    content.Headers.Add("Content-Type", f.contentType);
                    form.Add(content, f.name, f.fileName);
                }
            }

            HttpResponseMessage response = await httpClient.PostAsync(url, form);

            response.EnsureSuccessStatusCode();
            httpClient.Dispose();
            return response.Content.ReadAsStringAsync().Result;
        }

        private static void SendImageSet(ImageSet imageSet)
        {
            var multipartContent = new MultipartFormDataContent();

            var imageSetJson = JsonConvert.SerializeObject(imageSet,
                new JsonSerializerSettings
                {
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                });

            multipartContent.Add(new StringContent(imageSetJson, Encoding.UTF8, "application/json"), "imageset");

            int counter = 0;
            foreach (var image in imageSet.Images)
            {
                var imageContent = new ByteArrayContent(image.ImageData);
                imageContent.Headers.ContentType = new MediaTypeHeaderValue(image.MimeType);
                multipartContent.Add(imageContent, "image" + counter++, image.FileName);
            }

            var response = new HttpClient()
                .PostAsync("http://localhost:53908/api/send", multipartContent)
                .Result;

            var responseContent = response.Content.ReadAsStringAsync().Result;
            Trace.Write(responseContent);
        }

        public void Should_Accept_Only_Text_Content()
        {
            // Arrange
            Mock<IStorageRepository> storageRepositoryMock;
            Mock<IFileProcessor> fileProcessorMock;
            Mock<IChecksumCalculator> checksumCalculatorMock;
            Mock<IMetadataRepository> metadataRepositoryMock;
            var controller = this.ConfigureController(out storageRepositoryMock, out fileProcessorMock, out checksumCalculatorMock, out metadataRepositoryMock);

            var multipartContent = new MultipartFormDataContent();
            var binaryContent = Enumerable.Repeat(Enumerable.Range(14, 255).ToArray(), 20).SelectMany(x => x.Select(y => y)).Select(x=>(byte)x).ToArray();
            var fileContent = new ByteArrayContent(binaryContent);
            fileContent.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment") { FileName = "Test.txt" };
            fileContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("something/that_we_dont_expect");
            multipartContent.Add(fileContent);
            controller.Request.Content = multipartContent;

            // Act
            Task<IHttpActionResult> task = controller.Post();
            task.Wait();

            // Assert
            GenericValueResult<List<MetadataInfo>> result = task.Result as GenericValueResult<List<MetadataInfo>>;
            result.Should().NotBeNull("Wrong data type was returned from the controller");

            var t = result.Value as IEnumerable<Models.MetadataInfo>;
            t.Should().NotBeNull("Wrong data type was returned as a result of controller's work");

            var informationFromService = t.First();
            informationFromService.Id.Should().NotHaveValue();
            informationFromService.ProcessingResult.Should().Be(UploadController.ContentTypeCannotBeAcceptedMessage);
        }

        public async Task<HttpResponseMessage> GetImage(string name)
        {
            var userEmails = await UsersForHub();
            if (userEmails == null)
            {
                Services.Log.Error("No logged in user", null, "SetupToken");
                return new HttpResponseMessage(HttpStatusCode.Unauthorized);
            }

            byte[] imageBytes = null;
            foreach (var email in userEmails)
            {
                if (imageBytes == null)
                {
                    imageBytes = await GetStatusImageBytesForUser(email, name);
                }
            }

            if (imageBytes != null)
            {
                var content = new ByteArrayContent(imageBytes);
                content.Headers.ContentType = new MediaTypeHeaderValue("image/png");

                return new HttpResponseMessage(HttpStatusCode.OK) { Content = content };
            }
            else
            {
                Services.Log.Error(string.Format("Status image {0} not found", name));
                return new HttpResponseMessage(HttpStatusCode.NotFound);
            }
        }

 public ElasticsearchResponse DoSyncRequest(string method, Uri uri, byte[] data = null)
 {
     var client = new System.Net.Http.HttpClient();
     HttpResponseMessage response = null;
     byte[] result = null;
     HttpContent content = null;
     if (data != null)
         content = new ByteArrayContent(data);
     switch (method.ToLower())
     {
         case "head":
             response = client.SendAsync(new HttpRequestMessage(HttpMethod.Head, uri) ).Result;
             result = response.Content.ReadAsByteArrayAsync().Result;
             break;
         case "delete":
             response = client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, uri) { Content = content }).Result;
             result = response.Content.ReadAsByteArrayAsync().Result;
             break;
         case "put":
             response = client.PutAsync(uri, content).Result;
             result = response.Content.ReadAsByteArrayAsync().Result;
             break;
         case "post":
             response = client.PostAsync(uri, content).Result;
             result = response.Content.ReadAsByteArrayAsync().Result;
             break;
         case "get":
             response = client.GetAsync(uri).Result;
             result = response.Content.ReadAsByteArrayAsync().Result;
             break;
     }
     return ElasticsearchResponse.Create(this._settings, (int)response.StatusCode, method, uri.ToString(), data, result);
 }

        public async Task<string> CreatePageForIncidentAsync(string siteRootDirectory, string sectionId, Incident incident, IEnumerable<FileContent> inspectionPhotos, IEnumerable<Video> incidentVideos)
        {
            var templateFile = Path.Combine(siteRootDirectory, @"Templates\IncidentOneNotePage.cshtml");
            var template = System.IO.File.ReadAllText(templateFile);
            var viewBag = new RazorEngine.Templating.DynamicViewBag();
            viewBag.AddValue("InspectionPhotos", inspectionPhotos);
            viewBag.AddValue("IncidentVideos", incidentVideos);

            var html = RazorEngine.Engine.Razor.RunCompile(template, "IncidentOneNotePage", typeof(Incident), incident, viewBag);
            var content = new MultipartFormDataContent();
            content.Add(new StringContent(html, Encoding.UTF8, "text/html"), "Presentation");

            foreach (var image in inspectionPhotos)
            {
                var itemContent = new ByteArrayContent(image.Bytes);
                var contentType = MimeMapping.GetMimeMapping(image.Name);
                itemContent.Headers.ContentType = new MediaTypeHeaderValue(contentType);
                content.Add(itemContent, image.Id);
            }

            this.pageEndPoint = string.Format("{0}/sections/{1}/pages", serviceBaseUrl, sectionId);
            var requestMessage = new HttpRequestMessage(HttpMethod.Post, pageEndPoint);
            requestMessage.Content = content;

            var responseMessage = await HttpSendAsync(requestMessage, accessToken);
            if (responseMessage.StatusCode != System.Net.HttpStatusCode.Created)
                throw new HttpResponseException(responseMessage.StatusCode);

            var reponseObject = await GetReponseObjectAsync(responseMessage);
            return (string)reponseObject.links.oneNoteWebUrl.href;
        }

        public async Task<bool> UploadBytes(string url, byte[] data)
        {
            try
            {
                if (_networkInformation.QuickNetworkCheck())
                {
                    var h = new NativeMessageHandler();
                
                    var httpClient = new HttpClient(h);
                    var message = new HttpRequestMessage(HttpMethod.Post, url);

                    var content = new ByteArrayContent(data);

                    message.Content = content;

                    var result = await httpClient.SendAsync(message);
                    return result.IsSuccessStatusCode;
                }
            }
            catch
            {
                Debug.WriteLine("WARNING: Could not upload: {0}", url);
            }

            return false;
        }

        ///// <summary>
        ///// 
        ///// </summary>
        ///// <param name="actContext"></param>
        //public override void OnActionExecuted(HttpActionExecutedContext actContext)
        //{
        //    var content = actContext.Response.Content;
        //    if (content != null)
        //    {
        //        string encoding = null;
        //        CompressionType compressionType = GetCompressionType(actContext.Request, out encoding);
        //        if (compressionType != CompressionType.None)
        //        {
        //            var bytes = content.ReadAsByteArrayAsync().Result;
        //            if (bytes != null)
        //            {
        //                byte[] zlibbedContent = null;
        //                zlibbedContent = CompressionHelper.CompressionByte(bytes, compressionType);
        //                var newContent = new ByteArrayContent(zlibbedContent);
        //                newContent.Headers.Add("Content-encoding", encoding);
        //                newContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content.Headers.ContentType.MediaType);

        //                actContext.Response.Content = newContent;
        //            }
        //        }

        //    }

        //    base.OnActionExecuted(actContext);
        //}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="actionExecutedContext"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public override async Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            var content = actionExecutedContext.Response.Content;
            if (content != null)
            {
                string encoding = null;
                CompressionType compressionType = GetCompressionType(actionExecutedContext.Request, out encoding);
                if (compressionType != CompressionType.None)
                {
                    var bytes = content.ReadAsByteArrayAsync().Result;
                    if (bytes != null)
                    {
                        byte[] zlibbedContent = null;
                        zlibbedContent = await CompressionHelper.CompressionByteAsync(bytes, compressionType);
                        var newContent = new ByteArrayContent(zlibbedContent);
                        newContent.Headers.Add("Content-encoding", encoding);
                        newContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content.Headers.ContentType.MediaType);

                        actionExecutedContext.Response.Content = newContent;
                    }
                }

            }
            await base.OnActionExecutedAsync(actionExecutedContext, cancellationToken);
        }

        public async Task Handle200AndContentType()
        {
            // Arrange
            JToken root = null;
            var machine = new HttpResponseMachine();

            machine.When(HttpStatusCode.OK, null, new MediaTypeHeaderValue("application/json"))
                .Then(async (l, r) =>
            {
                var text = await r.Content.ReadAsStringAsync();
                root = JToken.Parse(text);
            });

            machine.When(HttpStatusCode.OK, null, new MediaTypeHeaderValue("application/xml"))
                .Then(async (l, r) => { });

            var byteArrayContent = new ByteArrayContent(Encoding.UTF8.GetBytes("{\"hello\" : \"world\"}"));
            byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            
            // Act
            await machine.HandleResponseAsync("", new HttpResponseMessage(HttpStatusCode.OK) { Content = byteArrayContent});

            // Assert
            Assert.NotNull(root);
        }

        private async static Task<bool> SendMessageWithImageAsync(string message, string chatId, string messageId,
            Stream imageStream)
        {
            var tghttpClient = new HttpClient();
            imageStream.Seek(0, SeekOrigin.Begin);
            var buf = ReadFully(imageStream);

            var imageContent = new ByteArrayContent(buf);
            imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("image/png");

            // Send Message, as well as image
            var endpointUrl =
                        new Uri(string.Format(RequestTemplate.RpcOpUrl, RequestTemplate.AppId, "sendPhoto"));
            var content = new MultipartFormDataContent();
            /*content.Add(new FormUrlEncodedContent(new List<KeyValuePair<string,string>>
            {
                new KeyValuePair<string, string>("chat_id", chatId),
                new KeyValuePair<string, string>("reply_to_message_id", messageId),
                new KeyValuePair<string, string>("caption", message)
            }));*/
            content.Add(imageContent, "photo", string.Format("{0}.png", Guid.NewGuid()));
            content.Add(new ByteArrayContent(Encoding.UTF8.GetBytes(chatId)),"chat_id");
            content.Add(new ByteArrayContent(Encoding.UTF8.GetBytes(messageId)), "reply_to_message_id");
            content.Add(new ByteArrayContent(Encoding.UTF8.GetBytes(message)), "aptiond");
            var result = await
                tghttpClient.PostAsync(endpointUrl, content);
            var content2 = await result.Content.ReadAsStringAsync();
            return result.IsSuccessStatusCode;
        }

        static void Main(string[] args)
        {
            string url = "http://localhost:7375/";
            string path = @"D:\GraduationMusic\ATsednya\Tsedenia GM - Atalay.mp3";

            MemoryStream requestStream = new MemoryStream();
            Stream fileStream = File.Open(path, FileMode.Open);

            var byteFile = ReadFully(fileStream);

            var base64Doc = Convert.ToBase64String(byteFile);

            HttpContent content = new ByteArrayContent(byteFile);

            using (var client = new HttpClient())
            {
                client.BaseAddress = new Uri(url);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                // New code:
                HttpResponseMessage response = client.PostAsync("api/trackdata/file", content).Result;

                var result = response.Content;

            }
        }

        public void Ctor()
        {
            byte[] b = { 4, 6 };

            using (var m = new ByteArrayContent (b)) {
            }
        }