using System;

using BLToolkit.Common;

using KeyValue = System.Collections.Generic.KeyValuePair<System.Type, System.Type>;
using Table    = System.Collections.Generic.Dictionary<System.Collections.Generic.KeyValuePair<System.Type, System.Type>, BLToolkit.Mapping.IValueMapper>;

namespace BLToolkit.Mapping
{
	public static class ValueMapping
	{
		#region Init

		private static readonly Table _mappers = new Table();

		#endregion

		#region Default Mapper

		class DefaultValueMapper : IValueMapper
		{
			public void Map(
				IMapDataSource      source, object sourceObject, int sourceIndex,
				IMapDataDestination dest,   object destObject,   int destIndex)
			{
				dest.SetValue(destObject, destIndex, source.GetValue(sourceObject, sourceIndex));

				//object o = source.GetValue(sourceObject, sourceIndex);

				//if (o == null) dest.SetNull (destObject, destIndex);
				//else           dest.SetValue(destObject, destIndex, o);
			}
		}

		private static IValueMapper _defaultMapper = new DefaultValueMapper();
		[CLSCompliant(false)]
		public  static IValueMapper  DefaultMapper
		{
			get { return _defaultMapper;  }
			set { _defaultMapper = value; }
		}

		#endregion

		#region GetMapper

		private static readonly object _sync = new object();

		[CLSCompliant(false)]
		public static IValueMapper GetMapper(Type t1, Type t2)
		{
			if (t1 == null) t1 = typeof(object);
			if (t2 == null) t2 = typeof(object);

			if (t1.IsEnum) t1 = Enum.GetUnderlyingType(t1);
			if (t2.IsEnum) t2 = Enum.GetUnderlyingType(t2);

			KeyValue key = new KeyValue(t1, t2);

			lock (_sync)
			{
				IValueMapper t;

				if (_mappers.TryGetValue(key, out t))
					return t;

				//t = BLToolkit.Mapping.ValueMappingInternal.MapperSelector.GetMapper(t1, t2);

				if (null == t)
				{
					Type type = typeof(GetSetDataChecker<,>).MakeGenericType(t1, t2);

					if (((IGetSetDataChecker)Activator.CreateInstance(type)).Check() == false)
					{
						t = _defaultMapper;
					}
					else
					{
						type = t1 == t2 ?
							typeof(ValueMapper<>).MakeGenericType(t1) :
							typeof(ValueMapper<,>).MakeGenericType(t1, t2);

						t = (IValueMapper)Activator.CreateInstance(type);
					}
				}

				_mappers.Add(key, t);

				return t;
			}
		}

		#endregion

		#region Generic Mappers

		interface IGetSetDataChecker
		{
			bool Check();
		}

		class GetSetDataChecker<S,D> : IGetSetDataChecker
		{
			public bool Check()
			{
				return
					!(MapGetData<S>.I is MapGetData<S>.Default<S>) &&
					!(MapSetData<S>.I is MapSetData<S>.Default<S>) &&
					!(MapGetData<D>.I is MapGetData<D>.Default<D>) &&
					!(MapSetData<D>.I is MapSetData<D>.Default<D>);
			}
		}

		class ValueMapper<T> : IValueMapper
		{
			public void Map(
				IMapDataSource      source, object sourceObject, int sourceIndex,
				IMapDataDestination dest,   object destObject,   int destIndex)
			{
				if (source.IsNull(sourceObject, sourceIndex))
					dest.SetNull(destObject, destIndex);
				else
				{
					MapSetData<T>.MB<T> setter = MapSetData<T>.I;
					MapGetData<T>.MB<T> getter = MapGetData<T>.I;

					setter.To(dest, destObject, destIndex,
						getter.From(source, sourceObject, sourceIndex));
				}
			}
		}

		class ValueMapper<S,D> : IValueMapper
		{
			public void Map(
				IMapDataSource      source, object sourceObject, int sourceIndex,
				IMapDataDestination dest,   object destObject,   int destIndex)
			{
				if (source.IsNull(sourceObject, sourceIndex))
					dest.SetNull(destObject, destIndex);
				else
				{
					MapSetData<D>.MB<D>        setter    = MapSetData<D>.I;
					MapGetData<S>.MB<S>        getter    = MapGetData<S>.I;
					Convert<D,S>.ConvertMethod converter = Convert<D,S>.From;

					setter.To(dest, destObject, destIndex,
						converter(getter.From(source, sourceObject, sourceIndex)));
				}
			}
		}

		#endregion
	}
}