using Abp.Application.Services;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Entities;
using Abp.Domain.Repositories;
using Abp.Extensions;
using Abp.Linq;
using Abp.Linq.Extensions;
using Abp.Runtime.Caching;
using Abp.UI;

using Microsoft.AspNetCore.Identity;

using System.Data.Common;
using System.Linq.Dynamic.Core;
using System.Linq.Expressions;

using VberZero.AppService.Base.Dto;
using VberZero.DomainService.AppGuids;
using VberZero.DomainService.Attaches;
using VberZero.DomainService.AutoCompletes;
using VberZero.DomainService.States;
using VberZero.IdentityFramework;
using VberZero.Session;
using VberZero.Tools;
using VberZero.Tools.Lambda;

namespace VberZero.AppService.Base;

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput, TDeleteInput>
    : ApplicationService,
        IVzCrudAppService<TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput, TDeleteInput>
    where TEntity : class, IEntity<TPrimaryKey>
    where TEntityDto : IVzEntityDto<TPrimaryKey>
    where TUpdateInput : IVzEntityDto<TPrimaryKey>
    where TGetInput : IVzEntityDto<TPrimaryKey>
    where TDeleteInput : IVzEntityDto<TPrimaryKey>
{
    protected readonly IRepository<TEntity, TPrimaryKey> Repository;

    protected VzCrudAppServiceBase(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null)

    {
        KeyFiledName = keyFiledName;
        AsyncQueryableExecuter = NullAsyncQueryableExecuter.Instance;
        LocalizationSourceName = VzConsts.LocalizationSourceName;
        Repository = repository;
        AttachManager = NullAttachManager.Instance;
        StatesManager = NullSysStatesManager.Instance;
        AppGuidManager = NullAppGuidManager.Instance;
        QueryAcManager = NullAutoCompleteQueryManager.Instance;
        AbpSession = NullVzSession.Instance;
    }

    #region 字段、属性

    public new IVzSession AbpSession { get; set; }
    public IAttachManager AttachManager { get; set; }
    public ISysStatesManager StatesManager { get; set; }
    public IAppGuidManager AppGuidManager { get; set; }
    public IAutoCompleteQueryManager QueryAcManager { get; set; }

    public ICacheManager CacheManager { get; set; }

    public IAsyncQueryableExecuter AsyncQueryableExecuter { get; set; }

    /// <summary>
    /// 自定义唯一字段名称（主键）
    /// </summary>
    protected string KeyFiledName { get; set; }

    /// <summary>
    /// 是否自动生成自定义字段（GUID）
    /// </summary>
    protected virtual bool KeyIsAuto { get; set; } = true;

    /// <summary>
    /// 自定义唯一字段存在提示信息
    /// </summary>
    protected virtual string KeyExistMessage { get; set; }

    protected virtual string ExistMessage => string.IsNullOrEmpty(KeyExistMessage) ? L("KeyExistMessage") : KeyExistMessage;

    /// <summary>
    /// 自定义唯一字段不存在提示信息
    /// </summary>
    protected virtual string KeyNotExistMessage { get; set; }

    protected virtual string NotExistMessage => string.IsNullOrEmpty(KeyNotExistMessage) ? L("KeyNotExistMessage") : KeyNotExistMessage;

    protected virtual string GetPermissionName { get; set; }
    protected virtual string GetAllPermissionName { get; set; }
    protected virtual string CreatePermissionName { get; set; }
    protected virtual string UpdatePermissionName { get; set; }
    protected virtual string DeletePermissionName { get; set; }

    #endregion 字段、属性

    #region CURD

    #region Query

    #region GetEntity/Dto

    /// <summary>
    ///  查询实体Dto
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<TEntityDto> GetDto(TGetInput input)
    {
        var entity = await GetEntity(input);
        return MapToEntityDto(entity);
    }

    /// <summary>
    ///  查询实体Dto
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<TEntityDto> GetDtoById(TPrimaryKey id)
    {
        var entity = await GetEntityById(id);
        return MapToEntityDto(entity);
    }

    /// <summary>
    /// 查询实体Dto（需指明自定义字段）
    /// </summary>
    /// <param name="no"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<TEntityDto> GetDtoByNo(string no)
    {
        var entity = await GetEntityByNo(no);
        return MapToEntityDto(entity);
    }

    /// <summary>
    /// 查询实体
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<TEntity> GetEntity(TGetInput input)
    {
        var entity = await GetEntityById(input.Id);
        return entity;
    }

    /// <summary>
    /// 查询实体
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<TEntity> GetEntityById(TPrimaryKey id)
    {
        var exp = LambdaHelper.CreatePrimaryKeyExp<TEntity, TPrimaryKey>(id);
        if (exp == null)
        {
            CheckErrors(string.Format(L("NoEntity"), id));
        }
        return await Repository.FirstOrDefaultAsync(exp);
    }

    /// <summary>
    /// 查询实体（需指明自定义字段）
    /// </summary>
    /// <param name="no"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<TEntity> GetEntityByNo(string no)
    {
        //CheckGetPermission();
        if (string.IsNullOrEmpty(KeyFiledName))
        {
            ThrowError("NoKeyFieldName");
        }
        //LambdaObject obj = new LambdaObject()
        //{
        //    FieldType = LambdaFieldType.S,
        //    FieldName = KeyFiledName,
        //    FieldValue = no,
        //    ExpType = LambdaExpType.Equal
        //};
        //var exp = obj.GetExp<TEntity>();
        var exp = LambdaHelper.CreateFieldExp<TEntity>(KeyFiledName, no);
        return exp == null ? null : await Repository.FirstOrDefaultAsync(exp);
    }

    #endregion GetEntity/Dto

    /// <summary>
    /// 分页查询
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<PagedResultDto<TEntityDto>> GetAll(TGetAllInput input)
    {
        CheckGetAllPermission();
        var query = CreateFilteredQuery(input);
        var totalCount = await AsyncQueryableExecuter.CountAsync(query);
        query = ApplySorting(query, input);
        query = ApplyPaging(query, input);
        var entities = await AsyncQueryableExecuter.ToListAsync(query);

        return new PagedResultDto<TEntityDto>(totalCount, entities.Select(MapToEntityDto).ToList());
    }

    /// <summary>
    /// 排序
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="input">The input.</param>
    protected virtual IQueryable<T> ApplySorting<T>(IQueryable<T> query, TGetAllInput input)
    {
        return _ApplySorting(query, input);
    }

    /// <summary>
    /// 排序
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="input">The input.</param>
    protected IQueryable<T> _ApplySorting<T>(IQueryable<T> query, TGetAllInput input)
    {
        //Try to sort query if available
        if (input is ISortedResultRequest sortInput)
        {
            return sortInput.Sorting.IsNullOrWhiteSpace()
                ? SelfSorting(query, input)
                : query.OrderBy(sortInput.Sorting);
        }

        if (input is ILimitedResultRequest)
        {
            return query.OrderBy("Id DESC");
        }

        //No sorting
        return query;
    }

    /// <summary>
    /// 默认自定义排序
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="query"></param>
    /// <param name="input"></param>
    /// <returns></returns>
    protected virtual IQueryable<T> SelfSorting<T>(IQueryable<T> query, TGetAllInput input)
    {
        return query is IQueryable<TEntity> queryable
            ? (IQueryable<T>)queryable.OrderByDescending(a => a.Id)
            : query;
    }

    /// <summary>
    /// 分页
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="input">The input.</param>
    protected virtual IQueryable<T> ApplyPaging<T>(IQueryable<T> query, TGetAllInput input)
    {
        return _ApplyPaging(query, input);
    }

    /// <summary>
    /// 分页
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="input">The input.</param>
    protected IQueryable<T> _ApplyPaging<T>(IQueryable<T> query, TGetAllInput input)
    {
        //Try to use paging if available
        if (input is IPagedResultRequest pagedInput)
        {
            return query.PageBy(pagedInput);
        }

        //Try to limit query result if available
        if (input is ILimitedResultRequest limitedInput)
        {
            return query.Take(limitedInput.MaxResultCount);
        }

        //No paging
        return query;
    }

    /// <summary>
    /// 根据给定的<see cref="TGetAllInput"/> 创建 <see cref="IQueryable{TEntity}"/>过滤查询.
    /// </summary>
    /// <param name="input"></param>
    /// <param name="propertySelectors">Including</param>
    protected virtual IQueryable<TEntity> CreateFilteredQuery(TGetAllInput input, params Expression<Func<TEntity, object>>[] propertySelectors)
    {
        var query = propertySelectors?.Length > 0 ? Repository.GetAllIncluding(propertySelectors) : Repository.GetAll();
        query = ApplyFilter(query, input);
        return query;
    }

    /// <summary>
    /// 过滤查询条件
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="query"></param>
    /// <param name="input"></param>
    /// <returns></returns>
    protected virtual IQueryable<T> ApplyFilter<T>(IQueryable<T> query, TGetAllInput input)
    {
        var pagedInput = input as IVzPagedRequestDto;
        if (pagedInput == null)
        {
            return query;
        }

        if (!string.IsNullOrEmpty(pagedInput.KeyWords))
        {
            query = pagedInput.KeyField.IsNullOrEmpty() ? KeyWordFilter(query, pagedInput.KeyWords) : KeyWordFilter(query, pagedInput);
        }
        query = SearchListFilter(query, pagedInput);
        return query;
    }

    /// <summary>
    /// 过滤查询条件
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="query"></param>
    /// <param name="input"></param>
    /// <param name="whereExpressions">附带条件</param>
    /// <returns></returns>
    protected virtual IQueryable<T> ApplyFilter<T>(IQueryable<T> query, TGetAllInput input, params Expression<Func<TEntity, bool>>[] whereExpressions)
    {
        if (whereExpressions != null)
        {
            foreach (var exp in whereExpressions)
            {
                query = query.Where(exp);
            }
        }
        query = ApplyFilter(query, input);
        return query;
    }

    /// <summary>
    /// 关键字查询
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="query"></param>
    /// <param name="pagedInput"></param>
    /// <returns></returns>
    protected virtual IQueryable<T> KeyWordFilter<T>(IQueryable<T> query, string pagedInput)
    {
        return query;
    }

    /// <summary>
    /// 关键字查询
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="query"></param>
    /// <param name="pagedInput"></param>
    /// <returns></returns>
    protected virtual IQueryable<T> KeyWordFilter<T>(IQueryable<T> query, IVzPagedRequestDto pagedInput)
    {
        if (!string.IsNullOrEmpty(pagedInput.KeyWords) && !string.IsNullOrEmpty(pagedInput.KeyField) && pagedInput.KeyField.ToLower() != "keyword")
        {
            object keyWords = pagedInput.KeyWords;
            LambdaObject obj = new LambdaObject()
            {
                FieldType = (LambdaFieldType)pagedInput.FieldType,
                FieldName = pagedInput.KeyField,
                FieldValue = keyWords,
                ExpType = (LambdaExpType)pagedInput.ExpType
            };
            var exp = obj.GetExp<T>();
            query = exp != null ? query.Where(exp) : query;
        }
        return query;
    }

    /// <summary>
    /// 多个条件查询
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="query"></param>
    /// <param name="pagedInput"></param>
    /// <returns></returns>
    protected IQueryable<T> SearchListFilter<T>(IQueryable<T> query, IVzPagedRequestDto pagedInput)
    {
        if (pagedInput.SearchList is { Count: > 0 })
        {
            query = SelfFilter(query, pagedInput.SearchList);
            var objList = new List<LambdaObject>();
            foreach (var o in pagedInput.SearchList)
            {
                if (o.HasUse || string.IsNullOrEmpty(o.KeyWords))
                    continue;
                object keyWords = o.KeyWords;
                objList.Add(new LambdaObject
                {
                    FieldType = (LambdaFieldType)o.FieldType,
                    FieldName = o.KeyField,
                    FieldValue = keyWords,
                    ExpType = (LambdaExpType)o.ExpType
                });
            }
            var exp = objList.GetExp<T>();
            query = exp != null ? query.Where(exp) : query;
        }
        return query;
    }

    /// <summary>
    /// 特殊条件时，自定义查询 （使用完该字段查询条件时，应该从list里清除）
    /// </summary>
    /// <param name="query"></param>
    /// <param name="list"></param>
    /// <returns></returns>
    protected virtual IQueryable<T> SelfFilter<T>(IQueryable<T> query, List<MultiSearchDto> list)
    {
        return query;
    }

    #endregion Query

    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public virtual async Task Create(TCreateInput input)
    {
        CheckCreatePermission();
        await CreateEntity(input);
    }

    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="input"></param>
    /// <param name="isCheck"></param>
    /// <returns></returns>
    protected async Task<TEntityDto> CreateEntity(TCreateInput input, bool isCheck = true)
    {
        if (!KeyFiledName.IsNullOrEmpty())
        {
            var fieldValue = input.GetFiledValue<string>(KeyFiledName);
            if (KeyIsAuto && fieldValue.IsNullOrEmpty())
            {
                input.SetFiledValue(KeyFiledName, Guid.NewGuid().ToString("N"));
            }
            else
            {
                if (isCheck)
                {
                    var exp = LambdaHelper.CreateFieldExp<TEntity>(KeyFiledName, fieldValue);
                    if (exp != null && await Repository.FirstOrDefaultAsync(exp) != null)
                    {
                        CheckErrors(ExistMessage);
                    }
                }
            }
        }
        var entity = MapToEntity(input);
        await Repository.InsertAsync(entity);
        await CurrentUnitOfWork.SaveChangesAsync();

        return MapToEntityDto(entity);
    }

    /// <summary>
    /// 修改
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public virtual async Task Update(TUpdateInput input)
    {
        CheckUpdatePermission();
        await UpdateEntity(input);
    }

    /// <summary>
    /// 修改
    /// </summary>
    /// <param name="input"></param>
    /// <param name="entity"></param>
    /// <returns></returns>
    protected async Task<TEntityDto> UpdateEntity(TUpdateInput input, TEntity entity = null)
    {
        entity = entity ?? await GetEntityById(input.Id);
        if (entity == null)
        {
            CheckErrors(NotExistMessage);
        }
        MapToEntity(input, entity);
        await CurrentUnitOfWork.SaveChangesAsync();

        return MapToEntityDto(entity);
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public virtual Task Delete(TDeleteInput input)
    {
        CheckDeletePermission();
        return DeleteEntity(input);
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="input"></param>
    /// <param name="isCheckNull"></param>
    /// <returns></returns>
    protected async Task DeleteEntity(TDeleteInput input, bool isCheckNull = true)
    {
        if (isCheckNull && !string.IsNullOrEmpty(KeyFiledName))
        {
            LambdaObject obj = new LambdaObject()
            {
                FieldType = LambdaFieldType.S,
                FieldName = KeyFiledName,
                FieldValue = input.GetFiledValue<string>(KeyFiledName),
                ExpType = LambdaExpType.Equal
            };
            var exp = obj.GetExp<TEntity>();
            if (exp != null && await Repository.FirstOrDefaultAsync(exp) == null)
            {
                CheckErrors(NotExistMessage);
            }
        }

        try
        {
            await Repository.DeleteAsync(input.Id);
            await CurrentUnitOfWork.SaveChangesAsync();
        }
        catch (DbException)
        {
            ThrowError("CanNotCascadeDeleteMessage");
        }
        catch (Exception e)
        {
            CheckErrors(e.Message);
        }
    }

    #endregion CURD

    #region MAP

    protected virtual TEntityDto MapToEntityDto(TEntity entity)
    {
        return ObjectMapper.Map<TEntityDto>(entity);
    }

    protected virtual TEntity MapToEntity(TCreateInput createInput)
    {
        return ObjectMapper.Map<TEntity>(createInput);
    }

    protected virtual void MapToEntity(TUpdateInput updateInput, TEntity entity)
    {
        ObjectMapper.Map(updateInput, entity);
    }

    protected virtual TOut VzMap<TOut>(object obj)
    {
        return ObjectMapper.Map<TOut>(obj);
    }

    protected virtual TOut VzMap<TOut, TIn>(TIn obj)
    {
        return ObjectMapper.Map<TOut>(obj);
    }

    #endregion MAP

    #region CHECK

    protected virtual int CheckGuid(int? guid)
    {
        if (guid == null || guid == 0)
        {
            ThrowError("GetGuidNoError");
            return 0;
        }
        return (int)guid;
    }

    protected virtual void CheckErrors(string error)
    {
        throw new UserFriendlyException(error);
    }

    protected virtual void CheckErrors(IdentityResult identityResult)
    {
        identityResult.CheckErrors(LocalizationManager);
    }

    /// <summary>
    /// 抛出错误
    /// </summary>
    /// <param name="err"></param>
    /// <param name="isLocalization">是否要本地化</param>
    protected virtual void ThrowError(string err, bool isLocalization = true)
    {
        CheckErrors(isLocalization ? L(err) : err);
    }

    protected virtual void CheckPermission(string permissionName)
    {
        if (!string.IsNullOrEmpty(permissionName))
        {
            PermissionChecker.Authorize(permissionName);
        }
    }

    protected virtual void CheckGetPermission()
    {
        CheckPermission(GetPermissionName);
    }

    protected virtual void CheckGetAllPermission()
    {
        CheckPermission(GetAllPermissionName);
    }

    protected virtual void CheckCreatePermission()
    {
        CheckPermission(CreatePermissionName);
    }

    protected virtual void CheckUpdatePermission()
    {
        CheckPermission(UpdatePermissionName);
    }

    protected virtual void CheckDeletePermission()
    {
        CheckPermission(DeletePermissionName);
    }

    #endregion CHECK
}

#region AppServiceBase

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto>
    : VzCrudAppServiceBase<TEntity, TEntityDto, int>
    where TEntity : class, IEntity<int>
    where TEntityDto : IVzEntityDto<int>
{
    protected VzCrudAppServiceBase(IRepository<TEntity, int> repository, string keyFiledName = null)
        : base(repository)
    {
        KeyFiledName = keyFiledName;
    }
}

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey>
    : VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, PagedAndSortedResultRequestDto>
    where TEntity : class, IEntity<TPrimaryKey>
    where TEntityDto : IVzEntityDto<TPrimaryKey>
{
    protected VzCrudAppServiceBase(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null)
        : base(repository)
    {
        KeyFiledName = keyFiledName;
    }
}

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput>
    : VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TEntityDto, TEntityDto>
    where TEntity : class, IEntity<TPrimaryKey>
    where TEntityDto : IVzEntityDto<TPrimaryKey>
{
    protected VzCrudAppServiceBase(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null)
        : base(repository)
    {
        KeyFiledName = keyFiledName;
    }
}

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput>
    : VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TCreateInput>
    where TGetAllInput : IPagedAndSortedResultRequest
    where TEntity : class, IEntity<TPrimaryKey>
    where TEntityDto : IVzEntityDto<TPrimaryKey>
    where TCreateInput : IVzEntityDto<TPrimaryKey>
{
    protected VzCrudAppServiceBase(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null)
        : base(repository)
    {
        KeyFiledName = keyFiledName;
    }
}

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput>
    : VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, VzEntityDto<TPrimaryKey>>
    where TEntity : class, IEntity<TPrimaryKey>
    where TEntityDto : IVzEntityDto<TPrimaryKey>
    where TUpdateInput : IVzEntityDto<TPrimaryKey>
{
    protected VzCrudAppServiceBase(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null)
        : base(repository)
    {
        KeyFiledName = keyFiledName;
    }
}

public abstract class VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput>
    : VzCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput, VzEntityDto<TPrimaryKey>>
    where TEntity : class, IEntity<TPrimaryKey>
    where TEntityDto : IVzEntityDto<TPrimaryKey>
    where TUpdateInput : IVzEntityDto<TPrimaryKey>
    where TGetInput : IVzEntityDto<TPrimaryKey>
{
    protected VzCrudAppServiceBase(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null)
        : base(repository)
    {
        KeyFiledName = keyFiledName;
    }
}

#endregion AppServiceBase