using CAPI.Custom.Data;
using CAPI.Custom.Entities;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Validation;
using System.Linq;

namespace CAPI.Custom.Services
{
    public abstract class EntityReadOnlyService<TContext,TEntity> : IDisposable
        where TContext : DbContext, new()
        where TEntity : class
    {
        protected TContext db = new TContext();

        public virtual IQueryable<TEntity> Entities => db.Set<TEntity>();

        public virtual TEntity Find(object recId) => db.Set<TEntity>().Find(recId);

        public virtual void Dispose()
        {
            db.SaveChanges();
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (db != null)
                {
                    db.Dispose();
                    db = null;
                }
            }
        }
    }

    public abstract class EntityServiceBase<TContext, TEntity> : EntityReadOnlyService<TContext, TEntity>
        where TContext : DbContext, new()
        where TEntity : class
    {
        /// <summary>
        /// Mark entity as Added - Applies on Save()
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Add(TEntity entity)
        {
            db.Set<TEntity>().Add(entity);
        }

        /// <summary>
        /// Mark entity as Deleted - Applies on Save()
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Remove(TEntity entity)
        {
            db.Set<TEntity>().Remove(entity);
        }

        /// <summary>
        /// Mark entity as Edited - Applies on Save()
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Edit(TEntity entity)
        {
            db.Entry(entity).State = EntityState.Modified;
        }

        /// <summary>
        /// Apply changes
        /// </summary>
        /// <returns></returns>
        public virtual int Save()
        {
            try
            {
                return db.SaveChanges();
            }
            catch (DbEntityValidationException dbEx)
            {
                foreach (var validationErrors in dbEx.EntityValidationErrors)
                {
                    foreach (var validationError in validationErrors.ValidationErrors)
                    {
                        //Trace.TraceInformation("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
                        Console.WriteLine("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
                        dbEx.Data.Add(validationError.PropertyName, validationError);
                        System.Diagnostics.Debugger.Break();
                        //return;
                    }
                }

                throw;
            }
        }
    }

    public class EntityService<TEntity> : EntityServiceBase<QuotesContext, TEntity>
        where TEntity : class, IEntity
    {
        public EntityService()
        {
            this.db = QuotesContext.Create();
        }

        /// <summary>
        /// Create entity immediately
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual TEntity Create(TEntity entity) => db.Create(entity);

        /// <summary>
        /// Create multiple entities immediately
        /// </summary>
        /// <param name="entities"></param>
        /// <returns></returns>
        public virtual IEnumerable<TEntity> Create(IEnumerable<TEntity> entities) => db.Create(entities);

        /// <summary>
        /// Update entity immediately
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual TEntity Update(TEntity entity) => db.Update(entity);

        /// <summary>
        /// Update multiple entities immediately
        /// </summary>
        /// <param name="entities"></param>
        /// <returns></returns>
        public virtual IEnumerable<TEntity> Update(IEnumerable<TEntity> entities) => db.Update(entities);

        /// <summary>
        /// Delete entity immediately
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual int Delete(TEntity entity) => db.Delete(entity);

        /// <summary>
        /// Delete multiple entities immediately
        /// </summary>
        /// <param name="entities"></param>
        /// <returns></returns>
        public virtual int Delete(IEnumerable<TEntity> entities) => db.Delete(entities);
    }

    public class SurfaceItemService<TSurfaceItem> : EntityService<TSurfaceItem>
        where TSurfaceItem : class, ISurfaceEntity
    {
        public virtual TSurfaceItem GetByItemId(int itemId) => Entities.FirstOrDefault(p => p.itemID == itemId);

        public virtual IQueryable<TChildItem> GetChildren<TChildItem>(int parentId)
            where TChildItem : class, ISurfaceChildEntity
        {
            return db.Set<TChildItem>().GetByParentId(parentId);
        }
    }

    public class SurfaceChildItemService<TSurfaceChildItem> : SurfaceItemService<TSurfaceChildItem>
        where TSurfaceChildItem : class, ISurfaceChildEntity
    {
        public virtual IQueryable<TSurfaceChildItem> GetByParentId(int parentId) => 
            db.Set<TSurfaceChildItem>().Where(p => p.ParentSurfaceItemId == parentId);

        public virtual TParentSurfaceItem GetParent<TParentSurfaceItem>(TSurfaceChildItem childItem)
            where TParentSurfaceItem : class, ISurfaceEntity
        {
            return db.Set<TParentSurfaceItem>().FirstOrDefault(p => p.itemID == childItem.ParentSurfaceItemId);
        }
    }

    public class ViewService<TView> : EntityReadOnlyService<QuotesContext, TView>
        where TView : class, IViewEntity
    {

    }

    public class SurfaceItemViewService<TView> : ViewService<TView>
        where TView : class, IViewEntity, ISurfaceEntity
    {
        public virtual TView GetByItemId(int itemId) => Entities.FirstOrDefault(p => p.itemID == itemId);
    }

    public class SurfaceChildItemViewService<TView> : SurfaceItemViewService<TView>
        where TView : class, IViewEntity, ISurfaceChildEntity
    {
        public virtual IQueryable<TView> GetByParentId(int parentId) =>
            db.Set<TView>().Where(p => p.ParentSurfaceItemId == parentId);
    }
}