using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using AutoMapper;
using IRaCIS.Core.Domain.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using AutoMapper.QueryableExtensions;
using IRaCIS.Core.Infrastructure;
using IRaCIS.Core.Infrastructure.Extention;

namespace IRaCIS.Core.Infra.EFCore
{
    public class Repository<TEntity> : IRepository<TEntity>
        where TEntity : Entity
    {
        public IMapper _mapper { get; set; }
        public IRaCISDBContext _dbContext { get; set; }

        private DbSet<TEntity> _dbSet => _dbContext.Set<TEntity>();


        public Repository(IRaCISDBContext dbContext, IMapper mapper)
        {
            _dbContext = dbContext;
            _mapper = mapper;
        }

        #region 异步部分


        public async Task<TEntity> InsertOrUpdateAsync<TFrom>(TFrom from, bool autoSave = false, params EntityVerifyExp<TEntity>[] verify)
        {
            var entity = _mapper.Map<TEntity>(from);

            if (entity.Id == Guid.Empty)
            {


                foreach (var verifyItem in verify.Where(t => t.verifyType != VerifyEnum.OnlyUpdate && t.IsVerify))
                {
                    if (await _dbSet.AnyAsync(verifyItem.VerifyExp).ConfigureAwait(false))
                    {
                        throw new BusinessValidationFailedException(verifyItem.VerifyMsg);
                    }
                }

                await _dbSet.AddAsync(entity).ConfigureAwait(false);

                if (autoSave)
                {
                    await SaveChangesAsync();

                }
                return entity;

            }
            else
            {


                foreach (var verifyItem in verify.Where(t => t.verifyType != VerifyEnum.OnlyAdd && t.IsVerify))
                {
                    if (verifyItem.verifyType == VerifyEnum.OnlyUpdate)
                    {
                        if (await _dbSet.AnyAsync(verifyItem.VerifyExp).ConfigureAwait(false))
                        {
                            throw new BusinessValidationFailedException(verifyItem.VerifyMsg);
                        }
                    }
                    else if (verifyItem.verifyType == VerifyEnum.Both)
                    {
                        if (await _dbSet.AnyAsync(verifyItem.VerifyExp.And(t => t.Id != entity.Id)).ConfigureAwait(false))
                        {
                            throw new BusinessValidationFailedException(verifyItem.VerifyMsg);
                        }
                    }
                }

                var dbEntity = await _dbSet.FirstOrDefaultAsync(t => t.Id == entity.Id).ConfigureAwait(false);

                var dbBeforEntity = dbEntity.Clone();

                _mapper.Map(from, dbEntity);

                if (autoSave)
                {
                    await SaveChangesAsync();
                }
                return dbBeforEntity;

            }
        }

        public async Task<bool> SaveChangesAsync(CancellationToken cancellationToken = default)
        {

            return await _dbContext.SaveChangesAsync(cancellationToken) > 0;

        }

        public async ValueTask<TEntity> FindAsync(Guid id, CancellationToken cancellationToken = default)
        {
            return await _dbContext.FindAsync<TEntity>(id);
        }

        //有可能是联合主键，本项目没用到，用Guid
        public async ValueTask<TEntity> FindAsync(object[] keyValues, CancellationToken cancellationToken)
        {
            return await _dbContext.FindAsync<TEntity>(keyValues);
        }

        public async Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> exp = null, bool ignoreQueryFilters = false)
        {

            var query = _dbSet.AsQueryable();

            if (ignoreQueryFilters)
            {
                query = query.IgnoreQueryFilters();
            }
            if (exp == null) 
                return await query.FirstOrDefaultAsync().ConfigureAwait(false);
            return await query.FirstOrDefaultAsync(exp).ConfigureAwait(false);
        }

        public async ValueTask<TEntity> AddAsync(TEntity entity, bool autoSave = false, CancellationToken cancellationToken = default)
        {

            await _dbSet.AddAsync(entity).ConfigureAwait(false);

            if (autoSave)
            {
                await SaveChangesAsync(cancellationToken);
            }

            return entity;
        }

        public async Task<bool> AddRangeAsync(IEnumerable<TEntity> entities, bool autoSave = false, CancellationToken cancellationToken = default)
        {
            await _dbSet.AddRangeAsync(entities).ConfigureAwait(false);

            if (autoSave)
            {
                return await SaveChangesAsync(cancellationToken);
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> UpdateAsync(TEntity entity, bool autoSave = false, CancellationToken cancellationToken = default)
        {
            _dbSet.Update(entity);

            if (autoSave)
            {
                return await SaveChangesAsync(cancellationToken);
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> UpdateManyAsync(IEnumerable<TEntity> entities, bool autoSave = false, CancellationToken cancellationToken = default)
        {
            _dbSet.UpdateRange(entities);

            if (autoSave)
            {
                return await SaveChangesAsync(cancellationToken);
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> DeleteAsync(TEntity entity, bool autoSave = false, CancellationToken cancellationToken = default)
        {
            _dbSet.Remove(entity);

            //var entry = _dbSet.Attach(entity);
            //entry.State = EntityState.Deleted;

            if (autoSave)
            {
                return await SaveChangesAsync(cancellationToken);
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> DeleteManyAsync(IEnumerable<TEntity> entities, bool autoSave = false, CancellationToken cancellationToken = default)
        {
            _dbSet.RemoveRange(entities);

            if (autoSave)
            {
                return await SaveChangesAsync(cancellationToken);
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> AnyAsync(Expression<Func<TEntity, bool>> exp, bool ignoreQueryFilters = false)
        {
            var query = _dbSet.AsQueryable();

            if (ignoreQueryFilters)
            {
                query = query.IgnoreQueryFilters();
            }

            return await query.AsNoTracking().AnyAsync(exp);
        }

        public async Task<int> CountAsync(Expression<Func<TEntity, bool>> whereLambda = null, bool ignoreQueryFilters = false)
        {
            var query = _dbSet.AsQueryable();

            if (ignoreQueryFilters)
            {
                query = query.IgnoreQueryFilters();
            }

            return whereLambda == null ? await query.AsNoTracking().CountAsync() : await query.AsNoTracking().CountAsync(whereLambda);
        }

        // Z.EntityFramework.Plus.EFCore
        public async Task<bool> DeleteFromQueryAsync(Expression<Func<TEntity, bool>> deleteFilter)
        {
            return await _dbSet.Where(deleteFilter).DeleteFromQueryAsync() > 0;
        }

        public async Task<bool> UpdateFromQueryAsync(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TEntity>> updateFactory)
        {
            return await _dbSet.Where(where).UpdateFromQueryAsync(updateFactory) > 0;
        }

        #endregion



        #region 非异步部分

        public TEntity ImageFind(Guid id, Type type)
        {
            //重传的时候  状态为修改    上传的时候状态为添加  内存中有，就不要重复查询数据库了
            var list = _dbContext.ChangeTracker.Entries()
                  .Where(u => (u.State == EntityState.Added || u.State == EntityState.Modified) && (u.Entity.GetType() == type)).Select(t => t.Entity as TEntity);

            var entity = list.FirstOrDefault(t => t.Id == id);

            if (entity == null)
            {
                return _dbSet.FirstOrDefault(t => t.Id == id);
            }
            else
            {
                return entity;
            }

        }

        public IQueryable<TEntity> AsQueryable( bool ignoreQueryFilters = false)
        {
            var query = _dbSet.AsQueryable();

            if (ignoreQueryFilters)
            {
                query = query.IgnoreQueryFilters();
            }

            return query.AsNoTracking();
        }

        public IQueryable<TResult> Select<TResult>(Expression<Func<TEntity, TResult>> selector)
        {
            return _dbSet.AsNoTracking().Select(selector);
        }

        public IQueryable<TEntity> WhereIf(bool condition, Expression<Func<TEntity, bool>> filter)
        {
            return condition ? _dbSet.AsNoTracking().Where(filter) : _dbSet.AsNoTracking();
        }

        public IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> exp = null, bool isTraking = false,bool ignoreQueryFilters = false)
        {
            IQueryable<TEntity> query = _dbSet;

            if (!isTraking)
            {
                query = query.AsNoTracking();
            }

            if (ignoreQueryFilters)
            {
                query = query.IgnoreQueryFilters();
            }

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

        public EntityEntry Entry(TEntity t)
        {
            return _dbContext.Entry(t);
        }

        public EntityEntry<TEntity> Attach(TEntity entity)
        {
            return _dbSet.Attach(entity);
        }

        public void Detached(TEntity t)
        {
            _dbContext.Entry(t).State = EntityState.Detached;
        }


        //  automapper 相关
        public IQueryable<TDestination> ProjectTo<TDestination>(IConfigurationProvider configuration, object parameters, params Expression<Func<TDestination, object>>[] membersToExpand)
        {
            return _dbSet.AsNoTracking().ProjectTo(configuration, parameters, membersToExpand);
        }

        public IQueryable<TDestination> ProjectTo<TDestination>(IConfigurationProvider configuration, params Expression<Func<TDestination, object>>[] membersToExpand)
        {
            return _dbSet.AsNoTracking().ProjectTo(configuration, membersToExpand);
        }

        public IQueryable<TDestination> ProjectTo<TDestination>(IConfigurationProvider configuration, IDictionary<string, object> parameters, params string[] membersToExpand)
        {
            return _dbSet.AsNoTracking().ProjectTo<TDestination>(configuration, parameters, membersToExpand);
        }



        #endregion
    }

}