#region "  © Copyright 2005-07 to Marcos Meli - http://www.marcosmeli.com.ar" 

// Errors, suggestions, contributions, send a mail to: marcos@filehelpers.com.

#endregion

using System;
using System.Globalization;

namespace FileHelpers
{
	/// <summary>Class that provides static methods that returns a default <see cref="ConverterBase">Converter</see> to the basic types.</summary>
	/// <remarks>Used by the <see cref="FileHelpers.FieldConverterAttribute"/>.</remarks>
	internal sealed class ConvertHelpers
	{
        private const string DefaultDecimalSep = ".";

		#region "  Constructors  "

		// Not allow direct creation
		private ConvertHelpers()
		{
		}

		#endregion

		#region "  CreateCulture  "

		static CultureInfo CreateCulture(string decimalSep)
		{
			CultureInfo ci = new CultureInfo(CultureInfo.CurrentCulture.LCID);

			if (decimalSep == ".")
			{
				ci.NumberFormat.NumberDecimalSeparator = ".";
				ci.NumberFormat.NumberGroupSeparator = ",";
			}
			else if (decimalSep == ",")
			{
				ci.NumberFormat.NumberDecimalSeparator = ",";
				ci.NumberFormat.NumberGroupSeparator = ".";
			}
            else
                throw new BadUsageException("You can only use '.' or ',' as decimal or grup separators");

			return ci;
		}

		#endregion

		#region "  GetDefaultConverter  "

		internal static ConverterBase GetDefaultConverter(string fieldName, Type fieldType)
		{
#if NET_2_0

            if (fieldType.IsValueType &&
                  fieldType.IsGenericType &&
                    fieldType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                fieldType = fieldType.GetGenericArguments()[0];
            }

#endif
			// Try to assign a default Converter
            if (fieldType == typeof(string))
                return null;
            else if (fieldType == typeof(Int16))
                return new Int16Converter();
            else if (fieldType == typeof(Int32))
                return new Int32Converter();
            else if (fieldType == typeof(Int64))
                return new Int64Converter();
            else if (fieldType == typeof(SByte))
                return new SByteConverter();
            else if (fieldType == typeof(UInt16))
                return new UInt16Converter();
            else if (fieldType == typeof(UInt32))
                return new UInt32Converter();
            else if (fieldType == typeof(UInt64))
                return new UInt64Converter();
            else if (fieldType == typeof(Byte))
                return new ByteConverter();
            else if (fieldType == typeof(Decimal))
                return new DecimalConverter();
            else if (fieldType == typeof(Double))
                return new DoubleConverter();
            else if (fieldType == typeof(Single))
                return new SingleConverter();
            else if (fieldType == typeof(DateTime))
                return new DateTimeConverter();
            else if (fieldType == typeof(Boolean))
                return new BooleanConverter();
#if ! MINI
            else if (fieldType.IsEnum)
                return new EnumConverter(fieldType);
#endif			

			throw new BadUsageException("The field: '" + fieldName + "' of type: " + fieldType.Name + " is a non system type, so this field need a CustomConverter (see the docs for more info).");
		}

		#endregion

        internal abstract class CultureConverter
            : ConverterBase 
        {
            protected CultureInfo mCulture;
            protected Type mType;
            public CultureConverter(Type T, string decimalSep)
            {
                mCulture = CreateCulture(decimalSep);
                mType = T;
            }

            public sealed override string FieldToString(object from)
            {
                return ((IConvertible)from).ToString(mCulture);
            }

            public sealed override object StringToField(string from)
            {
                object val;
                
                try
                {
                    val = ParseString(from);
                }
                catch
                {
                    throw new ConvertException(from, mType);
                }

                return val;
            }

            protected abstract object ParseString(string from);

        }

        internal sealed class ByteConverter : CultureConverter
        {
            public ByteConverter()
                : this(DefaultDecimalSep)
            {}

            public ByteConverter(string decimalSep)
                : base(typeof(Byte), decimalSep)
            {}

            protected override object ParseString(string from)
            {
                return Byte.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }


        internal sealed class UInt16Converter : CultureConverter
        {
            public UInt16Converter()
                : this(DefaultDecimalSep)
            {}

            public UInt16Converter(string decimalSep)
                : base(typeof(UInt16), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return UInt16.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }


        internal sealed class UInt32Converter : CultureConverter
        {
            public UInt32Converter()
                : this(DefaultDecimalSep)
            {}

            public UInt32Converter(string decimalSep)
                : base(typeof(UInt32), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return UInt32.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }



        internal sealed class UInt64Converter : CultureConverter
        {
            public UInt64Converter()
                : this(DefaultDecimalSep)
            {}

            public UInt64Converter(string decimalSep)
                : base(typeof(UInt64), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return UInt64.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }

		#region "  Int16, Int32, Int64 Converters  "

		#region "  Convert Classes  "

        internal sealed class SByteConverter : CultureConverter
        {
            public SByteConverter()
                : this(DefaultDecimalSep)
            {}

            public SByteConverter(string decimalSep)
                : base(typeof(SByte), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return SByte.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }

        internal sealed class Int16Converter : CultureConverter
        {
            public Int16Converter()
                : this(DefaultDecimalSep)
            {}

            public Int16Converter(string decimalSep)
                : base(typeof(Int16), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return Int16.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }

        internal sealed class Int32Converter : CultureConverter
        {
            public Int32Converter()
                : this(DefaultDecimalSep)
            {}


            public Int32Converter(string decimalSep)
                : base(typeof(Int32), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return Int32.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }

		internal sealed class Int64Converter : CultureConverter
		{
            public Int64Converter()
                : this(DefaultDecimalSep)
            {}
            public Int64Converter(string decimalSep)
                   : base(typeof(Int64), decimalSep)
            { }

            protected override object ParseString(string from)
            {
                return Int64.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }

		#endregion

		#endregion

		#region "  Single, Double, DecimalConverters  "

		#region "  Convert Classes  "

		internal sealed class DecimalConverter : CultureConverter
		{
            public DecimalConverter()
                : this(DefaultDecimalSep)
            {}

			public DecimalConverter(string decimalSep)
                :base (typeof(Decimal), decimalSep)
			{
			}

            protected override object ParseString(string from)
            {
                return Decimal.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }

        internal sealed class SingleConverter : CultureConverter
		{
            public SingleConverter()
                : this(DefaultDecimalSep)
            {}

			public SingleConverter(string decimalSep)
                : base(typeof(Single), decimalSep)
			{}

			protected override object ParseString(string from)
            {
                return Single.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture);
            }
        }


        internal sealed class DoubleConverter : CultureConverter
		{
            public DoubleConverter()
                : this(DefaultDecimalSep)
            {}

			public DoubleConverter(string decimalSep)
                :base(typeof(Double), decimalSep)
			{
			}

            protected override object ParseString(string from)
            {
                return Double.Parse(StringHelper.RemoveBlanks(from), NumberStyles.Number, mCulture); 
            }
        }

		#endregion

		#endregion

		#region "  Date Converters  "


		#region "  Convert Classes  "

		internal sealed class DateTimeConverter : ConverterBase
		{
			string mFormat;

			public DateTimeConverter() : this(ConverterBase.DefaultDateTimeFormat)
			{
			}

			public DateTimeConverter(string format)
			{
				if (format == null || format == String.Empty)
					throw new BadUsageException("The format of the DateTime Converter can be null or empty.");

				try
				{
					string tmp = DateTime.Now.ToString(format);
				}
				catch
				{
					throw new BadUsageException("The format: '" + format + " is invalid for the DateTime Converter.");
				}

				mFormat = format;
			}

            //static CultureInfo mInvariant = System.Globalization.CultureInfo.InvariantCulture;

			public override object StringToField(string from)
			{
				if (from == null) from = string.Empty;

				object val;
				try
				{
					val = DateTime.ParseExact(from.Trim(), mFormat, null);
				}
				catch
				{
					string extra = String.Empty;
					if (from.Length > mFormat.Length)
						extra = " There are more chars than in the format string: '" + mFormat + "'";
					else if (from.Length < mFormat.Length)
						extra = " There are less chars than in the format string: '" + mFormat + "'";
					else
						extra = " Using the format: '" + mFormat + "'";


					throw new ConvertException(from, typeof (DateTime), extra);
				}
				return val;
			}

			public override string FieldToString(object from)
			{
				return Convert.ToDateTime(from).ToString(mFormat);
			}
		}

		#endregion

		#endregion

		#region "  Boolean Converters  "

		#region "  Convert Classes  "

		internal sealed class BooleanConverter : ConverterBase
		{
			private string mTrueString = null;
			private string mFalseString = null;
			private string mTrueStringLower = null;
			private string mFalseStringLower = null;

			public BooleanConverter()
			{
			}

			public BooleanConverter(string trueStr, string falseStr) 
			{
				mTrueString = trueStr;
				mFalseString = falseStr;
				mTrueStringLower = trueStr.ToLower();
				mFalseStringLower = falseStr.ToLower();
			}

			public override object StringToField(string from)
			{
				object val;
				try
				{
					string testTo = from.ToLower();
					
					if (mTrueString == null)
					{
						testTo = testTo.Trim();
						if (testTo == "true" || testTo == "1")
							val = true;
						else if (testTo == "false" || testTo == "0" || testTo == "")
							val = false;
						else
							throw new Exception();
					}
					else
					{
						if (testTo == mTrueStringLower || testTo.Trim() == mTrueStringLower)
							val = true;
						else if (testTo == mFalseStringLower || testTo.Trim() == mFalseStringLower)
							val = false;
						else
							throw new ConvertException(from, typeof(bool), "The string: " + from + " cant be recognized as boolean using the true/false values: " + mTrueString + "/" + mFalseString);
					}
				}
				catch
				{
					throw new ConvertException(from, typeof (Boolean));
				}

				return val;
			}

			public override string FieldToString(object from)
			{
				bool b = Convert.ToBoolean(from);
				if (b)
					if (mTrueString == null)
						return "True";
					else
						return mTrueString;
				else 
					if (mFalseString == null)
						return "False";
					else
						return mFalseString;

			}
		}

		#endregion

		#endregion
	}
}