using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic;
using System.Linq.Expressions;
using System.Reflection;
using System.ComponentModel;

namespace EPS.Common.Repositories
{
	/// <summary>
	/// An implementation of IRepository.
	/// </summary>
	/// <typeparam name="TModel">The type that the repository will contain.</typeparam>
    public class Repository<TModel> : IRepository<TModel> where TModel : IModel, new()
	{
		private int _idcounter = 0;
		/// <summary>
		/// Gets a count of the number of models in the repository.
		/// </summary>
		/// <value>The number of models in the repository.</value>
		public int Count
		{
			get
			{
				return _models.Count;
			}
		}
		private List<TModel> _models = new List<TModel>();
		/// <summary>
		/// Doesn't really find anything, just returns everything in the repository.
		/// </summary>
		/// <returns>The contents of the repository.</returns>
		public IEnumerable<TModel> FindAll()
		{
			return _models;
		}
		/// <summary>
		/// Finds an instance of TModel by id.
		/// </summary>
		/// <param name="id">The id of the TModel instance to find.</param>
		/// <returns>
		/// TModel if the id is found, otherwise null.
		/// </returns>
		public TModel Find(int id)
		{
			foreach(TModel m in this._models)
			{
				if (m.ID == id)
					return m;
			}
			return default(TModel);
		}
		/// <summary>
		/// Inserts the instance if it does not already exist, otherwise updates the existing one.
		/// </summary>
		/// <param name="model">The model to save.</param>
		public void Save(TModel model)
		{
			TModel existing = default(TModel);
			if (_models.Count > 0)
				existing = this.Find(model.ID);

			if (existing == null)
			{
				_idcounter += 1;
				model.ID = _idcounter;
				_models.Add(model);
				return;
			}

			//copy all of the writable values from the updated model to the existing model
			//excluding ID because we'd always be setting it to zero otherwise.
			foreach(PropertyInfo property in typeof(TModel).GetProperties())
			{
				if (!property.CanWrite && property.Name != "ID")
					continue;

				property.SetValue(existing, property.GetValue(model, null), null);
			}
		}
		/// <summary>
		/// Deletes the specified model from the repository.
		/// </summary>
		/// <param name="model">The model to be removed.</param>
		public void Delete(TModel model)
		{
			_models.RemoveAll(m => { return m.ID == model.ID; });
		}


		/// <summary>
		/// Orders the list by property name.
		/// </summary>
		/// <param name="propertyName">Name of the property.</param>
		/// <param name="sortDirection">The sort direction.</param>
		/// <returns>
		/// A new list sorted by property name in the order indicated by the sortDirection.
		/// </returns>
		public IEnumerable<TModel> OrderBy(string propertyName, Sort sortDirection)
		{
			if (String.IsNullOrEmpty(propertyName))
				throw new ArgumentNullException("propertyName");

			return _models.AsQueryable<TModel>().OrderBy(propertyName + " " + sortDirection.ToString());
		}

		/// <summary>
		/// Orders the list by property name.
		/// </summary>
		/// <param name="values">Values to indicate sorting properties.
		/// eg, new { Property = "FirName", SortAscending = true }</param>
		/// <returns></returns>
		public IEnumerable<TModel> OrderBy(object values)
		{
			if (values == null) throw new ArgumentNullException("values");

			string propertyName = String.Empty;
			Sort sortDirection = Sort.Ascending;
			PropertyDescriptorCollection props = TypeDescriptor.GetProperties(values);
			foreach (PropertyDescriptor prop in props)
			{
				switch (prop.Name)
				{
					case "Property":
						propertyName = prop.GetValue(values).ToString();
						break;
					case "SortAscending":
						sortDirection = Convert.ToBoolean(prop.GetValue(values)) ? Sort.Ascending : Sort.Descending;
						break;					
				}
			}
			return OrderBy(propertyName, sortDirection);
		}
	}
}