using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace RanWahle.Blog
{
    /// <summary>
    /// This class implements Bi-directional dictionary
    /// </summary>
    /// <typeparam name="TKey">The dictionary Key (acts also as value)</typeparam>
    /// <typeparam name="TValue">The dictionary value (acts also as key)</typeparam>
    /// <remarks>
    /// Because values acts also as keys, they should not repeat one another
    /// If a value is added twice - en exception is thrown (as in key in regular dictionary)
    /// This class won't support key and value of the same type. 
    /// </remarks>
    public class BiDirectionalDictionary<TKey, TValue> :
        IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
        IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback
      
    {
        #region Members
        private Dictionary<TKey, TValue> keyValueDic;
        private Dictionary<TValue, TKey> valueKeyDic;
        #endregion

        #region Ctor
        public BiDirectionalDictionary()
        {
            if (typeof(TKey) == typeof(TValue))
            {
                throw new NotSupportedException("This class cannot suport keys and values of the same type");
            }
            keyValueDic = new Dictionary<TKey, TValue>();
            valueKeyDic = new Dictionary<TValue, TKey>();
        }
        #endregion

        #region Proeprties
        /// <summary>
        /// Gets a collection containing the keys of the dictionary
        /// </summary>
        public Dictionary<TKey, TValue>.KeyCollection Keys
        {
            get
            {
                return keyValueDic.Keys;
            }
        }

        /// <summary>
        /// Gets a collection containing the values of the dictionary
        /// </summary>
        public Dictionary<TKey, TValue>.ValueCollection Values
        {
            get
            {
                return keyValueDic.Values;
            }
        }

        /// <summary>
        /// Gets or sets the value of thedictionary by the TKey 
        /// </summary>
        /// <param name="key">TKey</param>
        /// <returns></returns>
        public TValue this[TKey key]
        {
            get
            {
                return keyValueDic[key];
            }
            set
            {
                if (valueKeyDic.ContainsKey(value))
                {
                    keyValueDic.Remove(valueKeyDic[value]);
                }
                keyValueDic[key] = value;
                valueKeyDic[value] = key;
            }
        }

        public TKey this[TValue valueAsKey]
        {
            get
            {
                return valueKeyDic[valueAsKey];
            }
            set
            {
                if (keyValueDic.ContainsKey(value))
                {
                    valueKeyDic.Remove(keyValueDic[value]);
                }
                keyValueDic[value] = valueAsKey;
                valueKeyDic[valueAsKey] = value;
            }
        }



        #endregion

        #region Methods

        public Dictionary<TKey, TValue>.Enumerator GetEnumerator()
        {
            return keyValueDic.GetEnumerator();
        }

        /// <summary>
        /// Adds the specified key and value to the dictionary
        /// </summary>
        /// <param name="key">Dictionary key</param>
        /// <param name="value">Dictionary value</param>
        public void Add(TKey key, TValue value)
        {
            //Validate
            if (this.ContainsKey(key))
            {
                throw new ArgumentException(string.Format("The key {0} is already exist in the dictionary", key));
            }
            if (this.ContainsValue(value))
            {
                throw new ArgumentException(string.Format("The value {0} is already exist in the dictonary", value));
            }
            keyValueDic.Add(key, value);
            valueKeyDic.Add(value, key);
        }

        /// <summary>
        /// Removes the value with it specified key from hte dictionary
        /// </summary>
        /// <param name="key">Key to remove</param>
        /// <returns>True if item removed, false otherwise</returns>
        public bool Remove(TKey key)
        {
            TValue value = keyValueDic[key];
            return Remove(key, value);
        }

        /// <summary>
        /// Removes the specified value with it's key from the dictionary
        /// </summary>
        /// <param name="value">Value to remove</param>
        public bool Remove(TValue value)
        {
            TKey key = valueKeyDic[value];
            return Remove(key, value);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns>True if item removed, false otherwise</returns>
        private bool Remove(TKey key, TValue value)
        {
            return keyValueDic.Remove(key) &&
            valueKeyDic.Remove(value);
        }
        #endregion



        #region ICollection<KeyValuePair<TKey,TValue>> Members

        public void Add(KeyValuePair<TKey, TValue> item)
        {
            Add(item.Key, item.Value);
        }

        public void Clear()
        {
            keyValueDic.Clear();
            valueKeyDic.Clear();
        }

        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return keyValueDic.ContainsKey(item.Key) && keyValueDic[item.Key].Equals(item.Value);
        }

        /// <summary>
        /// Gets the number of key/value pairs contained in the System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;.
        /// </summary>
        public int Count
        {
            get { return keyValueDic.Count; }
        }



        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return keyValueDic.Remove(item.Key)
                && valueKeyDic.Remove(item.Value);
        }

        #endregion

        #region IEnumerable<KeyValuePair<TKey,TValue>> Members

        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
        {
            return keyValueDic.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

        #region ICollection<KeyValuePair<TKey,TValue>> Members

        /// <summary>
        /// Copies the dictionary to the given array
        /// starting in thew given arrayIndex
        /// </summary>
        /// <param name="array">Array to copy to</param>
        /// <param name="arrayIndex">Starting index</param>
        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            int tempIndex = arrayIndex;
            foreach (KeyValuePair<TKey, TValue> pair in this)
            {
                array[tempIndex] = pair;
                tempIndex++;
            }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        #endregion

        /// <summary>
        ///  Determines whether the BiDirectionalDictionary&lt;TKey,TValue&gt;
        ///     contains the specified key.
        /// </summary>
        /// <param name="key">
        /// The key to locate in the BiDirectionalDictionar&lt;TKey,TValue&gt;.
        /// </param>
        /// <returns>
        /// true if the System.Collections.Generic.Dictionary<TKey,TValue> contains an
        ///     element with the specified key; otherwise, false.
        /// </returns>
        /// <exception cref="System.ArgumentNullException">Key is null</exception>
        public bool ContainsKey(TKey key)
        {
            return this.keyValueDic.ContainsKey(key);
        }
        /// <summary>
        ///  Determines whether the BiDirectionalDictionary&lt;TKey,TValue&gt;
        ///     contains the specified value.
        /// </summary>
        /// <param name="key">
        /// The value to locate in the BiDirectionalDictionar&lt;TKey,TValue&gt;.
        /// </param>
        /// <returns>
        /// true if the SBiDirectionalDictionar&lt;TKey,TValue&gt; contains an
        ///     element with the specified key; otherwise, false.
        /// </returns>
        /// <exception cref="System.ArgumentNullException">Value is null</exception>

        public bool ContainsValue(TValue value)
        {
            return this.valueKeyDic.ContainsKey(value);
        }

        #region IDeserializationCallback Members

        public void OnDeserialization(object sender)
        {
            this.keyValueDic.OnDeserialization(sender);
        }

        #endregion

        #region ISerializable Members

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            this.keyValueDic.GetObjectData(info, context);
        }

        #endregion

        #region ICollection Members

        /// <summary>
        /// Copies the dictionary to the given array
        /// starting in thew given arrayIndex
        /// </summary>
        /// <param name="array">Array to copy to</param>
        /// <param name="index">Starting index</param>
        public void CopyTo(Array array, int index)
        {
            this.CopyTo(array as KeyValuePair<TKey, TValue>[], index);
        }

        bool ICollection.IsSynchronized
        {
            get { return (this.keyValueDic as ICollection).IsSynchronized; }
        }

        object ICollection.SyncRoot
        {
            get { return (this.keyValueDic as ICollection).SyncRoot; }
        }

        #endregion

        #region IDictionary Members


        bool IDictionary.IsFixedSize
        {
            get { return (this.keyValueDic as IDictionary).IsFixedSize; }
        }




        #endregion

        #region ICollection Members


        int ICollection.Count
        {
            get { return this.Count; }
        }

        #endregion

        #region IDictionary Members

        public void Add(object key, object value)
        {
            this.Add((TKey)key, (TValue)value);
        }

        public bool Contains(object key)
        {
            return this.Contains((TKey)key);
        }

        IDictionaryEnumerator IDictionary.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        ICollection IDictionary.Keys
        {
            get { return this.Keys; }
        }

        public void Remove(object key)
        {
            this.Remove((TKey)key);
        }

        ICollection IDictionary.Values
        {
            get { return this.Values; }
        }

        public object this[object key]
        {
            get
            {
                return this[(TKey)key];
            }
            set
            {
                this[(TKey)key] = (TValue)value;
            }
        }

        #endregion

        #region IDictionary<TKey,TValue> Members


        ICollection<TKey> IDictionary<TKey, TValue>.Keys
        {
            get { return this.Keys; }
        }

        bool IDictionary<TKey, TValue>.Remove(TKey key)
        {
            return this.Remove(key);
        }
        /// <summary>
        ///  Gets the value associated with the specified key.
        /// </summary>
        /// <param name="key"> The key of the value to get.</param>
        /// <param name="value">
        /// When this method returns, contains the value associated with the specified
        ///     key, if the key is found; otherwise, the default value for the type of the
        ///    value parameter. This parameter is passed uninitialized.
        /// </param>
        /// <returns> true if the System.Collections.Generic.Dictionary&lt;TKey,TValue&gt; contains an
        ///     element with the specified key; otherwise, false.
        ///  </returns>
        ///  <exception cref="System.ArgumentNullException">
        ///  key is null.
        ///  </exception>
        public bool TryGetValue(TKey key, out TValue value)
        {
            return keyValueDic.TryGetValue(key, out value);
        }
        /// <summary>
        /// Tries to get key out of the dictionary.
        /// Acts as the opposite of TryGetValue
        /// </summary>
        /// <param name="value">Value (act as key in the opposite direction</param>
        /// <param name="key">Key (act as value in the opposite direction)</param>
        /// <returns>True if key exists, false otherwise</returns>
        public bool TryGetKey(TValue value, out TKey key)
        {
            return valueKeyDic.TryGetValue(value, out key);
        }

        /// <summary>
        /// Gets all dictionbary values
        /// </summary>
        ICollection<TValue> IDictionary<TKey, TValue>.Values
        {
            get { return this.Values; }
        }

        #endregion
    }
}