using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using SqlSugar;
using XF.Domain;
using XF.Domain.Repository;

namespace CallCenter.Repository.SqlSugar
{
    public abstract class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class, IEntity<string>, IHasCreationTime, new()
    {
        protected ISugarUnitOfWork<CallCenterDbContext> Uow { get; }
        protected ISqlSugarClient Db { get; }

        public BaseRepository(ISugarUnitOfWork<CallCenterDbContext> uow)
        {
            Uow = uow;
            Db = uow.Db;
        }

        public async Task<string> AddAsync(TEntity entity, CancellationToken cancellationToken = default)
        {
            var excEntity = await Db.Insertable(entity).ExecuteReturnEntityAsync();
            return excEntity.Id;
        }

        /// <summary>
        /// 批量插入（应用场景：小数据量，超出1万条建议另行实现）
        /// </summary>
        /// <param name="entities"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task AddRangeAsync(List<TEntity> entities, CancellationToken cancellationToken = default)
        {
            await Db.Insertable(entities).ExecuteCommandAsync();
        }

        public async Task RemoveAsync(TEntity entity, bool? soft = false, CancellationToken cancellationToken = default)
        {
            if (soft.HasValue && soft.Value)
            {
                await Db.Deleteable(entity).IsLogic().ExecuteCommandAsync("IsDeleted", true, "DeletionTime");
            }
            else
            {
                await Db.Deleteable(entity).ExecuteCommandAsync();
            }
        }

        public async Task RemoveAsync(string id, bool? soft = false, CancellationToken cancellationToken = default)
        {
            if (soft.HasValue && soft.Value)
            {
                await Db.Deleteable<TEntity>().In(id).IsLogic().ExecuteCommandAsync("IsDeleted", true, "DeletionTime");
            }
            else
            {
                await Db.Deleteable<TEntity>().In(id).ExecuteCommandAsync();
            }
        }

        public async Task RemoveAsync(Expression<Func<TEntity, bool>> predicate, bool? soft, CancellationToken cancellationToken = default)
        {
            if (soft.HasValue && soft.Value)
            {
                await Db.Deleteable<TEntity>().Where(predicate).IsLogic().ExecuteCommandAsync("IsDeleted", true, "DeletionTime");
            }
            else
            {
                await Db.Deleteable<TEntity>().Where(predicate).ExecuteCommandAsync();
            }
        }

        public async Task RemoveRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
        {
            await Db.Deleteable<TEntity>(entities).ExecuteCommandAsync();
        }

        public async Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
        {
            await Db.Updateable(entity)
                .IgnoreColumns(ignoreAllNullColumns: true)
                .IgnoreColumns(d => d.CreationTime)
                .ExecuteCommandAsync();
        }

        public async Task UpdateRangeAsync(List<TEntity> entities, CancellationToken cancellationToken = default)
        {
            await Db.Updateable(entities)
                .IgnoreColumns(d => d.CreationTime)
                .ExecuteCommandAsync();
        }

        public async Task<TEntity?> GetAsync(string id, CancellationToken cancellationToken = default)
        {
            return await Db.Queryable<TEntity>().FirstAsync(d => d.Id == id);
        }

        public async Task<TEntity?> GetAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
        {
            return await Db.Queryable<TEntity>().FirstAsync(predicate);
        }

        public async Task<TEntity?> GetAsync(Expression<Func<TEntity, bool>> predicate,bool isDesc, Expression<Func<TEntity, object>> orderby, CancellationToken cancellationToken = default)
        {
            if (isDesc)
            {
                return await Db.Queryable<TEntity>().OrderBy(orderby, OrderByType.Desc).FirstAsync(predicate);
            }
            else
            {
                return await Db.Queryable<TEntity>().OrderBy(orderby,OrderByType.Asc).FirstAsync(predicate);
            }
        }


        public async Task<List<TEntity>> QueryAsync(Expression<Func<TEntity, bool>>? predicate = null, params (bool isWhere, Expression<Func<TEntity, bool>> expression)[] whereIfs)
        {
            var query = Db.Queryable<TEntity>().Where(predicate ??= d => true);
            if (whereIfs.Any())
            {
                foreach (var whereIf in whereIfs)
                {
                    query = query.WhereIF(whereIf.isWhere, whereIf.expression);
                }
            }

            return await query.ToListAsync();
        }

        public async Task<bool> AnyAsync(CancellationToken cancellationToken = default) =>
            await Db.Queryable<TEntity>().AnyAsync();

        public async Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default) =>
            await Db.Queryable<TEntity>().AnyAsync(predicate);

        public async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default) =>
            await Db.Queryable<TEntity>().CountAsync(predicate);

        /// <summary>
        /// 基础分页
        /// </summary>
        /// <param name="predicate"></param>
        /// <param name="orderByCreator"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public async Task<(int Total, List<TEntity> Items)> QueryPagedAsync(
            Expression<Func<TEntity, bool>> predicate,
            Func<ISugarQueryable<TEntity>, ISugarQueryable<TEntity>> orderByCreator,
            int pageIndex,
            int pageSize,
            params (bool isWhere, Expression<Func<TEntity, bool>> expression)[] whereIfs)
        {
            RefAsync<int> total = 0;
            var query = Db.Queryable<TEntity>().Where(predicate);
            if (whereIfs.Any())
            {
                foreach (var whereIf in whereIfs)
                {
                    query = query.WhereIF(whereIf.isWhere, whereIf.expression);
                }
            }
            var items = await orderByCreator(query).ToPageListAsync(pageIndex, pageSize, total);
            return (total.Value, items);
        }

        public async Task<List<TEntity>> QueryExtAsync(Expression<Func<TEntity, bool>> predicate, Func<ISugarQueryable<TEntity>, ISugarQueryable<TEntity>> includes)
        {
            var query = Db.Queryable<TEntity>().Where(predicate);
            query = includes(query);
            return await query.ToListAsync();
        }

        public async Task<TEntity> GetExtAsync(Expression<Func<TEntity, bool>> predicate, Func<ISugarQueryable<TEntity>, ISugarQueryable<TEntity>> includes)
        {
            var query = Db.Queryable<TEntity>();
            query = includes(query);
            return await query.FirstAsync(predicate);
        }

        public async Task<TEntity> GetExtAsync(string id, Func<ISugarQueryable<TEntity>, ISugarQueryable<TEntity>> includes)
        {
            var query = Db.Queryable<TEntity>();
            query = includes(query);
            return await query.FirstAsync(d => d.Id == id);
        }

        public async Task UpdateAsync(TEntity entity, bool ignoreNullColumns = true, CancellationToken cancellationToken = default)
        {
            await Db.Updateable(entity)
                .IgnoreColumns(ignoreAllNullColumns: ignoreNullColumns)
                .IgnoreColumns(d => d.CreationTime)
                .ExecuteCommandAsync();
        }
    }
}