using System.Linq.Dynamic.Core;

using Abp.Application.Services;
using Abp.Application.Services.Dto;
using Abp.Linq.Extensions;
using Abp.Runtime.Caching;
using Abp.Runtime.Session;
using Abp.UI;

using Microsoft.AspNetCore.Identity;

using VberZero.AppService.Base.Dto;
using VberZero.Authorization.Users;
using VberZero.BaseSystem.MultiTenancy;
using VberZero.BaseSystem.Users;
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.Lambda;

namespace VberZero.AppService.Base;

public abstract class VzAppServiceBase : ApplicationService
{
    public ICacheManager CacheManager { get; set; }
    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; }
    protected virtual VzTenantManager TenantManager { get; set; }
    protected virtual VzUserManager UserManager { get; set; }

    protected VzAppServiceBase()
    {
        LocalizationSourceName = VzConsts.LocalizationSourceName;
        AttachManager = NullAttachManager.Instance;
        StatesManager = NullSysStatesManager.Instance;
        AppGuidManager = NullAppGuidManager.Instance;
        QueryAcManager = NullAutoCompleteQueryManager.Instance;
        AbpSession = NullVzSession.Instance;
    }

    protected virtual async Task<User> GetCurrentUserAsync()
    {
        var user = await UserManager.FindByIdAsync(AbpSession.GetUserId().ToString());
        if (user == null)
        {
            throw new Exception("There is no current user!");
        }

        return user;
    }

    protected virtual Task<Tenant> GetCurrentTenantAsync()
    {
        return TenantManager.GetByIdAsync(AbpSession.GetTenantId());
    }

    /// <summary>
    /// 过滤查询条件
    /// </summary>
    protected virtual IQueryable<T> ApplyFilter<T>(IQueryable<T> query, IVzPagedRequestDto input)
    {
        if (!(input is { } pagedInput))
        {
            return query;
        }

        if (!string.IsNullOrEmpty(pagedInput.KeyWords))
        {
            query = pagedInput.KeyField.ToLower() == "keyword" ? 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="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 != null && pagedInput.SearchList.Count > 0)
        {
            List<LambdaObject> objList = SelfFilter(pagedInput.SearchList) ?? 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="list"></param>
    /// <returns></returns>
    protected virtual List<LambdaObject> SelfFilter(List<MultiSearchDto> list)
    {
        return null;
    }

    /// <summary>
    /// 排序
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="input">The input.</param>
    protected virtual IQueryable<T> ApplySorting<T>(IQueryable<T> query, IVzPagedRequestDto 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, IVzPagedRequestDto input)
    {
        //Try to sort query if available
        if (input is ISortedResultRequest sortInput)
        {
            return string.IsNullOrWhiteSpace(sortInput.Sorting)
                ? SelfSorting(query, input)
                : query.OrderBy(sortInput.Sorting);
        }

        //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, IVzPagedRequestDto input)
    {
        return query;
    }

    /// <summary>
    /// 分页
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="input">The input.</param>
    protected virtual IQueryable<T> ApplyPaging<T>(IQueryable<T> query, IVzPagedRequestDto 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, IVzPagedRequestDto 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;
    }

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

    /// <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 CheckErrors(IdentityResult identityResult)
    {
        identityResult.CheckErrors(LocalizationManager);
    }
}