WPF Control Factory

using System;
using System.Reflection;
using System.Windows;
using Pfz.Collections;
using Pfz.DataTypes;

namespace Pfz.WpfControls
{
	/// <summary>
	/// The heart of Pfz.WpfControls and Pfz.WpfControls.
	/// This factory allows you to register IValueContainer controls, so
	/// whenever you need a control for a specific type, the right control
	/// will be created.
	/// </summary>
	public static class ControlFactory
	{
		private static TypeDictionary<ConstructorInfo> fTypeDictionary = new TypeDictionary<ConstructorInfo>();
		
		/// <summary>
		/// Registers the default controls that came with Pfz.WpfControls.
		/// </summary>
		static ControlFactory()
		{
			Register<StringControl>();
			Register<DateControl>();
			Register<TimeControl>();
			Register<DateTimeControl>();
			Register<BooleanControl>();
			Register<PasswordControl>();
			Register<EnumControl>(true);
			p_Register(typeof(RangeControl<>), true);
		}
		
		/// <summary>
		/// Registers a control by it's type.
		/// </summary>
		public static void Register<T>()
		where
			T: UIElement, IValueContainer, IValueControl, new()
		{
			Register<T>(false);
		}
		
		/// <summary>
		/// Registers a control by it's type and allows you to tell if
		/// sub-types of the data-types supported by this control can
		/// use this control if a better one does not exist.
		/// </summary>
		public static void Register<T>(bool canGenerateForSubtypes)
		where
			T: UIElement, IValueContainer, IValueControl, new()
		{
			p_Register(typeof(T), canGenerateForSubtypes);
		}

		/// <summary>
		/// Registers a control by it's type and allows you to tell if
		/// sub-types of the data-types supported by this control can
		/// use this control if a better one does not exist.
		/// </summary>
		public static void Register(Type type, bool canGenerateForSubtypes)
		{
			if (type == null)
				throw new ArgumentNullException("type");
			
			if (!type.IsSubclassOf(typeof(UIElement)))
				throw new ArgumentException("type must be a sub-class of UIElement.", "type");
			
			if (!typeof(IValueControl).IsAssignableFrom(type))
				throw new ArgumentException("type must implement IDataControl.", "type");
			
			if (type.GetConstructor(Type.EmptyTypes) == null)
				throw new ArgumentException("type must have a public default constructor", "type");
			
			p_Register(type, canGenerateForSubtypes);
		}
		private static void p_Register(Type type, bool canGenerateForSubtypes)
		{
			bool added = false;
			Type[] interfaceTypes = type.GetInterfaces();
			foreach(var interfaceType in interfaceTypes)
			{
				if (!interfaceType.IsGenericType)
					continue;
				
				if (interfaceType.GetGenericTypeDefinition() != typeof(IValueContainer<>))
					continue;
				
				added = true;
				var dataType = interfaceType.GetGenericArguments()[0];
				
				if (dataType.IsGenericParameter)
				{
					var constraints = dataType.GetGenericParameterConstraints();
					if (constraints.Length == 0)
						dataType = typeof(object);
					else
						dataType = constraints[0];
				}
				
				ConstructorInfo constructorInfo = type.GetConstructor(Type.EmptyTypes);
				fTypeDictionary.Set(dataType, constructorInfo, canGenerateForSubtypes);
			}
			
			if (!added)
				throw new ArgumentException("controlType must implement IValueContainer<> for at least one type.");
		}
		
		/// <summary>
		/// Tries to create a control for the given data-type.
		/// The result can be null if there is not a control appropriate for the
		/// data-type.
		/// </summary>
		public static UIElement TryCreate(Type dataType)
		{
			if (dataType == null)
				throw new ArgumentNullException("dataType");
			
			ConstructorInfo constructorInfo = fTypeDictionary.FindUpOrDefault(dataType);
			if (constructorInfo == null)
				return null;
			
			Type declaringType = constructorInfo.DeclaringType;
			if (declaringType.ContainsGenericParameters)
			{
				Type madeType = declaringType.MakeGenericType(dataType);
				constructorInfo = madeType.GetConstructor(Type.EmptyTypes);
			}
			
			UIElement result = (UIElement)constructorInfo.Invoke(null);
			
			IHasPreferredDataType preferredDataType = result as IHasPreferredDataType;
			if (preferredDataType != null)
				preferredDataType.PreferredDataType = dataType;
			
			return result;
		}
		
		private static readonly MethodInfo fTypedTryCreate = typeof(ControlFactory).GetMethod("TryCreate", new Type[]{typeof(string)});
		/// <summary>
		/// Tries to create a control for the given data-type using the given
		/// displayName. If the control does not support displayName, a 
		/// LabellerControl will be created for it.
		/// The result can be null if there is no editor for the given data-type.
		/// </summary>
		public static UIElement TryCreate(Type dataType, string displayName)
		{
			if (dataType == null)
				throw new ArgumentNullException("dataType");
				
			UIElement result = TryCreate(dataType);
			
			if (result == null)
				return null;
			
			if (displayName != null)
			{
				IHasDisplayName hasDisplayName = result as IHasDisplayName;
				if(hasDisplayName != null)
					hasDisplayName.DisplayName = displayName;
				else
					result = new LabellerControl(result, displayName);
			}
			
			return result;
		}
	}
}