using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Perforce.P4
{
	/// <summary>
	/// Defines the case for the StringEnum.
	/// </summary>
	[Flags]
	public enum StringEnumCase 
	{
		/// <summary>
		/// No case defined.
		/// </summary>
		None = 0x000,
		/// <summary>
		/// Lowercase.
		/// </summary>
		Lower = 0x001,
		/// <summary>
		/// Uppercase.
		/// </summary>
		Upper = 0x002
	}

	internal class StringEnum<T> // where T : IComparable<T>
	{
		protected T value;

        public StringEnum(T v)
        {
            if ((v is Enum) == false)
                throw new ArgumentException("StringEnum may only be used with objects that are of type enum");
            value = v;
        }

        public StringEnum(string s)
        {
            s = s.Replace(" ", string.Empty);
            s = s.Replace("/", string.Empty);
            value = (T)Enum.Parse(typeof(T), s);
        }

        public StringEnum(string s, bool safe)
        {
            try
            {
                s = s.Replace(" ", string.Empty);
                s = s.Replace("/", string.Empty);
                value = (T)Enum.Parse(typeof(T), s);
            }
            catch
            {
                if (safe)
                {
                    value = default(T);
                }
                else { throw; }
            }
        }

        public StringEnum(string s, bool safe, bool ignoreCase)
        {
            try
            {
                s = s.Replace(" ", string.Empty);
                s = s.Replace("/", string.Empty);
                value = (T)Enum.Parse(typeof(T), s, ignoreCase);
            }
            catch
            {
                if (safe)
                {
                    value = default(T);
                }
                else { throw; }
            }
        }

        public static implicit operator T(StringEnum<T> t) { return (t != null) ? t.value : default(T); }
		public static implicit operator StringEnum<T>(T t) { return new StringEnum<T>(t); }

		public static implicit operator StringEnum<T>(string s)
		{
			StringEnum<T> val = null;
			string v = s.Replace(" ", string.Empty);
			v = v.Replace("/", string.Empty);
			if (TryParse(v, true, ref val))
			{
				return val;
			}
			return new StringEnum<T>(default(T));
		}

		public static implicit operator string(StringEnum<T> v)
		{
			if (v != null)
			{
				return v.ToString();
			}
			return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj.GetType() == typeof(T))
			{
				return value.Equals((T)obj);
			}
			if (obj.GetType() == typeof(StringEnum<T>))
			{
				return value.Equals(((StringEnum<T>)obj).value);
			}
			return false;
		}

		public static bool operator ==(StringEnum<T> t1, StringEnum<T> t2) 
		{
			if ((((object)t1) == null) || (((object)t2) == null))
			{
				return ((object)t1) == ((object)t2);
			}
			return (t1!=null)?t1.value.Equals(t2.value):t2==null; 
		}
		public static bool operator !=(StringEnum<T> t1, StringEnum<T> t2) 
		{
			if ((((object)t1) == null) || (((object)t2) == null))
			{
				return ((object)t1) != ((object)t2);
			}
			return (t1 != null) ? !t1.value.Equals(t2.value) : t2 != null; 
		}

		public static bool operator ==(T t1, StringEnum<T> t2) 
		{
			if (((object)t2) == null)
			{
				return false;
			}
			return t1.Equals(t2.value); 
		}
		public static bool operator !=(T t1, StringEnum<T> t2) 
		{
			if (((object)t2) == null)
			{
				return true;
			}
			return !t1.Equals(t2.value); 
		}

		public static bool operator ==(StringEnum<T> t1, T t2) 
		{ 
			if (((object)t1) == null)
			{
				return false;
			}
			return t1.value.Equals(t2);
		}
		public static bool operator !=(StringEnum<T> t1, T t2) 
		{
			if (((object)t1) == null)
			{
				return true;
			}
			return !t1.value.Equals(t2); 
		}

		public override string ToString()
		{
			return value.ToString();
		}

		public virtual string ToString(StringEnumCase c)
		{
			if (c == StringEnumCase.Lower)
				return ToString().ToLower(); ;
			if (c == StringEnumCase.Upper)
				return ToString().ToUpper(); ;
			return ToString();
		}

		public static bool TryParse(string str, ref StringEnum<T> val)
		{
			try
			{
				T v = (T)Enum.Parse(typeof(T), str);
				val = new StringEnum<T>(v);
				if (val == null)
				{
					return false;
				}
				return true;
			}
			catch (Exception ex) 
			{
				Debug.Trace(ex.Message);
			}
			return false;
		}

		public static bool TryParse(string str, bool ignoreCase, ref StringEnum<T> val)
		{
			try
			{
				T v = (T)Enum.Parse(typeof(T), str, ignoreCase);
				val = new StringEnum<T>(v);
				if (val == null)
				{
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Debug.Trace(ex.Message);
			}
			return false;
		}
	}

	internal class StringEnumList<T> : IList<T>
	{
		internal IList<StringEnum<T>> v;

		public StringEnumList()
		{
			v = new List<StringEnum<T>>();
		}

		public StringEnumList(IList<T> l)
		{
			v = new List<StringEnum<T>>(l.Count);

			for (int idx = 0; idx < l.Count; idx++)
			{
				v.Add(l[idx]);
			}
		}

		#region IList<T> Members

		public int IndexOf(T item)
		{
			return v.IndexOf(item);
		}

		public void Insert(int index, T item)
		{
			v.Insert(index, item);
		}

		public void RemoveAt(int index)
		{
			v.RemoveAt(index);
		}

		public T this[int index]
		{
			get
			{
				return v[index];
			}
			set
			{
				v[index] = value;
			}
		}

		#endregion

		#region ICollection<T> Members

		public void Add(T item)
		{
			v.Add(item);
		}

		public void Clear()
		{
			v.Clear();
		}

		public bool Contains(T item)
		{
			return v.Contains(item);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (arrayIndex < 0)
			{
				throw new ArgumentOutOfRangeException("arrayIndex is less than zero");
			}
			if (arrayIndex + array.Length >  v.Count)
			{
				throw new ArgumentException("The number of elements in the source array is greater than the available space from arrayIndex to the end of the destination array.");
			}
			for (int idx = 0; idx < array.Length; idx++)
			{
				v[arrayIndex+idx] = array[idx];
			}
		}

		public int Count
		{
			get { return v.Count; }
		}

		public bool IsReadOnly
		{
			get { return v.IsReadOnly; }
		}

		public bool Remove(T item)
		{
			return v.Remove(item);
		}

		#endregion

		#region IEnumerable<T> Members

		public IEnumerator<T> GetEnumerator()
		{
			return new StringEnumListEnumerator<T>(v);
		}

		#endregion

		#region IEnumerable Members

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return v.GetEnumerator();
		}

		#endregion
	}

	internal class StringEnumListEnumerator<T> : IEnumerator<T>
	{
		IEnumerator<StringEnum<T>> v;

		public StringEnumListEnumerator(IList<StringEnum<T>> l)
		{
			v = l.GetEnumerator();
		}

		#region IEnumerator<T> Members

		public T Current
		{
			get { return v.Current; }
		}

		#endregion

		#region IDisposable Members

		public void Dispose()
		{
			v.Dispose();
		}

		#endregion

		#region IEnumerator Members

		object System.Collections.IEnumerator.Current
		{
			get { return v.Current; }
		}

		public bool MoveNext()
		{
			return v.MoveNext();
		}

		public void Reset()
		{
			v.Reset();
		}

		#endregion
	}
}