using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace Stackoverflow.Utilities
{
	/// <summary>
	/// This is a dictionary guaranteed to have only one of each value and key. 
	/// It may be searched either by TFirst or by TSecond, giving a unique answer because it is 1 to 1.
	/// It implements garbage-collector-friendly IEnumerable.
	/// </summary>
	/// <remarks>From https://stackoverflow.com/a/35949314/1460422</remarks>
	/// <typeparam name="TFirst">The type of the "key"</typeparam>
	/// <typeparam name="TSecond">The type of the "value"</typeparam>
	public class BiDictionary<TFirst, TSecond> : IEnumerable<BiDictionary<TFirst, TSecond>.Pair>
	{


		public struct Pair
		{
			public TFirst First;
			public TSecond Second;
		}


		public struct Enumerator : IEnumerator<Pair>, IEnumerator
		{

			public Enumerator(IEnumerable<KeyValuePair<TFirst, TSecond>> dictEnumerator)
			{
				_dictEnumerator = dictEnumerator.GetEnumerator();
			}

			public Pair Current {
				get {
					Pair pair;
					pair.First = _dictEnumerator.Current.Key;
					pair.Second = _dictEnumerator.Current.Value;
					return pair;
				}
			}

			object IEnumerator.Current {
				get {
					return Current;
				}
			}

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

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

			public void Reset()
			{
				throw new NotSupportedException();
			}

			private IEnumerator<KeyValuePair<TFirst, TSecond>> _dictEnumerator;

		}

		#region Exception throwing methods

		/// <summary>
		/// Tries to add the pair to the dictionary.
		/// Throws an exception if either element is already in the dictionary
		/// </summary>
		/// <param name="first"></param>
		/// <param name="second"></param>
		public void Add(TFirst first, TSecond second)
		{
			if (_firstToSecond.ContainsKey(first) || _secondToFirst.ContainsKey(second))
				throw new ArgumentException("Duplicate first or second");

			_firstToSecond.TryAdd(first, second);
			_secondToFirst.TryAdd(second, first);
		}

		/// <summary>
		/// Find the TSecond corresponding to the TFirst first
		/// Throws an exception if first is not in the dictionary.
		/// </summary>
		/// <param name="first">the key to search for</param>
		/// <returns>the value corresponding to first</returns>
		public TSecond GetByFirst(TFirst first)
		{
			TSecond second;
			if (!_firstToSecond.TryGetValue(first, out second))
				throw new ArgumentException("first");

			return second;
		}

		/// <summary>
		/// Find the TFirst corresponing to the Second second.
		/// Throws an exception if second is not in the dictionary.
		/// </summary>
		/// <param name="second">the key to search for</param>
		/// <returns>the value corresponding to second</returns>
		public TFirst GetBySecond(TSecond second)
		{
			TFirst first;
			if (!_secondToFirst.TryGetValue(second, out first))
				throw new ArgumentException("second");

			return first;
		}


		/// <summary>
		/// Remove the record containing first.
		/// If first is not in the dictionary, throws an Exception.
		/// </summary>
		/// <param name="first">the key of the record to delete</param>
		public void RemoveByFirst(TFirst first)
		{
			TSecond second;
			if (!_firstToSecond.TryGetValue(first, out second))
				throw new ArgumentException("first");

			_firstToSecond.TryRemove(first, out TSecond noop);
			_secondToFirst.TryRemove(second, out TFirst noopAgain);
		}

		/// <summary>
		/// Remove the record containing second.
		/// If second is not in the dictionary, throws an Exception.
		/// </summary>
		/// <param name="second">the key of the record to delete</param>
		public void RemoveBySecond(TSecond second)
		{
			TFirst first;
			if (!_secondToFirst.TryGetValue(second, out first))
				throw new ArgumentException("second");

			_secondToFirst.TryRemove(second, out TFirst noop);
			_firstToSecond.TryRemove(first, out TSecond noopAgain);
		}

		#endregion

		#region Try methods

		/// <summary>
		/// Tries to add the pair to the dictionary.
		/// Returns false if either element is already in the dictionary        
		/// </summary>
		/// <param name="first"></param>
		/// <param name="second"></param>
		/// <returns>true if successfully added, false if either element are already in the dictionary</returns>
		public bool TryAdd(TFirst first, TSecond second)
		{
			if (_firstToSecond.ContainsKey(first) || _secondToFirst.ContainsKey(second))
				return false;

			bool result = _firstToSecond.TryAdd(first, second);
			result = _secondToFirst.TryAdd(second, first) || result;
			return result;
		}


		/// <summary>
		/// Find the TSecond corresponding to the TFirst first.
		/// Returns false if first is not in the dictionary.
		/// </summary>
		/// <param name="first">the key to search for</param>
		/// <param name="second">the corresponding value</param>
		/// <returns>true if first is in the dictionary, false otherwise</returns>
		public bool TryGetByFirst(TFirst first, out TSecond second)
		{
			return _firstToSecond.TryGetValue(first, out second);
		}

		/// <summary>
		/// Find the TFirst corresponding to the TSecond second.
		/// Returns false if second is not in the dictionary.
		/// </summary>
		/// <param name="second">the key to search for</param>
		/// <param name="first">the corresponding value</param>
		/// <returns>true if second is in the dictionary, false otherwise</returns>
		public bool TryGetBySecond(TSecond second, out TFirst first)
		{
			return _secondToFirst.TryGetValue(second, out first);
		}

		/// <summary>
		/// Remove the record containing first, if there is one.
		/// </summary>
		/// <param name="first"></param>
		/// <returns> If first is not in the dictionary, returns false, otherwise true</returns>
		public bool TryRemoveByFirst(TFirst first)
		{
			TSecond second;
			if (!_firstToSecond.TryGetValue(first, out second))
				return false;

			bool result = _firstToSecond.TryRemove(first, out TSecond noop);
			result = _secondToFirst.TryRemove(second, out TFirst noopAgain) || result;
			return result;
		}

		/// <summary>
		/// Remove the record containing second, if there is one.
		/// </summary>
		/// <param name="second"></param>
		/// <returns> If second is not in the dictionary, returns false, otherwise true</returns>
		public bool TryRemoveBySecond(TSecond second)
		{
			TFirst first;
			if (!_secondToFirst.TryGetValue(second, out first))
				return false;

			_secondToFirst.TryRemove(second, out TFirst noop);
			_firstToSecond.TryRemove(first, out TSecond noopAgain);
			return true;
		}

		#endregion

		/// <summary>
		/// The number of pairs stored in the dictionary
		/// </summary>
		public Int32 Count {
			get { return _firstToSecond.Count; }
		}

		/// <summary>
		/// Removes all items from the dictionary.
		/// </summary>
		public void Clear()
		{
			_firstToSecond.Clear();
			_secondToFirst.Clear();
		}


		public Enumerator GetEnumerator()
		{
			//enumerator.Reset(firstToSecond.GetEnumerator());
			return new Enumerator(_firstToSecond);
		}

		IEnumerator<Pair> IEnumerable<Pair>.GetEnumerator()
		{
			return GetEnumerator();
		}

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



		private ConcurrentDictionary<TFirst, TSecond> _firstToSecond = new ConcurrentDictionary<TFirst, TSecond>();
		private ConcurrentDictionary<TSecond, TFirst> _secondToFirst = new ConcurrentDictionary<TSecond, TFirst>();

	}
}