using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Media.Imaging;
using System.Windows;
using System.Windows.Media;
using System.IO;
using System.Diagnostics;
using System.Windows.Threading;
using System.Windows.Shapes;

namespace Microsoft.Research.DynamicDataDisplay.Common.Auxiliary
{
	internal static class ScreenshotHelper
	{
		/// <summary>Gets the encoder by extension</summary>
		/// <param name="extension">The extension</param>
		/// <returns>BitmapEncoder object</returns>
		internal static BitmapEncoder GetEncoderByExtension(string extension)
		{
			switch (extension)
			{
				case "bmp":
					return new BmpBitmapEncoder();
				case "jpg":
					return new JpegBitmapEncoder();
				case "gif":
					return new GifBitmapEncoder();
				case "png":
					return new PngBitmapEncoder();
				case "tiff":
					return new TiffBitmapEncoder();
				case "wmp":
					return new WmpBitmapEncoder();
				default:
					throw new ArgumentException(Strings.Exceptions.CannotDetermineImageTypeByExtension, "extension");
			}
		}

		/// <summary>Creates the screenshot of entire plotter element</summary>
		/// <returns></returns>
		internal static BitmapSource CreateScreenshot(UIElement uiElement, Int32Rect screenshotSource)
		{
			Window window = Window.GetWindow(uiElement);
			if (window == null)
			{
				return CreateElementScreenshot(uiElement);
			}
			Size size = window.RenderSize;

			//double dpiCoeff = 32 / SystemParameters.CursorWidth;
			//int dpi = (int)(dpiCoeff * 96);
			double dpiCoeff = 1;
			int dpi = 96;

			RenderTargetBitmap bmp = new RenderTargetBitmap(
				(int)(size.Width * dpiCoeff), (int)(size.Height * dpiCoeff),
				dpi, dpi, PixelFormats.Default);

			// white background
			Rectangle whiteRect = new Rectangle { Width = size.Width, Height = size.Height, Fill = Brushes.White };
			whiteRect.Measure(size);
			whiteRect.Arrange(new Rect(size));
			bmp.Render(whiteRect);
			// the very element
			bmp.Render(uiElement);

			CroppedBitmap croppedBmp = new CroppedBitmap(bmp, screenshotSource);
			return croppedBmp;
		}

		private static BitmapSource CreateElementScreenshot(UIElement uiElement)
		{
			bool measureValid = uiElement.IsMeasureValid;

			if (!measureValid)
			{
				double width = 300;
				double height = 300;

				FrameworkElement frElement = uiElement as FrameworkElement;
				if (frElement != null)
				{
					if (!Double.IsNaN(frElement.Width))
						width = frElement.Width;
					if (!Double.IsNaN(frElement.Height))
						height = frElement.Height;
				}

				Size size = new Size(width, height);
				uiElement.Measure(size);
				uiElement.Arrange(new Rect(size));
			}

			RenderTargetBitmap bmp = new RenderTargetBitmap(
				(int)uiElement.RenderSize.Width, (int)uiElement.RenderSize.Height,
				96, 96, PixelFormats.Default);

			// this is waiting for dispatcher to perform measure, arrange and render passes
			uiElement.Dispatcher.Invoke(((Action)(() => { })), DispatcherPriority.Background);

			Size elementSize = uiElement.DesiredSize;
			// white background
			Rectangle whiteRect = new Rectangle { Width = elementSize.Width, Height = elementSize.Height, Fill = Brushes.White };
			whiteRect.Measure(elementSize);
			whiteRect.Arrange(new Rect(elementSize));
			bmp.Render(whiteRect);

			bmp.Render(uiElement);

			return bmp;
		}

		private static Dictionary<BitmapSource, string> pendingBitmaps = new Dictionary<BitmapSource, string>();

		internal static void SaveBitmapToStream(BitmapSource bitmap, Stream stream, string fileExtension)
		{
			if (bitmap == null)
				throw new ArgumentNullException("bitmap");
			if (stream == null)
				throw new ArgumentNullException("stream");
			if (String.IsNullOrEmpty(fileExtension))
				throw new ArgumentException(Strings.Exceptions.ExtensionCannotBeNullOrEmpty, fileExtension);

			BitmapEncoder encoder = ScreenshotHelper.GetEncoderByExtension(fileExtension);
			encoder.Frames.Add(BitmapFrame.Create(bitmap, null, new BitmapMetadata(fileExtension.Trim('.')), null));
			encoder.Save(stream);
		}

		internal static void SaveBitmapToFile(BitmapSource bitmap, string filePath)
		{
			if (String.IsNullOrEmpty(filePath))
				throw new ArgumentException(Strings.Exceptions.FilePathCannotbeNullOrEmpty, "filePath");

			if (bitmap.IsDownloading)
			{
				pendingBitmaps[bitmap] = filePath;
				bitmap.DownloadCompleted += OnBitmapDownloadCompleted;
				return;
			}

			string dirPath = System.IO.Path.GetDirectoryName(filePath);
			if (!String.IsNullOrEmpty(dirPath) && !Directory.Exists(dirPath))
			{
				Directory.CreateDirectory(dirPath);
			}

			bool fileExistedBefore = File.Exists(filePath);
			try
			{
				using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
				{
					string extension = System.IO.Path.GetExtension(filePath).TrimStart('.');
					SaveBitmapToStream(bitmap, fs, extension);
				}
			}
			catch (ArgumentException)
			{
				if (!fileExistedBefore && File.Exists(filePath))
				{
					try
					{
						File.Delete(filePath);
					}
					catch { }
				}
			}
			catch (IOException exc)
			{
				Debug.WriteLine("Exception while saving bitmap to file: " + exc.Message);
			}
		}

		public static void SaveStreamToFile(Stream stream, string filePath)
		{
			string dirPath = System.IO.Path.GetDirectoryName(filePath);
			if (!String.IsNullOrEmpty(dirPath) && !Directory.Exists(dirPath))
			{
				Directory.CreateDirectory(dirPath);
			}

			using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
			{
				string extension = System.IO.Path.GetExtension(filePath).TrimStart('.');
				if (stream.CanSeek)
					stream.Seek(0, SeekOrigin.Begin);

				stream.CopyTo(fs);
			}

			stream.Dispose();
		}

		private static void OnBitmapDownloadCompleted(object sender, EventArgs e)
		{
			BitmapSource bmp = (BitmapSource)sender;
			bmp.DownloadCompleted -= OnBitmapDownloadCompleted;
			string filePath = pendingBitmaps[bmp];
			pendingBitmaps.Remove(bmp);

			SaveBitmapToFile(bmp, filePath);
		}
	}
}