using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Core.Metadata.Edm;
using System.Data.Entity.Core.Objects;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace Neo.Afx.ComponentModel
{
    /// <summary>
    /// Ensures that when multiple repositories are used, they share a single database context.
    /// </summary>
    /// <typeparam name="TContext">The type of the database context.</typeparam>
    public abstract class Database<TContext> : IDisposable
        where TContext : DbContext, new()
    {
        /// <summary>
        /// The new record identifier.
        /// </summary>
        public readonly long NewID = -1;

        #region Initialization

        /// <summary>
        /// Initializes a new instance of the <see cref="Database&lt;TContext&gt;"/> class.
        /// </summary>
        protected Database()
            : this(Activator.CreateInstance<TContext>())
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Database&lt;TContext&gt;"/> class.
        /// </summary>
        /// <param name="context">The context to be used.</param>
        protected Database(TContext context)
            : this(context, null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Database&lt;TContext&gt;"/> class.
        /// </summary>
        /// <param name="context">The context to be used.</param>
        /// <param name="commandTimeout">The timeout value, in seconds, for all object context operations.
        /// A <code>null</code> value indicates that the default value of the underlying provider will be used.
        /// A <code>zero</code> value indicates an infinite timeout.</param>
        protected Database(TContext context, int? commandTimeout)
        {
            Context = context;
            ProxyCreationEnabled = false;
            if(commandTimeout.HasValue)
            {
                // Get the ObjectContext related to this DbContext
                var objectContext = (context as IObjectContextAdapter).ObjectContext;
                objectContext.CommandTimeout = commandTimeout.Value;
            }
        }
        #endregion

        #region Context

        /// <summary>
        /// Gets the context for this instance.
        /// </summary>
        public TContext Context
        {
            get;
            private set;
        }

        #endregion

        #region ContextStateManager

        /// <summary>
        /// Gets the object state manager.
        /// </summary>
        /// <value>
        /// The object state manager.
        /// </value>
        public ObjectStateManager ContextStateManager
        {
            get
            {
                return ((IObjectContextAdapter)Context).ObjectContext.ObjectStateManager;
            }
        }

        #endregion

        #region ProxyCreationEnabled

        /// <summary>
        /// Gets or sets a value indicating whether proxy creation is enabled. 
        /// <remarks>If <code>false</code>, this will turn OFF lazy loading on all entities but will allow for json serialization!!
        /// <p><em>Note:</em> When creating instances of POCO entity types, the Entity Framework creates 
        /// instances of a dynamically generated derived type that acts as a proxy for 
        /// the entity which can create complications when serializing proxy instances 
        /// http://blogs.msdn.com/b/adonet/archive/2011/02/02/using-dbcontext-in-ef-feature-ctp5-part-8-working-with-proxies.aspx
        /// </p>
        /// </remarks>
        /// </summary>
        /// <value>
        /// 	<code>true</code> if proxy creation is enabled; <code>false</code> otherwise. Default is <code>false</code>.
        /// </value>
        public bool ProxyCreationEnabled
        {
            get
            {
                return Context.Configuration.ProxyCreationEnabled;
            }
            set
            {
                Context.Configuration.ProxyCreationEnabled = value;
            }
        }

        #endregion

        #region Save

        /// <summary>
        /// Saves all changes made to the <see cref="Context"/>.
        /// </summary>
        public void Save()
        {
            try
            {
                Context.SaveChanges();
            }
            catch(Exception ex)
            {
                // Log it
                Trace.WriteLine(string.Format("{0:yyyy-MM-dd HH:mm:ss} DATABASE ERROR --> {1}", DateTime.Now, ex.ToStringComplete()));

                // Re-throw preserving stack trace
                throw;
            }
        }

        public void Save<TEntity>(TEntity entity)
            where TEntity : class
        {
            var ctxSet = GetDbSet<TEntity>();
            var fromEntityCtx = Context.Entry(entity);
            var keyMemebers = GetKeyMembers(entity);

            var ctxEntity = Context.Entry((GetByID<TEntity>(fromEntityCtx.Property(keyMemebers[0]).CurrentValue) ?? ctxSet.Add(ctxSet.Create())));
            ctxEntity.CurrentValues.SetValues(entity);

            Context.SaveChanges();
        }

        #endregion

        #region SaveEntity

        /// <summary>
        /// Saves all changes made to the current entity excluding related tables.
        /// </summary>
        public void SaveEntity(dynamic value, dynamic primaryId)
        {
            var entityType = value.GetType();
            var entityState = System.Data.Entity.EntityState.Modified;

            DbEntityEntry valEntity = Context.Entry(value);
            if(valEntity == null)
            {
                throw new Exception("Error occured while accessing current entry.");
            }

            try
            {
                object dbEntity = Context.Set(entityType).Find(primaryId);
                if(dbEntity == null)
                {
                    entityState = EntityState.Added;

                    dbEntity = Context.Set(entityType).Create();
                    Context.Set(entityType).Add(dbEntity);
                }

                var entry = Context.Entry(dbEntity);
                foreach(var propName in entry.CurrentValues.PropertyNames)
                {
                    entry.Property(propName).CurrentValue = valEntity.Property(propName).CurrentValue;
                }

                entry.State = entityState;
                Context.SaveChanges();
            }
            catch(Exception ex)
            {
                // Log it
                Trace.WriteLine(string.Format("{0:yyyy-MM-dd HH:mm:ss} DATABASE ENTITY ERROR --> {1}", DateTime.Now, (ex.Message.ToLower().Contains("inner exception") ? ex.InnerException.Message : ex.Message)));

                // Re-throw preserving stack trace
                throw;
            }
        }

        #endregion

        #region GetByID<TEntity>

        /// <summary>
        /// Gets the entity with the given ID.
        /// </summary>
        /// <typeparam name="TEntity">The type of entity to be returned.</typeparam>
        /// <param name="id">The id of the entity.</param>
        /// <returns>The entity with the given ID.</returns>
        public TEntity GetByID<TEntity>(object id)
            where TEntity : class
        {
            return GetDbSet<TEntity>().Find(id);
        }

        #endregion

        #region GetKeyMembers<TEntity>

        /// <summary>
        /// Gets the key members.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity.</typeparam>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public string[] GetKeyMembers<TEntity>(TEntity entity)
            where TEntity : class
        {
            var entityName = entity.GetType().Name;
            var items = ContextStateManager.MetadataWorkspace.GetItems<EntityType>(DataSpace.CSpace);
            if(items != null && items.Count > 0)
            {
                return items.Where(e => e.FullName.Equals("Model." + entityName)).SelectMany(e => e.KeyMembers).Select(e => e.Name).ToArray();
            }

            return null;
        }

        #endregion

        #region Get<TEntity>

        /// <summary>
        /// Gets a list of entities that match the given filter.
        /// </summary>
        /// <typeparam name="TEntity">The type of entity to be returned.</typeparam>
        /// <param name="filter">The filter to be used.</param>
        /// <param name="orderBy">The order to be used.</param>
        /// <param name="includeProperties">The properties to be included.</param>
        /// <returns>A list of entities that match the given filter.</returns>
        public IEnumerable<TEntity> Get<TEntity>(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "")
             where TEntity : class
        {
            IQueryable<TEntity> query = GetDbSet<TEntity>();

            if(filter != null)
            {
                query = query.Where(filter);
            }

            query = includeProperties.Split(new[]
            {
                ','
            }, StringSplitOptions.RemoveEmptyEntries).Aggregate(query, (current, includeProperty) => current.Include(includeProperty));

            return orderBy != null ? orderBy(query).ToList() : query.ToList();
        }

        #endregion

        #region Insert<TEntity>

        /// <summary>
        /// Inserts the specified entity.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity.</typeparam>
        /// <param name="entity">The entity to be inserted.</param>
        public void Insert<TEntity>(TEntity entity) where TEntity : class
        {
            ChangeToUpperCase<TEntity>(entity);
            GetDbSet<TEntity>().Add(entity);
        }

        /// <summary>
        /// Inserts the specified entity.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity.</typeparam>
        /// <param name="entity">The entity to be inserted.</param>
        /// <param name="changeToUppercase">Indicates if string text should be converted to uppercase.</param>
        public void Insert<TEntity>(TEntity entity, bool changeToUppercase) where TEntity : class
        {
            if (changeToUppercase)
            {
                ChangeToUpperCase<TEntity>(entity);
            }
            
            GetDbSet<TEntity>().Add(entity);
        }

        #endregion

        #region Update<TEntity>

        /// <summary>
        /// Updates the specified entity.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity.</typeparam>
        /// <param name="entityToUpdate">The entity to be updated.</param>
        public void Update<TEntity>(TEntity entityToUpdate) where TEntity : class
        {
            ChangeToUpperCase<TEntity>(entityToUpdate);
            GetDbSet<TEntity>().Attach(entityToUpdate);
            Context.Entry(entityToUpdate).State = System.Data.Entity.EntityState.Modified;
        }

        /// <summary>
        /// Updates the specified entity.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity.</typeparam>
        /// <param name="entityToUpdate">The entity to be updated.</param>
        /// <param name="changeToUppercase">Indicates if string text should be converted to uppercase.</param>
        public void Update<TEntity>(TEntity entityToUpdate, bool changeToUppercase) where TEntity : class
        {
            if (changeToUppercase)
            {
                ChangeToUpperCase<TEntity>(entityToUpdate);
            }
            
            GetDbSet<TEntity>().Attach(entityToUpdate);
            Context.Entry(entityToUpdate).State = System.Data.Entity.EntityState.Modified;
        }

        #endregion

        #region Attach<TEntity>

        /// <summary>
        /// Attaches the specified entity.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity.</typeparam>
        /// <param name="entity">The entity to be attached.</param>
        public void Attach<TEntity>(TEntity entity) where TEntity : class
        {
            if(Context.Entry(entity).State == EntityState.Detached)
            {
                GetDbSet<TEntity>().Attach(entity);
            }
        }

        #endregion

        #region GetDbSet<TEntity>

        DbSet<TEntity> GetDbSet<TEntity>()
            where TEntity : class
        {
            return Context.Set<TEntity>();
        }

        #endregion

        #region IDisposable Members

        private bool _disposed;

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing">
        /// <code>true</code> to release both managed and unmanaged resources; 
        /// <code>false</code> to release only unmanaged resources.
        /// </param>
        protected virtual void Dispose(bool disposing)
        {
            if(!_disposed)
            {
                if(disposing)
                {
                    Context.Dispose();
                }
            }
            _disposed = true;
        }

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

        /// <summary>
        /// Releases unmanaged resources and performs other cleanup operations before the
        /// <see cref="Database&lt;TContext&gt;"/> is reclaimed by garbage collection.
        /// </summary>
        ~Database()
        {
            Dispose(false);
        }

        #endregion

        #region ChangeToUpperCase
        /// <summary>
        /// Changes all the string variables to uppercase
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entityObject"></param>
        public void ChangeToUpperCase<T>(T entityObject)
        {
            var type = entityObject.GetType().ToString();            
            PropertyInfo[] properties = typeof(T).GetProperties();
            List<string> changes = new List<string>();
                      
            foreach (PropertyInfo pi in properties)
            {
                object value = typeof(T).GetProperty(pi.Name).GetValue(entityObject, null);
                
                if (pi.PropertyType == typeof(string) && value != null)
                {
                    var newValue = Convert.ToString(value).ToUpper();
                    pi.SetValue(entityObject,  newValue, null);                    
                }
            }
        }
        #endregion

    }
}