namespace RSn9.Caching
{
	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Timers;

	/// MRW: 19/02/07
	public sealed class SimpleCache<T> : IDictionary<string, T>,
	                                     ICollection<KeyValuePair<string, T>>,
	                                     ICollection,
	                                     IEnumerable<KeyValuePair<string, T>>,
	                                     IEnumerable,
	                                     IDisposable
	{
		private TimeSpan _commonSlide = TimeSpan.FromMinutes(5);
		private TimeSpan _commonExpire = TimeSpan.FromMinutes(15);
		private Dictionary<string, entry<T>> _data;
		private Timer _timer;

		/// <summary>
		/// Gets or sets the <see cref="T"/> with the specified key.
		/// </summary>
		/// <value></value>
		/// MRW: 29/02/2006 
		public T this[string key]
		{
			get
			{
				lock( ( (ICollection)this._data ).SyncRoot )
				{
					if ( this._data[key].Slide() )
					{
						this.Remove( key );

						return default(T);
					}
					else
					{
						return this._data[key]._data;
					}
				}
			}
			set
			{
				lock( ( (ICollection)this._data ).SyncRoot )
				{
					if ( this._data[key].Slide() )
						this.Remove( key );
					else
						this._data[key]._data = value;
				}
			}
		}

		#region (de)construction
		/// <summary>
		/// Initializes a new instance of the <see cref="SimpleCache"/> class.
		/// </summary>
		/// MRW: 29/02/2006 
		public SimpleCache()
			: this(4, TimeSpan.FromSeconds(5)) {}

		/// <summary>
		/// Initializes a new instance of the <see cref="SimpleCache"/> class.
		/// </summary>
		/// <param name="capacity">The capacity.</param>
		/// MRW: 29/02/2006 
		public SimpleCache(int capacity)
			: this(capacity, TimeSpan.FromSeconds(5)) {}

		/// <summary>
		/// Initializes a new instance of the <see cref="SimpleCache"/> class.
		/// </summary>
		/// <param name="interval">The interval.</param>
		/// MRW: 29/02/2006
		public SimpleCache( TimeSpan interval )
			: this( 4, interval ) { }

		/// <summary>
		/// Initializes a new instance of the <see cref="SimpleCache"/> class.
		/// </summary>
		/// MRW: 29/02/2006 
		public SimpleCache(int capacity, TimeSpan interval)
		{
			this._data = new Dictionary<string, entry<T>>(capacity);
			this._timer = new Timer();
			this._timer.AutoReset = true;
			this._timer.Interval = interval.TotalMilliseconds;
			this._timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
			this._timer.Start();
		}

		/// <summary>
		/// Releases unmanaged resources and performs other cleanup operations before the
		/// <see cref="SimpleCache"/> is reclaimed by garbage collection.
		/// </summary>
		/// MRW: 29/02/2006 
		~SimpleCache()
		{
			this.Dispose(false);
		}

		/// <summary>
		/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
		/// </summary>
		/// MRW: 29/02/2006 
		public void Dispose()
		{
			this.Dispose(true);
			GC.SuppressFinalize(this);
		}

		/// <summary>
		/// Disposes the specified disposing.
		/// </summary>
		/// <param name="disposing">if set to <c>true</c> [disposing].</param>
		/// MRW: 29/02/2006 
		private void Dispose(bool disposing)
		{
			if( disposing )
			{
				this.RemoveAll();

				if( this._timer != null )
				{
					this._timer.Dispose();
					this._timer = null;
				}
			}
		}
		#endregion

		#region Additive
		/// <summary>
		/// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.
		/// </summary>
		/// <param name="key">The object to use as the key of the element to add.</param>
		/// <param name="value">The object to use as the value of the element to add.</param>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IDictionary`2"></see> is read-only.</exception>
		/// <exception cref="T:System.ArgumentException">An element with the same key already exists in the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.</exception>
		/// <exception cref="T:System.ArgumentNullException">key is null.</exception>
		/// MRW: 29/02/2006 
		public void Add(string key, T value)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				this._data.Add(key, new entry<T>(value, this._commonExpire, this._commonSlide, null));
		}

		/// <summary>
		/// Adds the specified key.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="value">The value.</param>
		/// <param name="expire">The expire.</param>
		/// MRW: 29/02/2006 
		public void Add(string key, T value, TimeSpan expire)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				this._data.Add(key, new entry<T>(value, expire, this._commonSlide, null));
		}

		/// <summary>
		/// Adds the specified key.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="value">The value.</param>
		/// <param name="expire">The expire.</param>
		/// <param name="slide">The slide.</param>
		/// MRW: 29/02/2006 
		public void Add(string key, T value, TimeSpan expire, TimeSpan slide)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				this._data.Add(key, new entry<T>(value, expire, slide, null));
		}

		/// <summary>
		/// Adds the specified key.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="value">The value.</param>
		/// <param name="expireHandle">The expire handle.</param>
		/// MRW: 29/02/2006 
		public void Add(string key, T value, EventHandler expireHandle)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				this._data.Add(key, new entry<T>(value, this._commonExpire, this._commonSlide, expireHandle));
		}

		/// <summary>
		/// Adds the specified key.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="value">The value.</param>
		/// <param name="expire">The expire.</param>
		/// <param name="expireHandle">The expire handle.</param>
		/// MRW: 29/02/2006 
		public void Add(string key, T value, TimeSpan expire, EventHandler expireHandle)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				this._data.Add(key, new entry<T>(value, expire, this._commonSlide, expireHandle));
		}

		/// <summary>
		/// Adds the specified key.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="value">The value.</param>
		/// <param name="expire">The expire.</param>
		/// <param name="slide">The slide.</param>
		/// <param name="expireHandle">The expire handle.</param>
		/// MRW: 29/02/2006
		public void Add(string key, T value, TimeSpan expire, TimeSpan slide, EventHandler expireHandle)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				this._data.Add(key, new entry<T>(value, expire, slide, expireHandle));
		}
		#endregion

		#region Subtractive
		/// <summary>
		/// Forces the expire.
		/// </summary>
		/// MRW: 29/02/2006 
		public void ForceExpire()
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				try
				{
					this._timer.Stop();

					this.InternalExpire(true);
				}
				finally
				{
					this._timer.Start();
				}
		}

		/// <summary>
		/// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.
		/// </summary>
		/// <param name="key">The key of the element to remove.</param>
		/// <returns>
		/// true if the element is successfully removed; otherwise, false.  This method also returns false if key was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"></see>.
		/// </returns>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IDictionary`2"></see> is read-only.</exception>
		/// <exception cref="T:System.ArgumentNullException">key is null.</exception>
		/// MRW: 29/02/2006 
		public bool Remove(string key)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
			{
				if( this._data[key]._onExpire != null )
					this._data[key]._onExpire(this._data[key]._data, EventArgs.Empty);

				this._data[key].Dispose();

				return this._data.Remove(key);
			}
		}

		/// <summary>
		/// Removes all.
		/// </summary>
		/// MRW:  29/02/2006
		public void RemoveAll()
		{
			if( this._data.Count > 0 )
				lock( ( (ICollection)this._data ).SyncRoot )
				{
					foreach( string key in this._data.Keys )
						this.Remove(key);

					this._data.Clear();
				}
		}
		#endregion

		#region Discriptive
		/// <summary>
		/// Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2"></see> contains an element with the specified key.
		/// </summary>
		/// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.</param>
		/// <returns>
		/// true if the <see cref="T:System.Collections.Generic.IDictionary`2"></see> contains an element with the key; otherwise, false.
		/// </returns>
		/// <exception cref="T:System.ArgumentNullException">key is null.</exception>
		/// MRW: 29/02/2006
		public bool ContainsKey(string key)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				return this._data.ContainsKey(key);
		}

		/// <summary>
		/// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"></see>.
		/// </summary>
		/// <value></value>
		/// <returns>The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"></see>.</returns>
		/// MRW: 29/02/2006 
		public int Count
		{
			get
			{
				lock( ( (ICollection)this._data ).SyncRoot )
					return this._data.Count;
			}
		}

		/// <summary>
		/// Gets a value indicating whether the <see cref="T:System.Collections.Generic.ICollection`1"></see> is read-only.
		/// </summary>
		/// <value></value>
		/// <returns>true if the <see cref="T:System.Collections.Generic.ICollection`1"></see> is read-only; otherwise, false.</returns>
		/// MRW: 29/02/2006 
		public bool IsReadOnly
		{
			get { return false; }
		}

		/// <summary>
		/// Gets a value indicating whether access to the <see cref="T:System.Collections.ICollection"></see> is synchronized (thread safe).
		/// </summary>
		/// <value></value>
		/// <returns>true if access to the <see cref="T:System.Collections.ICollection"></see> is synchronized (thread safe); otherwise, false.</returns>
		/// MRW: 29/02/2006 
		public bool IsSynchronized
		{
			get { return true; }
		}
		#endregion

		#region operative
		/// <summary>
		/// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"></see>.
		/// </summary>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"></see> is read-only. </exception>
		/// MRW: 29/02/2006 
		public void Clear()
		{
			lock( ( (ICollection)this._data ).SyncRoot )
			{
				this._data.Clear();
			}
		}

		/// <summary>
		/// Copies the elements of the <see cref="T:System.Collections.ICollection"></see> to an <see cref="T:System.Array"></see>, starting at a particular <see cref="T:System.Array"></see> index.
		/// </summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array"></see> that is the destination of the elements copied from <see cref="T:System.Collections.ICollection"></see>. The <see cref="T:System.Array"></see> must have zero-based indexing.</param>
		/// <param name="index">The zero-based index in array at which copying begins.</param>
		/// <exception cref="T:System.ArgumentNullException">array is null. </exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">index is less than zero. </exception>
		/// <exception cref="T:System.ArgumentException">array is multidimensional.-or- index is equal to or greater than the length of array.-or- The number of elements in the source <see cref="T:System.Collections.ICollection"></see> is greater than the available space from index to the end of the destination array. </exception>
		/// <exception cref="T:System.InvalidCastException">The type of the source <see cref="T:System.Collections.ICollection"></see> cannot be cast automatically to the type of the destination array. </exception>
		/// MRW: 29/02/2006 
		public void CopyTo(Array array, int index)
		{
			( (ICollection)this._data ).CopyTo(array, index);
		}

		/// <summary>
		/// Gets an <see cref="T:System.Collections.Generic.ICollection`1"></see> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.
		/// </summary>
		/// <value></value>
		/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1"></see> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"></see>.</returns>
		/// MRW: 29/02/2006 
		public ICollection<string> Keys
		{
			get
			{
				lock( ( (ICollection)this._data ).SyncRoot )
					return this._data.Keys;
			}
		}

		/// <summary>
		/// Gets a COPY of <see cref="T:System.Collections.Generic.ICollection`1"></see> containing the values in the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.
		/// </summary>
		/// <value></value>
		/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1"></see> containing the values in the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"></see>.</returns>
		/// MRW: 29/02/2006 
		public ICollection<T> Values
		{
			get
			{
				lock( ( (ICollection)this._data ).SyncRoot )
				{
					Dictionary<string, entry<T>>.ValueCollection rr = this._data.Values;

					List<T> lst = new List<T>(rr.Count);

					foreach( entry<T> en in rr )
						lst.Add(en._data);

					return lst;
				}
			}
		}

		/// <summary>
		/// Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"></see>.
		/// </summary>
		/// <value></value>
		/// <returns>An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"></see>.</returns>
		/// MRW: 29/02/2006 
		public object SyncRoot
		{
			get { return true; }
		}

		/// <summary>
		/// Returns an enumerator that iterates through the cache.
		/// </summary>
		/// <returns>
		/// An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection.
		/// </returns>
		/// MRW: 29/02/2006 
		public IEnumerator GetEnumerator()
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				return this._data.GetEnumerator();
		}

		/// <summary>
		/// Not implemented.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="value">The value.</param>
		/// <returns></returns>
		/// MRW: 29/02/2006 
		bool IDictionary<string, T>.TryGetValue(string key, out T value)
		{
			throw new NotImplementedException();
		}
		#endregion

		#region KeyValuePair based
		/// <summary>
		/// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"></see>.
		/// </summary>
		/// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"></see> is read-only.</exception>
		/// MRW: 29/02/2006 
		public void Add(KeyValuePair<string, T> item)
		{
			this.Add(item.Key, item.Value);
		}

		/// <summary>
		/// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"></see>.
		/// </summary>
		/// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"></see> is read-only.</exception>
		/// MRW: 29/02/2006 
		void ICollection<KeyValuePair<string, T>>.Add(KeyValuePair<string, T> item)
		{
			this.Add(item.Key, item.Value);
		}

		/// <summary>
		/// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"></see> contains a specific value.
		/// </summary>
		/// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
		/// <returns>
		/// true if item is found in the <see cref="T:System.Collections.Generic.ICollection`1"></see>; otherwise, false.
		/// </returns>
		/// MRW: 29/02/2006 
		bool ICollection<KeyValuePair<string, T>>.Contains(KeyValuePair<string, T> item)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
			{
				Dictionary<string, T> tmp = new Dictionary<string, T>(this._data.Count);

				foreach( string key in this._data.Keys )
					tmp.Add(key, this._data[key]._data);

				return ( (ICollection<KeyValuePair<string, T>>)tmp ).Contains(item);
			}
		}

		/// <summary>
		/// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"></see> to an <see cref="T:System.Array"></see>, starting at a particular <see cref="T:System.Array"></see> index.
		/// </summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array"></see> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"></see>. The <see cref="T:System.Array"></see> must have zero-based indexing.</param>
		/// <param name="arrayIndex">The zero-based index in array at which copying begins.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">arrayIndex is less than 0.</exception>
		/// <exception cref="T:System.ArgumentNullException">array is null.</exception>
		/// <exception cref="T:System.ArgumentException">array is multidimensional.-or-arrayIndex is equal to or greater than the length of array.-or-The number of elements in the source <see cref="T:System.Collections.Generic.ICollection`1"></see> is greater than the available space from arrayIndex to the end of the destination array.-or-Type T cannot be cast automatically to the type of the destination array.</exception>
		/// MRW: 29/02/2006 
		void ICollection<KeyValuePair<string, T>>.CopyTo(KeyValuePair<string, T>[] array, int arrayIndex)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
			{
				Dictionary<string, T> tmp = new Dictionary<string, T>(this._data.Count);

				foreach( string key in this._data.Keys )
					tmp.Add(key, this._data[key]._data);

				( (ICollection<KeyValuePair<string, T>>)tmp ).CopyTo(array, arrayIndex);
			}
		}

		/// <summary>
		/// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"></see>.
		/// </summary>
		/// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
		/// <returns>
		/// true if item was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"></see>; otherwise, false. This method also returns false if item is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"></see>.
		/// </returns>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"></see> is read-only.</exception>
		/// MRW: 29/02/2006
		bool ICollection<KeyValuePair<string, T>>.Remove(KeyValuePair<string, T> item)
		{
			return this.Remove(item.Key);
		}

		/// <summary>
		/// Returns an enumerator that iterates through the collection.
		/// </summary>
		/// <returns>
		/// A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.
		/// </returns>
		/// MRW: 29/02/2006 
		IEnumerator<KeyValuePair<string, T>> IEnumerable<KeyValuePair<string, T>>.GetEnumerator()
		{
			lock( ( (ICollection)this._data ).SyncRoot )
			{
				Dictionary<string, T> tmp = new Dictionary<string, T>(this._data.Count);

				foreach( string key in this._data.Keys )
					tmp.Add(key, this._data[key]._data);

				return tmp.GetEnumerator();
			}
		}
		#endregion

		#region internal implementation
		/// <summary>
		/// Handles the Elapsed event of the _timer control.
		/// </summary>
		/// <param name="sender">The source of the event.</param>
		/// <param name="e">The <see cref="System.Timers.ElapsedEventArgs"/> instance containing the event data.</param>
		/// MRW: 29/02/2006 
		private void _timer_Elapsed(object sender, ElapsedEventArgs e)
		{
			lock( ( (ICollection)this._data ).SyncRoot )
				try
				{
					this._timer.Stop();

					this.InternalExpire(false);
				}
				finally
				{
					this._timer.Start();
				}
		}

		/// <summary>
		/// Internally runs the expiry.
		/// </summary>
		/// <param name="force">if set to <c>true</c> [force].</param>
		/// MRW: 29/02/2006 
		private void InternalExpire(bool force)
		{
			if( this._data.Count > 0 )
			{
				List<string> killList = new List<string>();
				DateTime now = DateTime.Now;

				foreach( string key in this._data.Keys )
				{
					entry<T> tmp = this._data[key];

					if( tmp._expire < now && ( force || tmp._allowExpire ) )
						killList.Add(key);
				}
				foreach( string key in killList )
				{
					if( this._data[key]._onExpire != null )
						this._data[key]._onExpire(this._data[key]._data, EventArgs.Empty);

					this._data[key].Dispose();
					this._data.Remove(key);
				}
			}
		}
		#endregion

		#region entry<U>
		/// <summary>
		/// Represents a cache entry and all of its associated data
		/// </summary>
		/// <typeparam name="U">Anything... literally</typeparam>
		/// MRW: 29/02/2006 
		private sealed class entry<U> : IDisposable
		{
			public U _data;
			public DateTime _stamp;
			public TimeSpan _slide;
			public DateTime _expire;
			public bool _allowExpire;
			public EventHandler _onExpire;

			public bool Slide()
			{
				DateTime now = DateTime.Now;

				if ( now < this._expire )
				{
					if ( now + this._slide > this._expire )
						this._expire = this._expire.Add( this._slide );

					return false; 
				}

				return true; // expire NOW! do not pass go...
			}

			/// <summary>
			/// Initializes a new instance of the <see cref="entry&lt;U&gt;"/> class.
			/// </summary>
			/// <param name="data">The data.</param>
			/// <param name="expire">The expire.</param>
			/// <param name="slide">The slide.</param>
			/// <param name="expireHandler">The expire handler.</param>
			/// MRW: 29/02/2006 
			public entry(U data, TimeSpan expire, TimeSpan slide, EventHandler expireHandler)
			{
				this._data = data;
				this._stamp = DateTime.Now;
				this._slide = slide;

				if ( expire == TimeSpan.Zero )
					this._allowExpire = false;
				else if ( expire == TimeSpan.MaxValue )
				{
					this._expire = this._stamp.Add( this._slide );
					this._allowExpire = true;
				}
				else
				{
					this._allowExpire = true;
					this._expire = this._stamp.Add( expire );
				}

				this._onExpire = expireHandler;
			}

			/// <summary>
			/// Releases unmanaged resources and performs other cleanup operations before the
			/// <see cref="entry&lt;U&gt;"/> is reclaimed by garbage collection.
			/// </summary>
			/// MRW: 29/02/2006 
			~entry()
			{
				this.Dispose(false);
			}

			/// <summary>
			/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
			/// </summary>
			/// MRW: 29/02/2006 
			public void Dispose()
			{
				this.Dispose(true);
				GC.SuppressFinalize(this);
			}

			/// <summary>
			/// Disposes the specified disposing.
			/// </summary>
			/// <param name="disposing">if set to <c>true</c> [disposing].</param>
			/// MRW: 29/02/2006 
			private void Dispose(bool disposing)
			{
				if( disposing )
					if( this._data is IDisposable )
						( this._data as IDisposable ).Dispose();
			}
		}
		#endregion
	}
}