bool CreateThumbnail (SafeUri thumbnailUri, ThumbnailSize size, IImageFile imageFile)
		{
			var pixels = size == ThumbnailSize.Normal ? 128 : 256;
			Pixbuf pixbuf;
			try {
				pixbuf = imageFile.Load ();
			} catch (Exception e) {
				Log.DebugFormat ("Failed loading image for thumbnailing: {0}", imageFile.Uri);
				Log.DebugException (e);
				return false;
			}

			double scale_x = (double)pixbuf.Width / pixels;
			double scale_y = (double)pixbuf.Height / pixels;
			double scale = Math.Max (1.0, Math.Max (scale_x, scale_y));
			// Ensures that the minimum value is 1 so that pixbuf.ScaleSimple doesn't return null
			// Seems to only happen in rare(?) cases
			int target_x = Math.Max ((int)(pixbuf.Width / scale), 1);
			int target_y = Math.Max ((int)(pixbuf.Height / scale), 1);

			var thumb_pixbuf = pixbuf.ScaleSimple (target_x, target_y, InterpType.Bilinear);
			var mtime = fileSystem.File.GetMTime (imageFile.Uri).ToString ();
			thumb_pixbuf.Savev (thumbnailUri.LocalPath, "png",
				new string [] { ThumbnailService.ThumbUriOpt, ThumbnailService.ThumbMTimeOpt, null },
				new string [] { imageFile.Uri, mtime });

			pixbuf.Dispose ();
			thumb_pixbuf.Dispose ();

			return true;
		}

		public bool TryCreateThumbnail (SafeUri thumbnailUri, ThumbnailSize size)
		{
			try {
				var imageFile = ImageFile.Create (fileUri);
				return CreateThumbnail (thumbnailUri, size, imageFile);
			}
			catch {
				return false;
			}
		}

 public ThumbnailKey GetDeceasedThumbnailKey(ThumbnailSize size, int thumbIndex)
 {
     if (mSim is MiniSimDescription)
     {
         return GetThumbnailKey(size, thumbIndex);
     }
     else
     {
         return mSim.GetDeceasedThumbnailKey(size, thumbIndex);
     }
 }

 public static string GetThumbnailImageUrl(string id, ThumbnailSize size = ThumbnailSize.Small)
 {
     switch (size)
     {
         case ThumbnailSize.Large:
             return string.Format("//i.ytimg.com/vi/{0}/hqdefault.jpg", id);
         case ThumbnailSize.Medium:
             return string.Format("//i.ytimg.com/vi/{0}/mqdefault.jpg", id);
         default:
             return string.Format("//i.ytimg.com/vi/{0}/default.jpg", id);
     }
 }

		public Pixbuf GetThumbnail (SafeUri fileUri, ThumbnailSize size)
		{
			var thumbnailUri = GetThumbnailPath (fileUri, size);
			var thumbnail = LoadThumbnail (thumbnailUri);
			if (IsValid (fileUri, thumbnail))
				return thumbnail;
			IThumbnailer thumbnailer = thumbnailerFactory.GetThumbnailerForUri (fileUri);
			if (thumbnailer == null)
				return null;
			return !thumbnailer.TryCreateThumbnail (thumbnailUri, size)
				? null
				: LoadThumbnail (thumbnailUri);
		}

 /// <summary>
 /// Converts a <see cref="ThumbnailSize"/> to string.
 /// </summary>
 /// <param name="sz"></param>
 /// <returns></returns>
 public static string ThumbnailSizeToURIString(ThumbnailSize sz)
 {
     switch (sz)
     {
         case ThumbnailSize.BigSquare: return "b";
         case ThumbnailSize.Huge: return "h";
         case ThumbnailSize.Large: return "l";
         case ThumbnailSize.Medium: return "m";
         case ThumbnailSize.Small: return "t";
         case ThumbnailSize.SmallSquare: return "s";
         default:
             throw new Exception("Invalid ThumbnailSize!");
     }
 }

 public void ThumbnailMaxHeight(ThumbnailSize size)
 {
     File file = null;
     try
     {
         file = PostImageFile("testimage.jpg");
         Image thumbnail = GetThumbnail(file, maxHeight: size);
         Assert.That(thumbnail, Is.Not.Null);
         Assert.That(thumbnail.Height, Is.LessThanOrEqualTo(int.Parse(size.Description())));
     }
     finally
     {
         Client.Delete(file);
     }
 }

 public void ThumbnailHeightBounded(ThumbnailSize minHeight, ThumbnailSize maxHeight)
 {
     File file = null;
     try
     {
         file = PostImageFile("testimage.jpg");
         Image thumbnail = GetThumbnail(file, minHeight: minHeight, maxHeight: maxHeight);
         Assert.That(thumbnail, Is.Not.Null);
         Assert.That(thumbnail.Height, Is.GreaterThanOrEqualTo(int.Parse(minHeight.Description())));
         Assert.That(thumbnail.Height, Is.LessThanOrEqualTo(int.Parse(maxHeight.Description())));
     }
     finally
     {
         Client.Delete(file);
     }
 }

        public static Pixbuf LoadThumbnail(SafeUri uri, ThumbnailSize size, PixbufLoader loader)
        {
            var thumb_uri = ThumbUri (uri, size);
            var pixbuf = LoadFromUri (thumb_uri);
            if (!IsValid (uri, pixbuf)) {
                Log.DebugFormat ("Invalid thumbnail, reloading: {0}", uri);
                if (pixbuf != null)
                    pixbuf.Dispose ();

                if (loader == null)
                    return null;

                pixbuf = CreateFrom (uri, thumb_uri, size, loader);
            }
            return pixbuf;
        }

 /// <summary>
 /// Converts the ThumbnailSize enum to the string equivalent for the API
 /// </summary>
 /// <param name="size"></param>
 /// <returns></returns>
 private string ThumbnailSizeString(ThumbnailSize size)
 {
     switch (size)
     {
         case ThumbnailSize.Small:
             return "small";
         case ThumbnailSize.Medium:
             return "medium";
         case ThumbnailSize.Large:
             return "large";
         case ThumbnailSize.ExtraLarge:
             return "l";
         case ThumbnailSize.ExtraLarge2:
             return "xl";
     }
     return "s";
 }

        public static ThumbnailKey GetThumbnailKey(IMiniSimDescription ths, ThumbnailSize size, int thumbIndex)
        {
            try
            {
                if (ths == null) return ThumbnailKey.kInvalidThumbnailKey;

                MiniSimDescription miniSim = ths as MiniSimDescription;
                if (miniSim != null)
                {
                    if (!ThumbnailManager.KeyExistsInDB(miniSim.mThumbKey))
                    {
                        SimDescription sim = MiniSims.UnpackSim(miniSim);

                        ThumbnailKey thumbnailKey = sim.GetThumbnailKey(ThumbnailSize.Large, 0x0);

                        try
                        {
                            sim.Dispose(false, true);
                        }
                        catch (Exception e)
                        {
                            Common.Exception(sim, e);
                        }

                        return thumbnailKey;
                    }

                    return miniSim.mThumbKey;
                }
                else if ((ths.CASGenealogy == null) || (ths.CASGenealogy.IsAlive()))
                {
                    return ths.GetThumbnailKey(size, thumbIndex);
                }
                else
                {
                    return ths.GetDeceasedThumbnailKey(size, thumbIndex);
                }
            }
            catch (Exception e)
            {
                Common.Exception(ths.FullName, e);
                return ThumbnailKey.kInvalidThumbnailKey;
            }
        }

		/// <summary>
		/// Gets a thumbnail image for the virtual machine (Implementation).
		/// </summary>
		/// <param name="vmId">Virtual machine id, represented by Guid (for example "4664215D-D195-4E35-BB6F-BFC1F17666EB").</param>
		/// <param name="size">Size of the thumbnail being requested</param>
		/// <returns>Array of bytes representing the virtual machine thumbnail image requested.</returns>
		private byte[] GetTumbnailFromSummaryInformation(string vmName, ThumbnailSize size)
		{
			int width = 80;
			int height = 60;

			if (size == ThumbnailSize.Medium160x120)
			{
				width = 160;
				height = 120;
			}
			else if (size == ThumbnailSize.Large320x240)
			{
				width = 320;
				height = 240;
			}

			lock (HostinfoByVMName)
			{
				if (!HostinfoByVMName.ContainsKey(vmName))
				{
					using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
					{
						VirtualMachineInfo vminfo = client.GetVirtualMachineByName(vmName);
						if (vminfo != null)
						{
							HostInfo host = client.GetHostById(vminfo.HostId);

							HostinfoByVMName.Add(vmName, host);
						}
					}
				}
			}

			HostInfo hostInfo = null;

			HostinfoByVMName.TryGetValue(vmName, out hostInfo);

			byte[] imgData = null;

			if (hostInfo != null)
			{
				using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
				{
					try
					{
						imgData = client.GetVirtualSystemThumbnailImage(width, height, vmName, hostInfo.ComputerName);
					}
					catch (Exception ex)
					{
						imgData = null;
						//
						Log.WriteError(ex);
					}
				}
			}

			// Create new bitmap
			if (imgData == null)
			{
				using (Bitmap bmp = new Bitmap(width, height))
				{
					Graphics g = Graphics.FromImage(bmp);
					SolidBrush brush = new SolidBrush(Color.LightGray);
					g.FillRectangle(brush, 0, 0, width, height);

					using (MemoryStream stream = new MemoryStream())
					{
						bmp.Save(stream, ImageFormat.Png);
						imgData = stream.ToArray();
					}
				}
			}

			return imgData;
		}

		/// <summary>
		/// Gets a thumbnail image for the virtual machine (Wrapper).
		/// </summary>
		/// <param name="vmId">Virtual machine id, represented by Guid (for example "4664215D-D195-4E35-BB6F-BFC1F17666EB").</param>
		/// <param name="size">Size of the thumbnail being requested</param>
		/// <returns>Array of bytes representing the virtual machine thumbnail image requested.</returns>
		public byte[] GetVirtualMachineThumbnailImage(string vmId, ThumbnailSize size)
		{
			return GetTumbnailFromSummaryInformation(vmId, size);
		}

		public byte[] GetSnapshotThumbnailImage(string snapshotId, ThumbnailSize size)
		{
			//            ManagementBaseObject objSummary = GetSnapshotSummaryInformation(snapshotId, (SummaryInformationRequest)size);

			using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
			{

				VirtualMachineInfo vminfo = client.GetVirtualMachineByName(snapshotId);
				HostInfo host = client.GetHostById(vminfo.HostId);

				return GetTumbnailFromSummaryInformation(vminfo.Name, size);
			}
		}

        /// <summary>
        /// This method returns the thumbnails of a specific file by ID
        /// </summary>
        /// <param name="driveId">The ID of the target drive</param>
        /// <param name="fileId">The ID of the target file</param>
        /// <returns>The file thumbnails for the specific file</returns>
        public static Stream GetFileThumbnailImage(String driveId, String fileId, ThumbnailSize size)
        {
            String jsonResponse = MicrosoftGraphHelper.MakeGetRequestForString(
                String.Format("{0}drives/{1}/items/{2}/thumbnails/0/{3}",
                    MicrosoftGraphHelper.MicrosoftGraphV1BaseUri,
                    driveId,
                    fileId,
                    size.ToString().ToLower()));

            var thumbnail = JsonConvert.DeserializeObject<Thumbnail>(jsonResponse);

            var thumbnailImageStream = MicrosoftGraphHelper.MakeGetRequestForStream(
                thumbnail.Url,
                "image/jpeg");

            return (thumbnailImageStream);
        }

        /// <summary>
        /// <para>Begins an asynchronous send to the get thumbnail route.</para>
        /// </summary>
        /// <param name="path">The path to the image file you want to thumbnail.</param>
        /// <param name="format">The format for the thumbnail image, jpeg (default) or png. For
        /// images that are photos, jpeg should be preferred, while png is  better for
        /// screenshots and digital arts.</param>
        /// <param name="size">The size for the thumbnail image.</param>
        /// <param name="callback">The method to be called when the asynchronous send is
        /// completed.</param>
        /// <param name="callbackState">A user provided object that distinguished this send
        /// from other send requests.</param>
        /// <returns>An object that represents the asynchronous send request.</returns>
        public sys.IAsyncResult BeginGetThumbnail(string path,
                                                  ThumbnailFormat format = null,
                                                  ThumbnailSize size = null,
                                                  sys.AsyncCallback callback = null,
                                                  object callbackState = null)
        {
            var thumbnailArg = new ThumbnailArg(path,
                                                format,
                                                size);

            return this.BeginGetThumbnail(thumbnailArg, callback, callbackState);
        }

        public RestRequest CreateThumbnailRequest(string path, ThumbnailSize size, string root)
        {
            var request = new RestRequest(Method.GET);
            request.Resource = "{version}/thumbnails/{root}{path}";

            request.AddParameter("version", _version, ParameterType.UrlSegment);
            request.AddParameter("path", path, ParameterType.UrlSegment);
            request.AddParameter("root", root, ParameterType.UrlSegment);
            request.AddParameter("size", ThumbnailSizeString(size));

            return request;
        }

        /// <summary>
        /// Gets the thumbnail of an image given its path
        /// </summary>
        /// <param name="path"></param>
        /// <param name="size"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<byte[]> GetThumbnail(string path, ThumbnailSize size, CancellationToken cancellationToken)
        {
            var request = MakeThumbnailRequest(path, size);

            var response = await _httpClient.SendAsync(request, cancellationToken);

            return await response.Content.ReadAsByteArrayAsync();
        }

 /// <summary>
 /// Gets the thumbnail of an image given its MetaData
 /// </summary>
 /// <param name="file"></param>
 /// <param name="size"></param>
 /// <returns></returns>
 public byte[] GetThumbnail(MetaData file, ThumbnailSize size)
 {
     return GetThumbnail(file.Path, size);
 }

 /// <remarks/>
 public void GetVirtualMachineThumbnailAsync(int itemId, ThumbnailSize size) {
     this.GetVirtualMachineThumbnailAsync(itemId, size, null);
 }