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

using VberZero.AppService.Base.Dto;
using VberZero.AppService.Base.TreeBase;
using VberZero.AppService.Functions.Dto;
using VberZero.Auditing;
using VberZero.BaseSystem;
using VberZero.Navigation;
using VberZero.Tools.StringModel;

namespace VberZero.AppService.Functions;

[AbpAuthorize, AuditLog("功能菜单管理", "功能菜单")]
public class FunctionAppServiceBase : VzTreeAppServiceBaseBase<SysFunction, FunctionDto, int?, VzPagedRequestDto, FunctionCreateDto, FunctionUpdateDto>, IFunctionAppServiceBase
{
    protected readonly VzNavigationManager NavigationManager;

    public FunctionAppServiceBase(ICacheManager cacheManager, IRepository<SysFunction, int?> repository, VzNavigationManager navigationManager) : base(repository, "FunctionNo")
    {
        NavigationManager = navigationManager;
        CacheManager = cacheManager;
    }

    protected virtual string RefreshPermissionName { get; set; }

    protected override bool KeyIsAuto { get; set; } = false;
    protected override string KeyExistMessage => string.Format(L("KeyExistMessageFormatter"), L("function"));
    protected override string KeyNotExistMessage => string.Format(L("KeyNotExistMessageFormatter"), L("function"));

    #region CURD

    [DisableAuditing]
    public override async Task<PagedResultDto<FunctionDto>> GetAll(VzPagedRequestDto input)
    {
        return await base.GetAll(input);
    }

    protected override IQueryable<T> ApplyFilter<T>(IQueryable<T> query, VzPagedRequestDto input)
    {
        if (query is IQueryable<SysFunction> queryable)
        {
            return (IQueryable<T>)queryable.Where(a => a.FunctionType != 0);
        }

        return query;
    }

    //public override async Task Create(FunctionCreateDto input)
    //{
    //    await base.Create(input);
    //}

    protected override Task<FunctionCreateDto> CheckCreate(FunctionCreateDto input)
    {
        CheckErrors("不支持操作");
        return default;
    }

    public override async Task Update(FunctionUpdateDto input)
    {
        await base.Update(input);
        await CacheManager.GetCache(VzConsts.CacheFunction).RemoveAsync(input.Id + "");
    }

    protected override async Task<SysFunction> CheckUpdate(FunctionUpdateDto input)
    {
        var entity = await GetEntityById(input.Id);
        return entity;
    }

    public override async Task Delete(VzEntityDto<int?> input)
    {
        await base.Delete(input);
        await CacheManager.GetCache(VzConsts.CacheFunction).RemoveAsync(input.Id + "");
    }

    protected override async Task<SysFunction> CheckDelete(VzEntityDto<int?> input)
    {
        var entity = await GetEntityById(input.Id);
        return entity;
    }

    /// <summary>
    /// 强制刷新
    /// </summary>
    /// <returns></returns>
    public async Task Refresh()
    {
        CheckPermission(MoveUpPermissionName);
        await CacheManager.GetCache<string, List<SysFunction>>(VzConsts.CacheFunction).ClearAsync();
        NavigationManager.Initialize();
    }

    #endregion CURD

    protected override IQueryable<T> SelfSorting<T>(IQueryable<T> query, VzPagedRequestDto input)
    {
        if (query is IQueryable<SysFunction> queryable)
            return (IQueryable<T>)queryable.OrderBy(a => a.FunctionType).ThenBy(a => a.Sort);
        return query;
    }

    protected override IQueryable<T> KeyWordFilter<T>(IQueryable<T> query, string keyword)
    {
        if (query is IQueryable<SysFunction> queryable)
            return (IQueryable<T>)queryable.WhereIf(keyword.NotEmpty(), a =>
                a.DisplayName.Contains(keyword));
        return query;
    }

    protected override FunctionDto MapToEntityDto(SysFunction entity)
    {
        var dto = base.MapToEntityDto(entity);
        dto.ParentName = entity.Parent?.DisplayName;
        return dto;
    }
}