using Dlhis.Entity.Sys.Entities;
using Dlhis.Entity.Sys.Enums;
using Dlhis.Sys.Identity.Services;
using Dlhis.Sys.Menu.Request;
using Dlhis.Sys.Menu.Response;
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using Mapster;

namespace Dlhis.Sys.Menu.Services.Implements;

public class MenuService : IMenuService
{
    private readonly IDbContext _dbContext;
    private readonly ICurrentUser _currentUser;
    private readonly IUserService _userService;

    public MenuService(IDbContext dbContext, ICurrentUser currentUser, IUserService userService)
    {
        _dbContext = dbContext;
        _currentUser = currentUser;
        _userService = userService;
    }

    public async Task<List<MenuResponse>> GetListAsync(PlatformEnumType platform)
    {
        var result = await _dbContext.Queryable<MenuEntity>()
            .Where(x => x.Platform == platform)
            .OrderBy(x => x.Sequence)
            .Select<MenuResponse>()
            .ToListAsync();

        var top = result.Where(x => x.PCode.IsEmpty()).ToList();
        foreach (var menu in top)
        {
            RecursionGetNext(menu, result);
        }

        return top;
    }


    public async Task<string> SaveMenuAsync(SaveMenuRequest request)
    {
        await CheckAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<MenuEntity>();
            await _dbContext.InsertAsync(entity);
            return entity.Code;
        }
        else
        {
            var entity = await _dbContext.Queryable<MenuEntity>().Where(x => x.Id == request.Id).FirstAsync();
            await ChangeIfCodeEditAsync(entity.Code, request.Code);

            request.Adapt(entity);

            await _dbContext.UpdateAsync(entity);
            return entity.Code;
        }
    }

    public async Task AssignmentAsync(MenuPermissionAssignmentRequest request)
    {
        //清空覆盖
        var permissionsToDelete = await _dbContext.Queryable<MenuPermissionEntity>()
            .Where(x => x.UniqueType == request.UniqueType)
            .Where(x => x.UniqueValue == request.UniqueValue)
            .ToListAsync();

        await _dbContext.DeleteAsync(permissionsToDelete);

        var permissions = request.Codes.Distinct().Select(x => new MenuPermissionEntity
        {
            Code = x,
            UniqueType = request.UniqueType,
            UniqueValue = request.UniqueValue
        }).ToList();

        await _dbContext.InsertAsync(permissions);
    }

    public async Task<List<string>> GetAssignmentCodesAsync(AssignTypeEnumType uniqueType, string uniqueData)
    {
        var permissionCodes = await _dbContext.Queryable<MenuPermissionEntity>()
            .Where(x => x.UniqueType == uniqueType)
            .Where(x => x.UniqueValue == uniqueData)
            .Select(x => x.Code)
            .ToListAsync();

        // var menus = await GetListAsync(PlatformEnumType.PCAdmin);
        //
        // foreach (var menu in menus)
        // {
        //     RecursionHandler(menu, permissionCodes, permissionCodes.Contains(menu.Code));
        // }

        return permissionCodes;

        // static bool RecursionHandler(MenuResponse current, List<string> innerPermissions, bool add)
        // {
        //     if (add) innerPermissions.Add(current.Code);
        //
        //     foreach (var menu in current.Items)
        //     {
        //         var currentAdd = RecursionHandler(menu, innerPermissions, add || innerPermissions.Contains(menu.Code));
        //         if (currentAdd && !innerPermissions.Contains(current.Code))
        //         {
        //             innerPermissions.Add(current.Code);
        //         }
        //     }
        //
        //     return add;
        // }
    }

    public async Task<List<string>> GetAllAssignmentPermissionsAsync()
    {
        var menus = await GetCurrentMenusAsync();
        return GetPermissions(menus).ToList();

        IEnumerable<string> GetPermissions(List<MenuResponse> innerMenuResponses)
        {
            foreach (var item in innerMenuResponses)
            {
                yield return item.Permission;

                foreach (var item1 in GetPermissions(item.Items))
                {
                    yield return item1;
                }
            }
        }
    }

    public async Task<List<MenuResponse>> GetCurrentMenusAsync()
    {
        //我能看到的权限code,非permissions
        var allCodes = await GetAllAssignmentCodesAsync();
        if (!allCodes.Any())
        {
            //todo 管理员 
            if (_currentUser.GetIntSubjectId() == 1)
            {
                return await GetListAsync(PlatformEnumType.PCAdmin);
            }

            return new List<MenuResponse>();
        }

        var allMenus = await _dbContext.Queryable<MenuEntity>()
            .Where(x => x.Platform == PlatformEnumType.PCAdmin)
            .Where(x => x.Visible)
            .Where(x => allCodes.Contains(x.Code))
            .Select<MenuResponse>()
            .ToListAsync();

        //获取顶级数据
        var menus = await _dbContext.Queryable<MenuEntity>()
            .Where(x => x.Platform == PlatformEnumType.PCAdmin)
            .Where(x => x.Visible)
            .Where(x => string.IsNullOrEmpty(x.PCode))
            .Select<MenuResponse>()
            .ToListAsync();

        foreach (var menu in menus)
        {
            RecursionGetNext(menu, allMenus);
        }

        menus.RemoveAll(x => !x.Items.Any());
        return menus;
    }

    public async Task<bool> IsPass(IEnumerable<string> p)
    {
        var permissions = await GetAllAssignmentPermissionsAsync();
        return permissions.Count == 0 || permissions.All(x => p.Contains(x));
    }

    public async Task ResetAsync(List<SaveMenuRequest> request)
    {
        var currentMenus = await _dbContext.Queryable<MenuEntity>().Where(x => x.Platform == PlatformEnumType.PCAdmin).ToListAsync();
        await _dbContext.Client.Deleteable(currentMenus).ExecuteCommandAsync();

        foreach (var item in request)
        {
            item.Sequence = currentMenus.FirstOrDefault(x => x.Code == item.Code)?.Sequence ?? item.Sequence;
            var code = await SaveMenuAsync(item);
            if (item.Items?.Any() == true)
            {
                item.Items.ForEach(x => x.PCode = code);
                await RecursionSaveNextAsync(item.Items);
            }
        }

        //递归处理下一级
        async Task RecursionSaveNextAsync(List<SaveMenuRequest> menus)
        {
            foreach (var item in menus)
            {
                item.Sequence = currentMenus.FirstOrDefault(x => x.Code == item.Code)?.Sequence ?? item.Sequence;
                var code = await SaveMenuAsync(item);

                if (item.Items?.Any() == true)
                {
                    item.Items.ForEach(x => x.PCode = code);
                    await RecursionSaveNextAsync(item.Items);
                }
            }
        }
    }

    //****************************************************************** help methods ******************************************************************************


    private static void RecursionGetNext(MenuResponse current, List<MenuResponse> menus)
    {
        var nextMenus = menus.Where(x => x.PCode == current.Code).ToList();
        current.Items = nextMenus;
        foreach (var menu in nextMenus)
        {
            RecursionGetNext(menu, menus);
        }
    }

    private async Task CheckAsync(SaveMenuRequest request)
    {
        //检查重复code
        (await _dbContext.Queryable<MenuEntity>()
                .Where(x => x.Code == request.Code)
                .WhereIF(request.Id.HasValue, x => x.Id != request.Id).AnyAsync())
            .ThrowIfTrue($"{request.Title}存在重复code");

        //检查name
        (await _dbContext.Queryable<MenuEntity>()
                .Where(x => x.Name == request.Name)
                .WhereIF(request.Id.HasValue, x => x.Id != request.Id).AnyAsync())
            .ThrowIfTrue($"{request.Title}存在重复name");


        //判断权限重复
        if (request.Permission.IsPresent())
        {
            (await _dbContext.Queryable<MenuEntity>()
                    .Where(x => x.Permission == request.Permission && (request.MenuType == MenuEnumType.Menu || request.MenuType == MenuEnumType.Button))
                    .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
                    .AnyAsync())
                .ThrowIfTrue($"{request.Title}存在重复权限标识");
        }

        //request.PCode
        var pMenu = await _dbContext.Queryable<MenuEntity>().Where(x => x.Code == request.PCode).SingleAsync();
        if (request.MenuType == MenuEnumType.Folder)
        {
            //request.PCode = null;
            if (string.IsNullOrEmpty(request.PCode))
            {
                request.PCode = null;
            }
        }
        else if (request.MenuType == MenuEnumType.Menu)
        {
            pMenu.ThrowIfNull($"{request.Title}的上级菜单不存在");
            (pMenu.MenuType != MenuEnumType.Folder).ThrowIfTrue($"{request.Title}菜单上级需要为目录");
        }
        else if (request.MenuType == MenuEnumType.Button)
        {
            pMenu.ThrowIfNull($"{request.Title}的上级菜单不存在");
            (pMenu.MenuType != MenuEnumType.Menu).ThrowIfTrue($"{request.Title}按钮上级需要为菜单");
        }
    }

    private async Task<List<string>> GetAllAssignmentCodesAsync()
    {
        var user = await _userService.GetUserByIdAsync(_currentUser.GetIntSubjectId());

        //user
        var userCodes = await GetAssignmentCodesAsync(AssignTypeEnumType.User, user.Id.ToString());

        //role
        var roleCodes = await GetAssignmentCodesAsync(AssignTypeEnumType.Role, user.RoleId.ToString());

        return userCodes.Concat(roleCodes).Distinct().ToList();
    }


    private async Task ChangeIfCodeEditAsync(string beforeCode, string pCode)
    {
        if (beforeCode != pCode)
        {
            //修改下级的PCode为当前的code
            var menus = await _dbContext.Queryable<MenuEntity>().Where(x => x.PCode == beforeCode).ToListAsync();
            menus.ForEach(x => { x.PCode = pCode; });

            //修改权限code为当前的code,避免权限丢失
            var permissions = await _dbContext.Queryable<MenuPermissionEntity>().Where(x => x.Code == beforeCode).ToListAsync();
            permissions.ForEach(x => { x.Code = pCode; });

            await _dbContext.UpdateAsync(menus);
            await _dbContext.UpdateAsync(permissions);
        }
    }
}