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

using Microsoft.EntityFrameworkCore;

using System.Linq.Expressions;

using VberZero.AppService.Base;
using VberZero.AppService.Base.Dto;
using VberZero.AppService.Helps.Dto;
using VberZero.AppService.Query.Dto;
using VberZero.AppService.Users.Dto;
using VberZero.BaseSystem;
using VberZero.BaseSystem.Roles;
using VberZero.BaseSystem.Users;
using VberZero.DomainService.AutoCompletes;
using VberZero.Session;
using VberZero.Tools.StringModel;

using static System.String;

namespace VberZero.AppService.Query;

/// <summary>
///     公共查询
/// </summary>
[AbpAuthorize]
[DisableAuditing]
public class VzQueryAppServiceBase : VzAppServiceBase, IVzQueryAppService
{
    #region 仓储

    public VzQueryAppServiceBase(
        IRepository<User, long> userRepository, ICacheManager cacheManager,
        IRepository<SysFunction, int?> funRepository, IRepository<SysHelp> helpRepository,
        IUserNavigationManager userNavigationManager, IRepository<AuditLog, long> logRepository, IRepository<Role, int> roleRepository)
    {
        UserRepository = userRepository;
        FunRepository = funRepository;
        HelpRepository = helpRepository;
        UserNavigationManager = userNavigationManager;
        LogRepository = logRepository;
        RoleRepository = roleRepository;

        AcQuery = NullAutoCompleteQueryManager.Instance;

        CacheManager = cacheManager;
    }

    protected IRepository<User, long> UserRepository { get; }
    protected IRepository<Role, int> RoleRepository { get; }
    protected IRepository<SysFunction, int?> FunRepository { get; }
    protected IRepository<SysHelp> HelpRepository { get; }
    protected IRepository<AuditLog, long> LogRepository { get; }

    protected IUserNavigationManager UserNavigationManager { get; }

    public IAutoCompleteQueryManager AcQuery { get; set; }

    #endregion 仓储

    #region SELECT

    #region SYSTEM

    [DisableAuditing]
    public async Task<string> GetUserSelectStr()
    {
        var list = await UserRepository.GetAllListAsync();
        var str = "<option  value=\"\" selected >请选择用户...</option>";
        foreach (var l in list) str += $"<option  value=\"{l.Id}\"  >{l.Name}</option>";
        return str;
    }

    [DisableAuditing]
    public async Task<string> GetUserTypeSelectStr(int type = 0)
    {
        var str = "<option  value=\"\" selected >请选择用户类型...</option>";
        if (type == 0)
        {
            str += await StatesManager.GetSelectStrAsync("UserRole.UserRoleType");
        }
        else
        {
            var userTypeStr = AbpSession.GetUserType().ToInt() + "";
            var isAdmin = AbpSession.GetUserName() == User.AdminUserName ||
                          AbpSession.GetUserName() == User.SystemUserName;
            str += await StatesManager.GetSelectStrAsync("UserRole.UserRoleType",
                a => isAdmin || Compare(a.CodeValue, userTypeStr, StringComparison.Ordinal) > 0);
        }

        return str;
    }

    [DisableAuditing]
    public async Task<string> GetRoleTypeSelectStr(int type = 0)
    {
        var str = "<option  value=\"\" selected >请选择角色类型...</option>";
        if (type == 0)
        {
            str += await StatesManager.GetSelectStrAsync("UserRole.UserRoleType");
        }
        else
        {
            var userTypeStr = AbpSession.GetUserType().ToInt() + "";
            var isAdmin = AbpSession.GetUserName() == User.AdminUserName ||
                          AbpSession.GetUserName() == User.SystemUserName;
            str += await StatesManager.GetSelectStrAsync("UserRole.UserRoleType",
                a => isAdmin || Compare(a.CodeValue, userTypeStr, StringComparison.Ordinal) > 0);
        }

        return str;
    }

    [DisableAuditing]
    public async Task<string> GetGenderTypeSelectStr()
    {
        var str = "<option  value=\"\" selected >请选择性别...</option>";
        str += await StatesManager.GetSelectStrAsync("Gender.Type");
        return str;
    }

    [DisableAuditing]
    public async Task<string[]> GetGenderTypeArrayStr()
    {
        List<string> strings = new List<string>();
        var list = await StatesManager.GetStateListAsync("Gender.Type");
        foreach (var s in list)
        {
            strings.Add(s.DisplayValue);
            strings.Add(s.CodeValue);
        }
        return strings.ToArray();
    }

    [DisableAuditing]
    public async Task<string> GetAccountTypeSelectStr()
    {
        var str = "<option  value=\"\" selected >请选择账号类型...</option>";
        str += await StatesManager.GetSelectStrAsync("Account.AccountType");
        return str;
    }

    [DisableAuditing]
    public async Task<string> GetActiveStateSelectStr()
    {
        var str = "<option  value=\"\" selected >请选择账号激活状态...</option>";
        str += await StatesManager.GetSelectStrAsync("Active.Status");
        return str;
    }

    [DisableAuditing]
    public async Task<string[]> GetActiveStateArrayStr()
    {
        List<string> strings = new List<string>();
        var list = await StatesManager.GetStateListAsync("Active.Status");
        foreach (var s in list)
        {
            strings.Add(s.DisplayValue);
            strings.Add(s.CodeValue);
        }
        return strings.ToArray();
    }

    [DisableAuditing]
    public async Task<string> GetFunctionTypeSelectStr()
    {
        var str = "<option  value=\"\" selected >请选择菜单类型...</option>";
        str += await StatesManager.GetSelectStrAsync("Function.FunctionType");
        return str;
    }

    [DisableAuditing]
    public async Task<string> GetCalendarNotifyTypeSelectStr()
    {
        var str = "<option  value=\"\" disabled>请选择通知类型...</option>";
        str += await StatesManager.GetSelectStrAsync("Calendar.NotifyType");
        return str;
    }

    [DisableAuditing]
    public async Task<string> GetWorkflowAuditStatusSelectStr()
    {
        var str = "<option  value=\"\" disabled>请选择审核类型...</option>";
        str += await StatesManager.GetSelectStrAsync("WorkflowAudit.Status");
        return str;
    }

    [DisableAuditing]
    public async Task<string> GetWorkflowStatusSelectStr()
    {
        var str = "<option  value=\"\" disabled>请选择类型...</option>";
        str += await StatesManager.GetSelectStrAsync("Workflow.Status");
        return str;
    }

    /// <summary>
    ///     查询是页面的功能菜单 select
    /// </summary>
    /// <returns></returns>
    [DisableAuditing]
    public Task<string> QueryFunctionPageSelectStr()
    {
        return QueryFunctionSelect(VzDefinition.FunctionType.Catalog, VzDefinition.FunctionType.Menu);
    }

    private async Task<string> QueryFunctionSelect(params VzDefinition.FunctionType[] types)
    {
        var list = await FunRepository.GetAllListAsync(a => types.Length == 0 || types.Contains(a.FunctionType));
        var str =
            "<option  value=\"\" selected disabled>请选择功能菜单</option>"; //"<option  value=\"\" selected >请选择类别...</option>";
        //var topParentPerm = list.FirstOrDefault(a => a.ParentNo == null)?.PermissionName ?? "";
        foreach (var l in list)
        {
            if (l.ParentNo == null)
            {
                str += $"<option  value=\"{l.Id}\" >{l.DisplayName}</option>";
                continue;
            }

            if (!await PermissionChecker.IsGrantedAsync(l.PermissionName)) continue;

            str += $"<option parent=\"{l.ParentNo}\" value=\"{l.Id}\">{l.DisplayName}</option>";
        }

        return str;
    }

    [DisableAuditing]
    public async Task<string> GetHelpTypeSelectStr()
    {
        var str = "<option  value=\"\" selected >请选择帮助目录类型...</option>";
        var userTypeStr = AbpSession.GetUserType().ToStr();
        str += await StatesManager.GetSelectStrAsync("SysHelp.HelpType",
            a => Compare(a.CodeValue, userTypeStr, StringComparison.Ordinal) >= 0);
        return str;
    }

    /// <summary>
    /// 日志服务名称
    /// </summary>
    /// <returns></returns>
    [DisableAuditing]
    public string GetLogServiceSelectStr()
    {
        var options = "<option  value=\"\" >请选择日志类型...</option>";

        var list = LogRepository.GetAll().Where(a => a.LogType != 0).GroupBy(a => a.ServiceName).Select(a => a.Key);
        foreach (var l in list)
        {
            options += $"<option value='{l}' >{l}</option>";
        }
        return options;
    }

    /// <summary>
    /// 日志服务方法名称
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public string GetLogMethodSelectStr(QueryMethodName input)
    {
        string options = "<option  value=\"\" >请选择操作类型...</option>";
        var list = LogRepository.GetAll().Where(a =>
            a.LogType != 0 && (string.IsNullOrEmpty(input.ServiceName) || a.ServiceName == input.ServiceName)).GroupBy(a => a.MethodName).Select(a => a.Key);
        foreach (var l in list)
        {
            options += $"<option value='{l}' >{l}</option>";
        }
        return options;
    }

    //[DisableAuditing]
    //public async Task<string> GetSelectTreeStr()
    //{
    //    var list = await Repository.GetAllListAsync();
    //    string str = "";//"<option  value=\"\" selected >请选择类别...</option>";
    //    var topParentNo = list.FirstOrDefault(a => a.ParentNo == null)?.Id ?? "";
    //    foreach (var l in list)
    //    {
    //        if (l.ParentNo == null)
    //        {
    //            str += $"<option value=\"\" selected disabled>请选择类别</option>";
    //            continue;
    //        }
    //        str += $"<option parent=\"{(l.ParentNo == topParentNo ? "" : l.ParentNo)}\" value=\"{l.Id}\">{l.Name}</option>";
    //    }
    //    return str;
    //}

    #endregion SYSTEM

    #endregion SELECT

    #region AutoCompleteQuery

    /// <summary>
    ///     查询自动完成的搜索记录
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<PagedResultDto<AcQueryDto>> AcInfos(PageAcQueryDto input)
    {
        var query = await AcQuery.PageItems(input.CodeKey, input.NameKey, input.Skip, input.Take);
        var list = query.Items.Select(a => new AcQueryDto(a)).ToList();
        return new PagedResultDto<AcQueryDto>(query.TotalCount, list);
    }

    public virtual async Task<AcQueryDto> AcInfo(CreateAcQueryDto input)
    {
        var info = await AcQuery.QueryItem(input.CodeKey, input.ValueKey);

        return new AcQueryDto(info ?? new SysAutoCompleteQuery());
    }

    /// <summary>
    ///     增加自动完成搜索记录
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task AddAcInfo(CreateAcQueryDto input)
    {
        await AcQuery.InsertOrUpdate(input.CodeKey, input.ValueKey, input.NameKey);
    }

    /// <summary>
    ///     查询未绑定的账号
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public virtual async Task<PagedResultDto<AcQueryDto>> UnBindUserAcInfos(UserAcQueryDto input)
    {
        var query = UserRepository.GetAll().Where(a =>
            a.IsActive && a.AccountType == input.AccountType && IsNullOrEmpty(a.AccountNo));
        var totalCount = await query.CountAsync();
        var list = await query.Select(a => new AcQueryDto
        {
            NameKey = a.Name,
            ValueKey = a.UserName
        }).ToListAsync();
        return new PagedResultDto<AcQueryDto>(totalCount, list);
    }

    #endregion AutoCompleteQuery

    #region User

    /// <summary>
    ///     查询用户信息
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisableAuditing]
    public virtual async Task<PagedResultDto<UserDto>> QueryUsers(VzPagedRequestDto input)
    {
        var query = UserRepository.GetAll().Where(a => a.IsActive);
        query = ApplyFilter(query, input);
        var totalCount = await query.CountAsync();
        query = query.OrderBy(a => a.Id);
        query = query.Skip(input.SkipCount).Take(input.MaxResultCount);
        var entities = await query.ToListAsync();
        var dtoList = new PagedResultDto<UserDto>(totalCount, ObjectMapper.Map<List<UserDto>>(entities));
        return dtoList;
    }

    /// <summary>
    ///     查询用户
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public virtual async Task<UserDto> QueryUserDtoById(long id)
    {
        var user = await CacheManager.GetCache<string, User>(VzConsts.CacheSystemUser)
            .GetAsync($"{id}", () => UserRepository.FirstOrDefaultAsync(a => a.Id == id));
        return ObjectMapper.Map<UserDto>(user);
    }

    /// <summary>
    ///     查询用户
    /// </summary>
    /// <param name="userName"></param>
    /// <returns></returns>
    public virtual async Task<UserDto> QueryUserDtoByUserName(string userName)
    {
        var user = await CacheManager.GetCache<string, User>(VzConsts.CacheSystemUser)
            .GetAsync($"{userName}", () => UserRepository.FirstOrDefaultAsync(a => a.UserName == userName));
        return ObjectMapper.Map<UserDto>(user);
    }

    /// <summary>
    /// 为工作流获取审核用户
    /// </summary>
    /// <param name="keyword"></param>
    /// <param name="take"></param>
    /// <returns></returns>
    public virtual async Task<Dictionary<string, string>> GetWfUser(string keyword, int take)
    {
        var query = UserRepository.GetAll().Where(a => a.IsActive && string.IsNullOrEmpty(keyword) || a.UserName.Contains(keyword) || a.Name.Contains(keyword) || a.Surname.Contains(keyword));
        query = query.OrderBy(a => a.CreationTime).Skip(0).Take(take);
        var users = await query.ToListAsync();
        var dic = new Dictionary<string, string>();
        foreach (var user in users)
        {
            dic.Add(user.Id + "", user.Surname);
        }

        return dic;
    }

    /// <summary>
    /// 为工作流获取审核角色
    /// </summary>
    /// <param name="keyword"></param>
    /// <param name="take"></param>
    /// <returns></returns>
    public virtual async Task<Dictionary<string, string>> GetWfRole(string keyword, int take)
    {
        var query = RoleRepository.GetAll().Where(a => a.Name.Contains(keyword) || a.DisplayName.Contains(keyword));
        query = query.OrderBy(a => a.CreationTime).Skip(0).Take(take);
        var roles = await query.ToListAsync();
        var dic = new Dictionary<string, string>();
        foreach (var role in roles)
        {
            dic.Add(role.Name + "", role.DisplayName);
        }

        return dic;
    }

    #endregion User

    #region Help

    /// <summary>
    ///     根据页面权限（permName）查询帮助信息
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public virtual async Task<List<SysHelpDto>> QueryHelpByPerm(string id)
    {
        var helps = await QueryHelps(a => a.Function.PermissionName == id);
        return helps;
    }

    /// <summary>
    ///     查询页面的帮助信息详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public virtual async Task<SysHelpDto> QueryHelpDto(int id)
    {
        return await CacheManager.GetCache<int, SysHelpDto>(VzConsts.CacheSysHelp).GetAsync(id,
            async () =>
            {
                var help = await HelpRepository.FirstOrDefaultAsync(a => a.Id == id);
                return ObjectMapper.Map<SysHelpDto>(help);
            });
    }

    /// <summary>
    ///     按照菜单查询页面帮助信息
    /// </summary>
    /// <returns></returns>
    public virtual async Task<List<MenuHelpDto>> QueryHelpByMenu()
    {
        var helps = await QueryHelps();
        var menu = await UserNavigationManager.GetMenuAsync("MainMenu", AbpSession.ToUserIdentifier());
        var list = new List<MenuHelpDto>();
        foreach (var item in menu.Items) BuildMenuHelps(list, item, helps);

        return list;
    }

    private async Task<List<SysHelpDto>> QueryHelps(Expression<Func<SysHelp, bool>> exp = null)
    {
        var userType = (VzDefinition.HelpType)AbpSession.GetUserType();
        var helps = await HelpRepository.GetAllIncluding(a => a.Function).Where(a => a.HelpType >= userType).WhereIf(exp != null, exp)
            .OrderBy(a => a.Sequence).Select(a => new SysHelpDto
            {
                Id = a.Id,
                HelpType = a.HelpType,
                Title = a.Title,
                KeyWords = a.KeyWords,
                FunctionNo = a.Id,
                FunctionDisplayName = a.Function != null ? a.Function.DisplayName : "",
                PermissionName = a.Function != null ? a.Function.PermissionName : "",
                Sequence = a.Sequence
            }).ToListAsync();
        return helps;
    }

    private void BuildMenuHelps(List<MenuHelpDto> list, UserMenuItem menu, List<SysHelpDto> helps)
    {
        var helpDtos = helps.Where(a => a.PermissionName == menu.Name).OrderBy(a => a.Sequence).ToList();
        if (helpDtos.Any())
            list.Add(new MenuHelpDto
            {
                Index = list.Count + 1,
                MenuName = menu.DisplayName,
                Helps = helpDtos
            });

        foreach (var item in menu.Items) BuildMenuHelps(list, item, helps);
    }

    #endregion Help
}