<%@ WebHandler Language="C#" Class="Visigo.Sharepoint.FormsBasedAuthentication.HIP.ImageHipChallengeHandler" %>
using System;
using System.Web;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.Collections.Specialized;
using System.Security.Cryptography;

namespace Visigo.Sharepoint.FormsBasedAuthentication.HIP
{
    /// <summary>Provides cryptographically-strong pseudo-random numbers.</summary>
    internal class RandomNumbers
    {
        /// <summary>Random number generator.</summary>
        private RNGCryptoServiceProvider _rand = new RNGCryptoServiceProvider();

        /// <summary>Used by NextRandom and NextRandomDouble.</summary>
        /// <remarks>
        /// RNGCryptoServiceProvider is not thread-safe.  Therefore, we only call to on a single thread.
        /// As a result, we can resuse the same byte arrays for every call.
        /// </remarks>
        private byte[] _rd4 = new byte[4], _rd8 = new byte[8];

        /// <summary>Gets a random non-negative integer less than max.</summary>
        /// <param name="max">The upper-bound for the random number.</param>
        /// <returns>The generated random number.</returns>
        public int Next(int max)
        {
            if (max <= 0) throw new ArgumentOutOfRangeException("max");
            _rand.GetBytes(_rd4);
            int val = BitConverter.ToInt32(_rd4, 0) % max;
            if (val < 0) val = -val;
            return val;
        }

        /// <summary>Gets a random number between min and max, inclusive.</summary>
        /// <param name="min">The minimum possible value.</param>
        /// <param name="max">The maximum possible value.</param>
        /// <returns>The randomly generated number.</returns>
        public int Next(int min, int max)
        {
            if (min > max) throw new ArgumentOutOfRangeException("max");
            return Next(max - min + 1) + min;
        }

        /// <summary>Gets a randomly generated double between 0.0 and 1.1.</summary>
        /// <returns>The random number.</returns>
        public double NextDouble()
        {
            _rand.GetBytes(_rd8);
            return BitConverter.ToUInt64(_rd8, 0) / (double)UInt64.MaxValue;
        }
    }
    
	/// <summary>Handles requests for dynamic images from the ImageHipChallenge control.</summary>
	public class ImageHipChallengeHandler : IHttpHandler
	{
        /// <summary>Default value for the RenderUrl property.</summary>
        private const string RENDERURL_DEFAULT = "ImageHipChallenge.ashx";
        /// <summary>Query string key for the image width.</summary>
        internal const string WIDTH_KEY = "w";
        /// <summary>Query string key for the image height.</summary>
        internal const string HEIGHT_KEY = "h";
        /// <summary>Query string key for challenge ID.</summary>
        internal const string ID_KEY = "id";        
        private RandomNumbers _rand = new RandomNumbers();
        
		/// <summary>Maximum width of an image to generate.</summary>
		private const int MAX_IMAGE_WIDTH = 600;
		/// <summary>Maximum height of an image to generate.</summary>
		private const int MAX_IMAGE_HEIGHT = 600;

		/// <summary>Gets whether this handler is reusable.</summary>
		/// <remarks>This handler is not thread-safe (uses non thread-safe member variables), so it is not reusable.</remarks>
		public bool IsReusable { get { return false; } }

        /// <summary>Gets a random non-negative integer less than max.</summary>
        /// <param name="max">The upper-bound for the random number.</param>
        /// <returns>The generated random number.</returns>
        protected int NextRandom(int max) { return _rand.Next(max); }

        /// <summary>Gets a random number between min and max, inclusive.</summary>
        /// <param name="min">The minimum possible value.</param>
        /// <param name="max">The maximum possible value.</param>
        /// <returns>The randomly generated number.</returns>
        protected int NextRandom(int min, int max) { return _rand.Next(min, max); }

        /// <summary>Gets a randomly generated double between 0.0 and 1.1.</summary>
        /// <returns>The random number.</returns>
        protected double NextRandomDouble() { return _rand.NextDouble(); }

        /// <summary>Gets the challenge text for a particular ID.</summary>
        /// <param name="challengeId">The ID of the challenge text to retrieve.</param>
        /// <returns>The text associated with the specified ID; null if no text exists.</returns>
        internal static string GetChallengeText(Guid challengeId)
        {
            HttpContext ctx = HttpContext.Current;
            return (string)ctx.Cache[challengeId.ToString()];
        }
                
		/// <summary>Processes the image request and generates the appropriate image.</summary>
		/// <param name="context">The current HttpContext.</param>
		public void ProcessRequest(HttpContext context)
		{
			// Retrieve query parameters and challenge text
            NameValueCollection queryString = context.Request.QueryString;
            int width = Convert.ToInt32(queryString[WIDTH_KEY]);
            if (width <= 0 || width > MAX_IMAGE_WIDTH) throw new ArgumentOutOfRangeException(WIDTH_KEY);
            int height = Convert.ToInt32(queryString[HEIGHT_KEY]);
            if (height <= 0 || height > MAX_IMAGE_HEIGHT) throw new ArgumentOutOfRangeException(HEIGHT_KEY);
            string text = GetChallengeText(new Guid(queryString[ID_KEY]));

            if (text != null)
            {
                // We successfully retrieved the information, so generate the image and send it to the client.
                HttpResponse resp = context.Response;
                resp.Clear();
                resp.ContentType = "image/jpeg";
                using (Bitmap bmp = GenerateImage(text, new Size(width, height)))
                {
                    bmp.Save(resp.OutputStream, ImageFormat.Jpeg);
                }
            }
		}

		/// <summary>Generates the challenge image.</summary>
		/// <param name="text">The text to be rendered into the image.</param>
		/// <param name="size">The size of the image to generate.</param>
		/// <returns>A dynamically-generated challenge image.</returns>
		public Bitmap GenerateImage(string text, Size size)
		{
			// Create the new Bitmap of the specified size and render to it
			Bitmap bmp = new Bitmap(size.Width, size.Height);
			using (Graphics g = Graphics.FromImage(bmp))
			{
				// Draw the background as a random linear gradient
				using(Brush b = new LinearGradientBrush(
						  new Rectangle(0,0,size.Width,size.Height),
						  Color.FromArgb(NextRandom(256),NextRandom(256),NextRandom(256)),
						  Color.FromArgb(NextRandom(256),NextRandom(256),NextRandom(256)),
						  (float)(NextRandomDouble()*360),false))
				{
					g.FillRectangle(b, 0, 0, bmp.Width, bmp.Height);
				}

				// Select a font family and create the default sized font.  We then need to shrink
				// the font size until the text fits.
				FontFamily ff = _families[NextRandom(_families.Length)];
				int emSize = (int)(size.Width*2 / text.Length);
				Font f = new Font(ff, emSize);
				try
				{
					// Make sure that the font size we have will fit with the selected text.
					SizeF measured = new SizeF(0,0);
					SizeF workingSize = new SizeF(size.Width, size.Height);
					while (emSize > 2 &&
						(measured = g.MeasureString(text, f)).Width > workingSize.Width ||
						measured.Height > workingSize.Height)
					{
						f.Dispose();
						f = new Font(ff, emSize -= 2);
					}

					// Select a color and draw the string into the center of the image
					using(StringFormat fmt = new StringFormat())
					{
						fmt.Alignment = fmt.LineAlignment = StringAlignment.Center;
						using(Brush b = new LinearGradientBrush(
								  new Rectangle(0,0,size.Width/2,size.Height/2),
								  Color.FromArgb(NextRandom(256),NextRandom(256),NextRandom(256)),
								  Color.FromArgb(NextRandom(256),NextRandom(256),NextRandom(256)),
								  (float)(NextRandomDouble()*360),false))
						{
							g.DrawString(text, f, b, new Rectangle(0,0,bmp.Width,bmp.Height), fmt);
						}
					}
				}
				finally
				{
					// Clean up
					f.Dispose();
				}
			}
			
			// Distort the final image and return it.  This distortion amount is fairly arbitrary.
			DistortImage(bmp, NextRandom(5, 10) * (NextRandom(2) == 1 ? 1 : -1) );
			return bmp;
		}

		/// <summary>Distorts the image.</summary>
		/// <param name="b">The image to be transformed.</param>
		/// <param name="distortion">An amount of distortion.</param>
		private static void DistortImage(Bitmap b, double distortion)
		{
			int width = b.Width, height = b.Height;

			// Copy the image so that we're always using the original for source color
			using (Bitmap copy = (Bitmap)b.Clone())
			{
				// Iterate over every pixel
				for (int y = 0; y < height; y++)
				{
					for (int x = 0; x < width; x++)
					{
						// Adds a simple wave
						int newX = (int)(x + (distortion * Math.Sin(Math.PI * y / 64.0)));
						int newY = (int)(y + (distortion * Math.Cos(Math.PI * x / 64.0)));
						if (newX < 0 || newX >= width) newX = 0;
						if (newY < 0 || newY >= height) newY = 0;
						b.SetPixel(x, y, copy.GetPixel(newX, newY));
					}
				}
			}
		}

		/// <summary>List of fonts that can be used for rendering text.</summary>
		/// <remarks>This list can be changed to include any families available on the current system.</remarks>
		private static FontFamily [] _families = { 
													 new FontFamily("Times New Roman")
												 };
	}
}