using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DocumentFormat.OpenXml.Office2010.Excel;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;
using Volo.Abp.PermissionManagement;
using Volo.Abp.Uow;
using Volo.Abp.Users;
using Win_in.Sfs.Auth.Application.Contracts;
using Win_in.Sfs.Auth.Domain;
using Win_in.Sfs.Shared.Domain.Shared;

namespace Win_in.Sfs.Auth.Application;

[AllowAnonymous]
[Route($"{AuthConsts.RootPath}user-menu")]
public class UserMenuAppService :
    SfsAuthCrudAppServiceBase<UserMenu, UserMenuDto, SfsAuthRequestInputBase, UserMenuCreateInput>,
    IUserMenuAppService
{

    const EnumPortal PDA_PORTAL = EnumPortal.Pda;
    const EnumPortal WEB_PORTAL = EnumPortal.Web;

    private readonly IMenuRepository _menuRepository;
    private readonly IPermissionAppService _permissionAppService;
    private readonly IIdentityUserAppService _identityUserAppService;
    private readonly IIdentityUserRepository _identityUserRepository;
    public UserMenuAppService(
        IUserMenuRepository repository, IMenuRepository menuRepository
        , IPermissionAppService permissionAppService
        , IIdentityUserAppService identityUserAppService
        , IIdentityUserRepository identityUserRepository) : base(repository)
    {
        base.CreatePolicyName = UserMenuPermissions.Create;
        base.UpdatePolicyName = UserMenuPermissions.Update;
        base.DeletePolicyName = UserMenuPermissions.Delete;
        _menuRepository = menuRepository;
        _permissionAppService = permissionAppService;
        _identityUserAppService = identityUserAppService;
        _identityUserRepository = identityUserRepository;
    }

    /// <summary>
    /// 按用户ID获取PDA菜单信息
    /// </summary>
    /// <param name="userId"></param>
    /// <returns></returns>
    [HttpGet("pda-menu/{userId}")]
    [AllowAnonymous]
    [UnitOfWork]
    public virtual async Task<List<MenuDto>> GetPdaMenusOfUserAsync(Guid? userId)
    {
        var userMenus = await _repository
            .GetListAsync(p => p.UserId == userId && p.Portal == EnumPortal.Pda).ConfigureAwait(false);

        var menuCodes = userMenus.Select(p => p.MenuCode).Distinct().ToList();

        var menus = await GetListByPortalAndCodesAsync(PDA_PORTAL, menuCodes).ConfigureAwait(false);

        return menus;

    }
    /// <summary>
    /// 按用户ID获取web菜单信息
    /// </summary>
    /// <param name="userId"></param>
    /// <returns></returns>
    [HttpGet("web-menu/{userId}")]
    [AllowAnonymous]
    [UnitOfWork]
    public virtual async Task<List<MenuDto>> GetWebMenusOfUserAsync(Guid? userId)
    {
        var permissions = await GetPermissionsAsync(userId.Value).ConfigureAwait(false);

        var menusEntity = await _menuRepository
            .GetListAsync(p => (permissions.Contains(p.Permission) || p.Permission == "skip")
                               && p.Portal == WEB_PORTAL
                               && p.Status == MenuStatus.Enable).ConfigureAwait(false);
        var menus = ObjectMapper.Map<List<Menu>, List<MenuDto>>(menusEntity);

        //var userMenus = await _repository
        //    .GetListAsync(p => p.UserId == userId);

        //userMenus = userMenus.Where(p => (int)p.Portal == (int)EnumPortal.Web).ToList();

        //var menuCodes = userMenus.Select(p => p.MenuCode).Distinct().ToList();
        //var menus = await GetListByPortalAndCodesAsync(WEB_PORTAL, menuCodes);

        var result = BuildMenuTree(menus);
        return result;
    }

    [AllowAnonymous]
    [UnitOfWork]
    [NonAction]
    private async Task<List<string>> GetPermissionsAsync(Guid userId)
    {
        //var roles = await _identityUserAppService.GetRolesAsync(userId).ConfigureAwait(false);
        var roles = await _identityUserRepository.GetRolesAsync(userId);
        var rolesDto=ObjectMapper.Map<List<IdentityRole>, List<IdentityRoleDto>>(roles);

        var permissionNames = new List<string>();
        foreach (var role in rolesDto)
        {
            var result = await _permissionAppService.GetAsync("R", role.Name).ConfigureAwait(false);
            permissionNames.AddRange(from permissionGroup in result.Groups
                                     from permission in permissionGroup.Permissions
                                     where permission.IsGranted
                                     select permission.Name);
        }

        return permissionNames.Distinct().ToList();
    }

    /// <summary>
    /// 构造web菜单树
    /// </summary>
    /// <param name="menus"></param>
    /// <returns></returns>
    private List<MenuDto> BuildMenuTree(List<MenuDto> menus)
    {
        var rootMenus = menus.OrderBy(p => p.Sort).Where(p => string.IsNullOrEmpty(p.ParentCode)).ToList();
        var menuLookup = menus.ToLookup(p => p.ParentCode);
        var result = new List<MenuDto>();
        foreach (var rootMenu in rootMenus)
        {
            SetChildren(rootMenu, menuLookup);
            result.Add(rootMenu);
        }
        return result;
    }

    private void SetChildren(MenuDto rootMenu, ILookup<string, MenuDto> menus)
    {
        var children = menus.FirstOrDefault(p => p.Key == rootMenu.Code);
        if (children != null)
        {
            rootMenu.Children = new List<MenuDto>();
            rootMenu.Children.AddRange(children.OrderBy(p => p.Sort));
            foreach (var child in children)
            {
                SetChildren(child, menus);
            }
        }
    }

    private async Task<List<MenuDto>> GetListByPortalAndCodesAsync(EnumPortal portal, List<string> menuCodes)
    {
        var entities = await _menuRepository
            .GetListAsync(p => menuCodes.Contains(p.Code));

        entities = entities.Where(p => p.Status == MenuStatus.Enable && p.Portal == EnumPortal.Pda).ToList();

        return ObjectMapper.Map<List<Menu>, List<MenuDto>>(entities);
    }

    /*
    [HttpGet("get-menu-by-login-user-async")]
    [Authorize(UserMenuPermissions.PdaMenu)]
    public virtual async Task<List<PdaMenuGroupDto>> GetMenuByLoginUserAsync()
    {
        var userId = CurrentUser.Id;

        List<PdaMenuGroupDto> pdaMenuGroupDtos = new List<PdaMenuGroupDto>();//返回给pda的菜单 已排序

        List<MenuDto> menuDtos = new List<MenuDto>(); //当前人拥有的所有菜单

        var userMenus = await _repository.GetListAsync(p => p.UserId == userId);

        foreach (var item in userMenus)
        {
            var menuDto = await _menuAppService.GetByCodeAsync(item.MenuCode);
            if (menuDto != null && menuDto.Status == Shared.Domain.Shared.MenuStatus.Enable)
            {
                menuDtos.Add(menuDto);
            }
        }

        var keys = menuDtos.GroupBy(p => p.GroupName);

        foreach (var key in keys)
        {
            List<PdaMenuDto> pdaMenuDtos = new List<PdaMenuDto>();

            int groupSort = 0;

            string title = "";

            foreach (var menuDto in key.OrderBy(p => p.Sort))
            {
                PdaMenuDto pdaMenuDto = new PdaMenuDto { name = menuDto.Name, path = menuDto.Route, url = menuDto.Icon, countUrl = menuDto.CountUrl };

                groupSort = menuDto.GroupSort;

                title = menuDto.GroupName;

                pdaMenuDtos.Add(pdaMenuDto);
            }

            pdaMenuGroupDtos.Add(new PdaMenuGroupDto { groupSort = groupSort, title = title, list = pdaMenuDtos });
        }

        return pdaMenuGroupDtos.OrderBy(p => p.groupSort).ToList();
    }

    [HttpGet("get-UserInfo-async")]
    [Authorize(UserMenuPermissions.PdaMenu)]
    public virtual async Task<PdaUserDto> GetUserAsync()
    {
        PdaUserDto pdaUserDto = null;

        if (CurrentUser.Id != null)
        {
            var userWorkGroupDtos = await _userWorkGroupAppService.GetListOfCurrentUserAsync();

            var list = await GetMenuByLoginUserAsync();

            pdaUserDto = new PdaUserDto
            {
                Name = CurrentUser.GetUserName(),
                UserId = CurrentUser.Id,
                PdaMenuGroupDtos = list,
                UserWorkGroupDto = userWorkGroupDtos
            };
        }

        return pdaUserDto;
    }
    */

    /// <summary>
    /// 按用户ID获取PDA用户菜单
    /// </summary>
    /// <param name="userId"></param>
    /// <returns></returns>
    [HttpGet("pda/by-user/{userId}")]
    public virtual async Task<List<UserMenuDto>> GetPdaListByUserAsync(Guid userId)
    {
        var entities = await _repository.GetListAsync(
            p => p.UserId == userId && p.Portal == PDA_PORTAL).ConfigureAwait(false);

        return ObjectMapper.Map<List<UserMenu>, List<UserMenuDto>>(entities);
    }
    /// <summary>
    /// 按用户ID更新PDA用户菜单
    /// </summary>
    /// <param name="userId"></param>
    /// <param name="inputs"></param>
    /// <returns></returns>
    [HttpPut("pda/by-user/{userId}")]
    public virtual async Task<List<UserMenuDto>> UpdatePdaListByUserAsync(Guid userId, List<UserMenuCreateInput> inputs)
    {
        await _repository.DeleteAsync(p => p.UserId == userId && p.Portal == PDA_PORTAL).ConfigureAwait(false);
        inputs = inputs.Where(p => p.Portal == PDA_PORTAL).ToList();
        var inserts = ObjectMapper.Map<List<UserMenuCreateInput>, List<UserMenu>>(inputs);

        await _repository.InsertManyAsync(inserts).ConfigureAwait(false);

        var result = ObjectMapper.Map<List<UserMenu>, List<UserMenuDto>>(inserts);

        return result;
    }
    /// <summary>
    /// 按用户ID获取WEB用户菜单
    /// </summary>
    /// <param name="userId"></param>
    /// <returns></returns>
    [HttpGet("web/by-user/{userId}")]
    public virtual async Task<List<UserMenuDto>> GetWebListByUserAsync(Guid userId)
    {
        var entities = await _repository.GetListAsync(
            p => p.UserId == userId && p.Portal == WEB_PORTAL).ConfigureAwait(false);

        return ObjectMapper.Map<List<UserMenu>, List<UserMenuDto>>(entities);
    }

    /// <summary>
    /// 按用户ID更新WEB用户菜单
    /// </summary>
    /// <param name="userId"></param>
    /// <param name="inputs"></param>
    /// <returns></returns>
    [HttpPut("web/by-user/{userId}")]
    public virtual async Task<List<UserMenuDto>> UpdateWebListByUserAsync(Guid userId, List<UserMenuCreateInput> inputs)
    {
        await _repository.DeleteAsync(p => p.UserId == userId && p.Portal == WEB_PORTAL).ConfigureAwait(false);
        inputs = inputs.Where(p => p.Portal == WEB_PORTAL).ToList();
        var inserts = ObjectMapper.Map<List<UserMenuCreateInput>, List<UserMenu>>(inputs);

        await _repository.InsertManyAsync(inserts).ConfigureAwait(false);

        var result = ObjectMapper.Map<List<UserMenu>, List<UserMenuDto>>(inserts);

        return result;
    }

}