#pragma once

#include <msclr\lock.h>

#define		LOCKTHREAD 	const lock mon( safe_cast<ICollection^>(this->_data)->SyncRoot )
#define		KEY_PAIR	Generic::KeyValuePair<String^, T>

using namespace msclr;
using namespace System;
using namespace System::Collections;
using namespace System::Timers;
using namespace System::Runtime::InteropServices;

namespace RSn9
{
	namespace Caching
	{
		generic<typename T>
		public ref class SimpleCache sealed :	public Generic::IDictionary<String^, T>,
												public Generic::ICollection<KEY_PAIR>, public ICollection,
												public Generic::IEnumerable<KEY_PAIR>, public IEnumerable
		{
		private:
	
			generic<typename U>
			ref class entry;

			TimeSpan								_commonSlide;
			TimeSpan								_commonExpire;
			Generic::Dictionary<String^,entry<T>^>^	_data;
			Timer^									_timer;

			/// <summary>
			/// General initialisation a new instance of the <see cref="SimpleCache&amp;lt;T&amp;gt;"/> class.
			/// </summary>
			/// <param name="capacity">The capacity.</param>
			/// <param name="interval">The interval.</param>
			/// MRW: 02/03/2007
			void constructme(int capacity, TimeSpan interval)
			{
				this->_commonSlide = TimeSpan::FromMinutes(5);
				this->_commonExpire= TimeSpan::FromMinutes(15);
				
				this->_data = gcnew Generic::Dictionary<String^, entry<T>^>(capacity);
				
				this->_timer = gcnew Timer;
				this->_timer->AutoReset = true;
				this->_timer->Interval = interval.TotalMilliseconds;
				this->_timer->Elapsed += gcnew ElapsedEventHandler(this,&SimpleCache<T>::_timer_Elapsed);
				this->_timer->Start();
			}

			/// <summary>
			/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
			/// </summary>
			/// MRW: 02/03/2007 
			~SimpleCache()
			{
				this->!SimpleCache();
			}

			/// <summary>
			/// Releases unmanaged resources and performs other cleanup operations before the
			/// <see cref="SimpleCache&amp;lt;T&amp;gt;"/> is reclaimed by garbage collection.
			/// </summary>
			/// MRW: 02/03/2007
			!SimpleCache()
			{
				this->RemoveAll();

				if( this->_timer != nullptr )
				{
					delete this->_timer;
					this->_timer = nullptr;
				}
			}

		public:
			/// <summary>
			/// Initializes a new instance of the <see cref="SimpleCache&amp;lt;T&amp;gt;"/> class.
			/// </summary>
			/// MRW: 02/03/2007 
			SimpleCache()
			{
				this->constructme(4, TimeSpan::FromSeconds(5));
			}

			/// <summary>
			/// Initializes a new instance of the <see cref="SimpleCache&amp;lt;T&amp;gt;"/> class.
			/// </summary>
			/// <param name="capacity">The capacity.</param>
			/// MRW: 02/03/2007 
			SimpleCache(int capacity)
			{
				this->constructme(capacity, TimeSpan::FromSeconds(5));
			}

			/// <summary>
			/// Initializes a new instance of the <see cref="SimpleCache&amp;lt;T&amp;gt;"/> class.
			/// </summary>
			/// <param name="capacity">The capacity.</param>
			/// <param name="interval">The interval.</param>
			/// MRW: 02/03/2007 
			SimpleCache(int capacity, TimeSpan interval)
			{
				this->constructme(capacity, interval);
			}

			/// <summary>
			/// Gets or sets the <see cref="T"/> with the specified key.
			/// </summary>
			/// <value></value>
			/// MRW: 02/03/2007 
			property T default[String ^]
			{
				virtual T get(String^ key)
				{
					LOCKTHREAD;

					this->_data[key]->_stamp += this->_data[key]->_slide;

					return this->_data[key]->_data;
				}
				virtual void set(String^ key, T value)
				{
					LOCKTHREAD;
				
					this->_data[key]->_stamp += this->_data[key]->_slide;

					this->_data[key]->_data = value;
				}
			}

			/// <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>
			/// MRW: 02/03/2007
			virtual void Add(String^ key, T value)
			{
				LOCKTHREAD;

				this->_data->Add(key, gcnew entry<T>(value, this->_commonExpire, this->_commonSlide , nullptr));
			}

			/// <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: 02/03/2007
			void Add(String^ key, T value, TimeSpan expire)
			{
				LOCKTHREAD;

				this->_data->Add(key, gcnew entry<T>(value,expire,this->_commonSlide,nullptr));
			}

			/// <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: 02/03/2007
			void Add(String^ key, T value, TimeSpan expire, TimeSpan slide)
			{
				LOCKTHREAD;

				this->_data->Add(key, gcnew entry<T>(value,expire,slide,nullptr));
			}

			/// <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: 02/03/2007
			void Add(String^ key, T value, EventHandler^ expireHandle)
			{
				LOCKTHREAD;

				this->_data->Add(key, gcnew 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: 02/03/2007
			void Add(String^ key, T value, TimeSpan expire, EventHandler^ expireHandle)
			{
				LOCKTHREAD;

				this->_data->Add(key, gcnew 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: 02/03/2007
			void Add(String^ key, T value, TimeSpan expire, TimeSpan slide, EventHandler^ expireHandle)
			{
				LOCKTHREAD;

				this->_data->Add(key, gcnew entry<T>(value,expire,slide,expireHandle));
			}

			/// <summary>
			/// Forces the expire.
			/// </summary>
			/// MRW: 02/03/2007
			void ForceExpire()
			{
				LOCKTHREAD;
				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>
			/// MRW: 02/03/2007
			virtual bool Remove(String^ key)
			{
				LOCKTHREAD;
				
				if(this->_data[key]->_onExpire != nullptr)
					this->_data[key]->_onExpire(this->_data[key]->_data, EventArgs::Empty);

				delete this->_data[key];

				return this->_data->Remove(key);
			}

			/// <summary>
			/// Removes all.
			/// </summary>
			/// MRW: 02/03/2007
			void RemoveAll()
			{
				if(this->_data->Count >0)
				{
					LOCKTHREAD;

					for each(String^ key in this->_data->Keys)
						this->Remove(key);

					this->_data->Clear();
				}
			}

			/// <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>
			/// MRW: 02/03/2007
			virtual bool ContainsKey(String^ key)
			{
				LOCKTHREAD;

				return this->_data->ContainsKey(key);
			}

			/// <summary>
			/// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"></see>.
			/// </summary>
			/// MRW: 02/03/2007
			virtual void Clear()
			{
				LOCKTHREAD;

				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>
			/// MRW: 02/03/2007
			virtual void CopyTo(Array^ arry, int index)
			{
				LOCKTHREAD;

				safe_cast<ICollection^>(this->_data)->CopyTo(arry,index);
			}

			/// <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: 02/03/2007
			property Object^ SyncRoot
			{
				virtual Object^ get()
				{
					return safe_cast<ICollection^>(this->_data)->SyncRoot;
				}
			}

			/// <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: 02/03/2007
			property Generic::ICollection<T>^ Values
			{
				virtual Generic::ICollection<T>^ get()
				{
					LOCKTHREAD;

					Generic::Dictionary<String^,entry<T>^>::ValueCollection^ rr = this->_data->Values;

					Generic::List<T>^ lst = gcnew Generic::List<T>(rr->Count);

					for each(entry<T>^ en in rr)
						lst->Add(en->_data);

					return lst;
				}
			}

			/// <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: 02/03/2007
			property Generic::ICollection<String^>^ Keys
			{
				virtual Generic::ICollection<String^>^ get()
				{
					LOCKTHREAD;
					return this->_data->Keys;
				}
			}

			/// <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: 02/03/2007
			property int Count
			{
				virtual int get()
				{
					LOCKTHREAD;
					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: 02/03/2007
			property bool IsReadOnly
			{
				virtual bool 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: 02/03/2007
			property bool IsSynchronized
			{
				virtual bool get()
				{
					return true;
				}
			}

			/// <summary>
			/// Gets or sets the common expire.
			/// </summary>
			/// <value>The common expire.</value>
			/// MRW: 02/03/2007
			property TimeSpan CommonExpire
			{
				TimeSpan get()
				{
					return this->_commonExpire;
				}
				void set(TimeSpan value)
				{
					this->_commonExpire = value;
				}
			}

			/// <summary>
			/// Gets or sets the common slide.
			/// </summary>
			/// <value>The common slide.</value>
			/// MRW: 02/03/2007
			property TimeSpan CommonSlide
			{
				TimeSpan get()
				{
					return this->_commonSlide;
				}
				void set(TimeSpan value)
				{
					this->_commonSlide = value;
				}
			}

			/// <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: 02/03/2007
			virtual IEnumerator^ GetEnumerator() = IEnumerable::GetEnumerator
			{
				LOCKTHREAD;

				return this->_data->GetEnumerator();
			}

		private:
			/// <summary>
			/// Not implemented.
			/// </summary>
			/// <param name="key">The key.</param>
			/// <param name="value">The value.</param>
			/// <returns></returns>
			/// MRW: 02/03/2007
			virtual bool TryGetValue(String^ key,[Out] T %value) sealed = Generic::IDictionary<String^,T>::TryGetValue
			{
				throw gcnew NotImplementedException();
			}

			/// <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: 02/03/2007
			virtual void Add2(KEY_PAIR item) sealed = Generic::ICollection<KEY_PAIR>::Add
			{
				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: 02/03/2007
			virtual bool Contains2(KEY_PAIR item) sealed = Generic::ICollection<KEY_PAIR>::Contains
			{
				LOCKTHREAD;

				Generic::Dictionary<String^, T>^ tmp = gcnew Generic::Dictionary<String^, T>(this->_data->Count);

				for each( String^ key in this->_data->Keys )
					tmp->Add(key, this->_data[key]->_data);

				return safe_cast<Generic::ICollection<KEY_PAIR>^>(tmp)->Contains(item);
			}

			/// <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: 02/03/2007
			virtual Generic::IEnumerator<KEY_PAIR>^ GetEnumerator2() sealed = Generic::IEnumerable<KEY_PAIR>::GetEnumerator
			{
				LOCKTHREAD;

				Generic::Dictionary<String^, T>^ tmp = gcnew Generic::Dictionary<String^, T>(this->_data->Count);

				for each( String^ key in this->_data->Keys )
					tmp->Add(key, this->_data[key]->_data);

				return tmp->GetEnumerator();
			}

			/// <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>
			/// MRW: 02/03/2007
			virtual void CopyTo2(array<KEY_PAIR>^ arry, int arrayIndex) sealed = Generic::ICollection<KEY_PAIR>::CopyTo
			{
				LOCKTHREAD;

				Generic::Dictionary<String^, T>^ tmp = gcnew Generic::Dictionary<String^, T>(this->_data->Count);

				for each( String^ key in this->_data->Keys )
					tmp->Add(key, this->_data[key]->_data);

				safe_cast<Generic::ICollection<KEY_PAIR>^>(tmp)->CopyTo(arry, 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>
			/// MRW: 02/03/2007
			virtual bool Remove(KEY_PAIR item) sealed = Generic::ICollection<KEY_PAIR>::Remove
			{
				return this->Remove(item.Key);
			}

			/// <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: 02/03/2007
			void _timer_Elapsed(Object^ sender, ElapsedEventArgs^ e)
			{
				LOCKTHREAD;
				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: 02/03/2007
			void InternalExpire(bool force)
			{
				if( this->_data->Count > 0 )
				{
					const DateTime now = DateTime::Now;

					Generic::List<String^>^ killList = gcnew Generic::List<String^>;

					for each( String^ key in this->_data->Keys )
					{
						entry<T>^ tmp = this->_data[key];

						if( tmp->_expire < now && ( force || tmp->_allowExpire ) )
							killList->Add(key);
					}

					for each( String^ key in killList )
						this->Remove(key);
				}
			}

			/// <summary>
			/// Represents a cache entry and all of its associated data
			/// </summary>
			/// <typeparam name="U">Anything... literally</typeparam>
			/// MRW: 02/03/2007
			generic<typename U>
			ref class entry sealed
			{
			public:
				U				_data;
				DateTime		_stamp;
				TimeSpan		_slide;
				DateTime		_expire;
				bool			_allowExpire;
				EventHandler^	_onExpire;

				/// <summary>
				/// Initializes a new instance of the <see cref="entry&amp;lt;U&amp;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: 02/03/2007
				entry(U data, TimeSpan expire, TimeSpan slide, EventHandler^ expireHandler)
				{
					this->_data = data;
					this->_stamp = DateTime::Now;
					this->_slide = slide;
					this->_expire = this->_stamp.Add(expire);
					this->_onExpire = expireHandler;

					if( expire == TimeSpan::Zero )
						this->_allowExpire = false;
					else
						this->_allowExpire = true;
				}

				/// <summary>
				/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
				/// </summary>
				/// MRW: 02/03/2007
				~entry()
				{
					this->!entry();
				}

				/// <summary>
				/// Releases unmanaged resources and performs other cleanup operations before the
				/// <see cref="entry&amp;lt;U&amp;gt;"/> is reclaimed by garbage collection.
				/// </summary>
				/// MRW: 02/03/2007
				!entry()
				{
					delete this->_data;
				}
			};
		};
	}
}