//
// Icon class testing unit
//
// Authors:
//	Gary Barnett <gary.barnett.mono@gmail.com>
// 	Sanjay Gupta <gsanjay@novell.com>
//	Sebastien Pouliot  <sebastien@ximian.com>
//
// Copyright (C) 2004,2006-2008 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Reflection;
using System.Security.Permissions;
using NUnit.Framework;

namespace MonoTests.System.Drawing {

	[TestFixture]	
	public class IconTest {
		
		Icon icon;
		Icon icon16, icon32, icon48, icon64, icon96;
		FileStream fs1;

		static string filename_dll;

		// static ctor are executed outside the Deny
		static IconTest ()
		{
			filename_dll = Assembly.GetExecutingAssembly ().Location;
		}
		
		[SetUp]
		public void SetUp ()		
		{
			String path = TestBitmap.getInFile ("bitmaps/smiley.ico");
			icon = new Icon (path);			
			fs1 = new FileStream (path, FileMode.Open);

			icon16 = new Icon (TestBitmap.getInFile ("bitmaps/16x16x16.ico"));
			icon32 = new Icon (TestBitmap.getInFile ("bitmaps/32x32x16.ico"));
			icon48 = new Icon (TestBitmap.getInFile ("bitmaps/48x48x1.ico"));
			icon64 = new Icon (TestBitmap.getInFile ("bitmaps/64x64x256.ico"));
			icon96 = new Icon (TestBitmap.getInFile ("bitmaps/96x96x256.ico"));
		}

		[TearDown]
		public void TearDown ()
		{
			if (fs1 != null)
				fs1.Close ();
			if (File.Exists ("newIcon.ico"))
				File.Delete ("newIcon.ico");
		}

		[Test]
		public void TestConstructors ()
		{
			Assert.AreEqual (32, icon.Height, "C#0a");
			Assert.AreEqual (32, icon.Width, "C#0b");

			Icon newIcon = new Icon (fs1, 48, 48);
			Assert.AreEqual (48, newIcon.Height, "C#1a"); 			
			Assert.AreEqual (48, newIcon.Width, "C#1b");

			newIcon = new Icon (icon, 16, 16);
			Assert.AreEqual (16, newIcon.Height, "C#2a"); 			
			Assert.AreEqual (16, newIcon.Width, "C#2b");
		}

		[Test]
		public void Constructor_IconNull_Int_Int ()
		{
			Assert.Throws<ArgumentException> (() => new Icon ((Icon)null, 32, 32));
		}

		[Test]
		public void Constructor_Icon_IntNegative_Int ()
		{
			Icon neg = new Icon (icon, -32, 32);
			Assert.AreEqual (32, neg.Height, "Height");
			Assert.AreEqual (32, neg.Width, "Width");
		}

		[Test]
		public void Constructor_IconNull_Size ()
		{
			Assert.Throws<ArgumentException> (() => new Icon ((Icon) null, new Size (32, 32)));
		}

		[Test]
		public void Constructor_Icon_Size_Negative ()
		{
			Icon neg = new Icon (icon, new Size (-32, -32));
			Assert.AreEqual (16, neg.Height, "Height");
			Assert.AreEqual (16, neg.Width, "Width");
		}

		[Test]
		public void Constructor_Icon_Int_Int_NonSquare ()
		{
			Icon non_square = new Icon (icon, 32, 16);
			Assert.AreEqual (32, non_square.Height, "Height");
			Assert.AreEqual (32, non_square.Width, "Width");
		}

		[Test]
		public void Constructor_Icon_GetNormalSizeFromIconWith256 ()
		{
			string filepath = TestBitmap.getInFile ("bitmaps/323511.ico");

			Icon orig = new Icon (filepath);
			Assert.AreEqual (32,orig.Height);
			Assert.AreEqual (32,orig.Width);

			Icon ret = new Icon (orig, 48, 48);
			Assert.AreEqual (48, ret.Height);
			Assert.AreEqual (48, ret.Width);
		}

		[Test]
		public void Constructor_Icon_DoesntReturn256Passing0 ()
		{
			string filepath = TestBitmap.getInFile ("bitmaps/323511.ico");
			
			Icon orig = new Icon (filepath);
			Assert.AreEqual (32,orig.Height);
			Assert.AreEqual (32,orig.Width);
			
			Icon ret = new Icon (orig, 0, 0);
			Assert.AreNotEqual (0, ret.Height);
			Assert.AreNotEqual (0, ret.Width);
		}

		[Test]
		public void Constructor_Icon_DoesntReturn256Passing1 ()
		{
			string filepath = TestBitmap.getInFile ("bitmaps/323511.ico");
			
			Icon orig = new Icon (filepath);
			Assert.AreEqual (32,orig.Height);
			Assert.AreEqual (32,orig.Width);
			
			Icon ret = new Icon (orig, 1, 1);
			Assert.AreNotEqual (0, ret.Height);
			Assert.AreNotEqual (0, ret.Width);
		}

		[Test]
		public void Constructor_StreamNull ()
		{
			Assert.Throws<ArgumentException> (() => new Icon ((Stream) null));
		}

		[Test]
		public void Constructor_StreamNull_Int_Int ()
		{
			Assert.Throws<ArgumentException> (() => new Icon ((Stream) null, 32, 32));
		}

		[Test]
		public void Constructor_StringNull ()
		{
			Assert.Throws<ArgumentNullException> (() => new Icon ((string) null));
		}

		[Test]
		public void Constructor_TypeNull_String ()
		{
			Assert.Throws<NullReferenceException> (() => new Icon ((Type) null, "mono.ico"));
		}

		[Test]
		public void Constructor_Type_StringNull ()
		{
			Assert.Throws<ArgumentException> (() => new Icon (typeof (Icon), null));
		}
		[Test]
		public void Constructor_StreamNull_Size ()
		{
			Assert.Throws<ArgumentException> (() => new Icon ((Stream) null, new Size (32, 32)));
		}

		[Test]
		public void Constructor_StringNull_Size ()
		{
			Assert.Throws<ArgumentNullException> (() => new Icon ((string) null, new Size (32, 32)));
		}

		[Test]
		public void Constructor_StringNull_Int_Int ()
		{
			Assert.Throws<ArgumentNullException> (() => new Icon ((string) null, 32, 32));
		}

		[Test]
		public void TestProperties ()
		{
			Assert.AreEqual (32, icon.Height, "P#1");
			Assert.AreEqual (32, icon.Width, "P#2");
			Assert.AreEqual (32, icon.Size.Width, "P#3");
			Assert.AreEqual (32, icon.Size.Height, "P#4");
		}

		[Test]
		public void Clone ()
		{
			Icon clone = (Icon) icon.Clone ();
			Assert.AreEqual (32, clone.Height, "Height");
			Assert.AreEqual (32, clone.Width, "Width");
			Assert.AreEqual (32, clone.Size.Width, "Size.Width");
			Assert.AreEqual (32, clone.Size.Height, "Size.Height");
		}

		[Test]
		public void CloneHandleIcon ()
		{
			Icon clone = (Icon) Icon.FromHandle (SystemIcons.Hand.Handle).Clone ();
			Assert.AreEqual (SystemIcons.Hand.Height, clone.Height, "Height");
			Assert.AreEqual (SystemIcons.Hand.Width, clone.Width, "Width");
			Assert.AreEqual (SystemIcons.Hand.Size.Width, clone.Size.Width, "Size.Width");
			Assert.AreEqual (SystemIcons.Hand.Size.Height, clone.Size.Height, "Size.Height");
		}

		private void XPIcon (int size)
		{
			// note: the Icon(string,Size) or Icon(string,int,int) doesn't exists under 1.x
			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/32bpp.ico"))) {
				using (Icon xp = new Icon (fs, size, size)) {
					Assert.AreEqual (size, xp.Height, "Height");
					Assert.AreEqual (size, xp.Width, "Width");
					Assert.AreEqual (size, xp.Size.Width, "Size.Width");
					Assert.AreEqual (size, xp.Size.Height, "Size.Height");

					Bitmap bmp = xp.ToBitmap ();
					Assert.AreEqual (size, bmp.Height, "Bitmap.Height");
					Assert.AreEqual (size, bmp.Width, "Bitmap.Width");
					Assert.AreEqual (size, bmp.Size.Width, "Bitmap.Size.Width");
					Assert.AreEqual (size, bmp.Size.Height, "Bitmap.Size.Height");
				}
			}
		}

		[Test]
		public void Icon32bits_XP16 ()
		{
			XPIcon (16);
		}

		[Test]
		public void Icon32bits_XP32 ()
		{
			XPIcon (32);
		}

		[Test]
		public void Icon32bits_XP48 ()
		{
			XPIcon (48);
		}

		[Test]
		public void SelectFromUnusualSize_Small16 ()
		{
			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/80509.ico"))) {
				using (Icon xp = new Icon (fs, 16, 16)) {
					Assert.AreEqual (16, xp.Height, "Height");
					Assert.AreEqual (10, xp.Width, "Width");
					Assert.AreEqual (10, xp.Size.Width, "Size.Width");
					Assert.AreEqual (16, xp.Size.Height, "Size.Height");
				}
			}
		}

		[Test]
		public void SelectFromUnusualSize_Normal32 ()
		{
			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/80509.ico"))) {
				using (Icon xp = new Icon (fs, 32, 32)) {
					Assert.AreEqual (22, xp.Height, "Height");
					Assert.AreEqual (11, xp.Width, "Width");
					Assert.AreEqual (11, xp.Size.Width, "Size.Width");
					Assert.AreEqual (22, xp.Size.Height, "Size.Height");
				}
			}
		}

		internal static void SaveAndCompare (string msg, Icon icon, bool alpha)
		{
			using (MemoryStream ms = new MemoryStream ()) {
				icon.Save (ms);
				ms.Position = 0;

				using (Icon loaded = new Icon (ms)) {
					Assert.AreEqual (icon.Height, loaded.Height, msg + ".Loaded.Height");
					Assert.AreEqual (icon.Width, loaded.Width, msg + ".Loaded.Width");

					using (Bitmap expected = icon.ToBitmap ()) {
						using (Bitmap actual = loaded.ToBitmap ()) {
							Assert.AreEqual (expected.Height, actual.Height, msg + ".Bitmap.Height");
							Assert.AreEqual (expected.Width, actual.Width, msg + ".Bitmap.Width");

							for (int y = 0; y < expected.Height; y++) {
								for (int x = 0; x < expected.Width; x++) {
									Color e = expected.GetPixel (x, y);
									Color a = actual.GetPixel (x, y);
									if (alpha)
										Assert.AreEqual (e.A, a.A, String.Format ("{0}:{1}x{2}:A", msg, x, y));
									Assert.AreEqual (e.R, a.R, String.Format ("{0}:{1}x{2}:R", msg, x, y));
									Assert.AreEqual (e.G, a.G, String.Format ("{0}:{1}x{2}:G", msg, x, y));
									Assert.AreEqual (e.B, a.B, String.Format ("{0}:{1}x{2}:B", msg, x, y));
								}
							}
						}
					}
				}
			}
		}

		[Test]
		public void Save ()
		{
			SaveAndCompare ("16", icon16, true);
			SaveAndCompare ("32", icon32, true);
			SaveAndCompare ("48", icon48, true);
			SaveAndCompare ("64", icon64, true);
			SaveAndCompare ("96", icon96, true);
		}

		[Test] // bug #410608
		public void Save_256 ()
		{
			string filepath = TestBitmap.getInFile ("bitmaps/323511.ico");

			using (Icon icon = new Icon (filepath)) {
				// bug #415809 fixed
				SaveAndCompare ("256", icon, true);
			}

			// binary comparison
			var orig = new MemoryStream (File.ReadAllBytes (filepath));
			var saved = new MemoryStream ();
			using (Icon icon = new Icon (filepath))
				icon.Save (saved);
			FileAssert.AreEqual (orig, saved, "binary comparison");
		}

		[Test]
		public void Save_Null ()
		{
			Assert.Throws<NullReferenceException> (() => icon.Save (null));
		}

		[Test]
		public void Icon16ToBitmap ()
		{
			using (Bitmap b = icon16.ToBitmap ()) {
				Assert.AreEqual (PixelFormat.Format32bppArgb, b.PixelFormat, "PixelFormat");
				// unlike the GDI+ icon decoder the palette isn't kept
				Assert.AreEqual (0, b.Palette.Entries.Length, "Palette");
				Assert.AreEqual (icon16.Height, b.Height, "Height");
				Assert.AreEqual (icon16.Width, b.Width, "Width");
				Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "RawFormat");
				Assert.AreEqual (2, b.Flags, "Flags");
			}
		}

		[Test]
		public void Icon32ToBitmap ()
		{
			using (Bitmap b = icon32.ToBitmap ()) {
				Assert.AreEqual (PixelFormat.Format32bppArgb, b.PixelFormat, "PixelFormat");
				// unlike the GDI+ icon decoder the palette isn't kept
				Assert.AreEqual (0, b.Palette.Entries.Length, "Palette");
				Assert.AreEqual (icon32.Height, b.Height, "Height");
				Assert.AreEqual (icon32.Width, b.Width, "Width");
				Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "RawFormat");
				Assert.AreEqual (2, b.Flags, "Flags");
			}
		}

		[Test]
		public void Icon48ToBitmap ()
		{
			using (Bitmap b = icon48.ToBitmap ()) {
				Assert.AreEqual (PixelFormat.Format32bppArgb, b.PixelFormat, "PixelFormat");
				// unlike the GDI+ icon decoder the palette isn't kept
				Assert.AreEqual (0, b.Palette.Entries.Length, "Palette");
				Assert.AreEqual (icon48.Height, b.Height, "Height");
				Assert.AreEqual (icon48.Width, b.Width, "Width");
				Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "RawFormat");
				Assert.AreEqual (2, b.Flags, "Flags");
			}
		}

		[Test]
		public void Icon64ToBitmap ()
		{
			using (Bitmap b = icon64.ToBitmap ()) {
				Assert.AreEqual (PixelFormat.Format32bppArgb, b.PixelFormat, "PixelFormat");
				// unlike the GDI+ icon decoder the palette isn't kept
				Assert.AreEqual (0, b.Palette.Entries.Length, "Palette");
				Assert.AreEqual (icon64.Height, b.Height, "Height");
				Assert.AreEqual (icon64.Width, b.Width, "Width");
				Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "RawFormat");
				Assert.AreEqual (2, b.Flags, "Flags");
			}
		}

		[Test]
		public void Icon96ToBitmap ()
		{
			using (Bitmap b = icon96.ToBitmap ()) {
				Assert.AreEqual (PixelFormat.Format32bppArgb, b.PixelFormat, "PixelFormat");
				// unlike the GDI+ icon decoder the palette isn't kept
				Assert.AreEqual (0, b.Palette.Entries.Length, "Palette");
				Assert.AreEqual (icon96.Height, b.Height, "Height");
				Assert.AreEqual (icon96.Width, b.Width, "Width");
				Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "RawFormat");
				Assert.AreEqual (2, b.Flags, "Flags");
			}
		}

		[Test] // bug #415581
		public void Icon256ToBitmap ()
		{
			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/415581.ico"))) {
				Icon icon = new Icon (fs, 48, 48);
				using (Bitmap b = icon.ToBitmap ()) {
					Assert.AreEqual (0, b.Palette.Entries.Length, "#A1");
					Assert.AreEqual (48, b.Height, "#A2");
					Assert.AreEqual (48, b.Width, "#A3");
					Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "#A4");
					Assert.AreEqual (2, b.Flags, "#A5");
				}
				icon.Dispose ();
			}

			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/415581.ico"))) {
				Icon icon = new Icon (fs, 256, 256);
				using (Bitmap b = icon.ToBitmap ()) {
					Assert.AreEqual (0, b.Palette.Entries.Length, "#B1");
					Assert.AreEqual (48, b.Height, "#B2");
					Assert.AreEqual (48, b.Width, "#B3");
					Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "#B4");
					Assert.AreEqual (2, b.Flags, "#B5");
				}
			}
		}

		[Test]
		public void Icon256ToBitmap_Request0 ()
		{
			// 415581.ico has 2 images, the 256 and 48
			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/415581.ico"))) {
				Icon icon = new Icon (fs, 0, 0);
				using (Bitmap b = icon.ToBitmap ()) {
					Assert.AreEqual (0, b.Palette.Entries.Length, "#B1");
					Assert.AreEqual (48, b.Height, "#B2");
					Assert.AreEqual (48, b.Width, "#B3");
					Assert.IsTrue (b.RawFormat.Equals (ImageFormat.MemoryBmp), "#B4");
					Assert.AreEqual (2, b.Flags, "#B5");
				}
			}
		}

		[Test]
		public void Only256InFile ()
		{
			using (FileStream fs = File.OpenRead (TestBitmap.getInFile ("bitmaps/only256.ico"))) {
				Assert.Throws<Win32Exception> (() => new Icon (fs, 0, 0));
			}
		}


		[Test]
		public void ExtractAssociatedIcon_Null ()
		{
			Assert.Throws<ArgumentException> (() => Icon.ExtractAssociatedIcon (null));
		}

		[Test]
		public void ExtractAssociatedIcon_Empty ()
		{
			Assert.Throws<ArgumentException> (() => Icon.ExtractAssociatedIcon (String.Empty));
		}

		[Test]
		public void ExtractAssociatedIcon_DoesNotExists ()
		{
			Assert.Throws<FileNotFoundException> (() => Icon.ExtractAssociatedIcon ("does-not-exists.png"));
		}

		private static bool RunningOnUnix {
			get {
				int p = (int) Environment.OSVersion.Platform;

				return (p == 4) || (p == 6) || (p == 128);
			}
		}
	}

	[TestFixture]
	public class IconFullTrustTest {
		[Test]
		public void ExtractAssociatedIcon ()
		{
			string filename_dll = Assembly.GetExecutingAssembly ().Location;
			Assert.IsNotNull (Icon.ExtractAssociatedIcon (filename_dll), "dll");
		}

		[Test]
		public void HandleRoundtrip ()
		{
			IntPtr handle;
			using (Icon icon = new Icon (TestBitmap.getInFile ("bitmaps/16x16x16.ico"))) {
				Assert.AreEqual (16, icon.Height, "Original.Height");
				Assert.AreEqual (16, icon.Width, "Original.Width");
				handle = icon.Handle;
				using (Icon icon2 = Icon.FromHandle (handle)) {
					Assert.AreEqual (16, icon2.Height, "FromHandle.Height");
					Assert.AreEqual (16, icon2.Width, "FromHandle.Width");
					Assert.AreEqual (handle, icon2.Handle, "FromHandle.Handle");
					IconTest.SaveAndCompare ("Handle", icon2, false);
				}
			}
			// unlike other cases (HICON, HBITMAP) handle DOESN'T survives original icon disposal
			// commented / using freed memory is risky ;-)
			/*using (Icon icon3 = Icon.FromHandle (handle)) {
				Assert.AreEqual (0, icon3.Height, "Survivor.Height");
				Assert.AreEqual (0, icon3.Width, "Survivor.Width");
				Assert.AreEqual (handle, icon3.Handle, "Survivor.Handle");
			}*/
		}

		[Test]
		public void CreateMultipleIconFromSameHandle ()
		{
			IntPtr handle;
			using (Icon icon = new Icon (TestBitmap.getInFile ("bitmaps/16x16x16.ico"))) {
				Assert.AreEqual (16, icon.Height, "Original.Height");
				Assert.AreEqual (16, icon.Width, "Original.Width");
				handle = icon.Handle;
				using (Icon icon2 = Icon.FromHandle (handle)) {
					Assert.AreEqual (16, icon2.Height, "2.Height");
					Assert.AreEqual (16, icon2.Width, "2.Width");
					Assert.AreEqual (handle, icon2.Handle, "2.Handle");
					IconTest.SaveAndCompare ("Handle2", icon2, false);
				}
				using (Icon icon3 = Icon.FromHandle (handle)) {
					Assert.AreEqual (16, icon3.Height, "3.Height");
					Assert.AreEqual (16, icon3.Width, "3.Width");
					Assert.AreEqual (handle, icon3.Handle, "3.Handle");
					IconTest.SaveAndCompare ("Handle3", icon3, false);
				}
			}
			// unlike other cases (HICON, HBITMAP) handle DOESN'T survives original icon disposal
			// commented / using freed memory is risky ;-)
		}

		[Test]
		public void HiconRoundtrip ()
		{
			IntPtr handle;
			using (Icon icon = new Icon (TestBitmap.getInFile ("bitmaps/16x16x16.ico"))) {
				Assert.AreEqual (16, icon.Height, "Original.Height");
				Assert.AreEqual (16, icon.Width, "Original.Width");
				handle = icon.ToBitmap ().GetHicon ();
			}
			// HICON survives
			using (Icon icon2 = Icon.FromHandle (handle)) {
				Assert.AreEqual (16, icon2.Height, "Survivor.Height");
				Assert.AreEqual (16, icon2.Width, "Survivor.Width");
				Assert.AreEqual (handle, icon2.Handle, "Survivor.Handle");
				IconTest.SaveAndCompare ("HICON", icon2, false);
			}
		}

		[Test]
		public void CreateMultipleIconFromSameHICON ()
		{
			IntPtr handle;
			using (Icon icon = new Icon (TestBitmap.getInFile ("bitmaps/16x16x16.ico"))) {
				Assert.AreEqual (16, icon.Height, "Original.Height");
				Assert.AreEqual (16, icon.Width, "Original.Width");
				handle = icon.ToBitmap ().GetHicon ();
			}
			// HICON survives
			using (Icon icon2 = Icon.FromHandle (handle)) {
				Assert.AreEqual (16, icon2.Height, "2.Height");
				Assert.AreEqual (16, icon2.Width, "2.Width");
				Assert.AreEqual (handle, icon2.Handle, "2.Handle");
				IconTest.SaveAndCompare ("HICON2", icon2, false);
			}
			using (Icon icon3 = Icon.FromHandle (handle)) {
				Assert.AreEqual (16, icon3.Height, "3.Height");
				Assert.AreEqual (16, icon3.Width, "3.Width");
				Assert.AreEqual (handle, icon3.Handle, "3.Handle");
				IconTest.SaveAndCompare ("HICON", icon3, false);
			}
		}
	}
}