using Dlhis.Entity.Permission.Entities;
using Dlhis.Entity.Permission.Enums;
using Dlhis.Sys.Menu.Request;
using Dlhis.Sys.Menu.Response;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.User.Abstractions;
using Kurisu.SqlSugar.Services;
using Mapster;

namespace Dlhis.Sys.Menu.Services.Implements;

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

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

    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 SaveMenuAsync(SaveMenuRequest request)
    {
        await CheckAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<MenuEntity>();
            await _dbContext.InsertAsync(entity);
        }
        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);
        }
    }


    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);
        }
    }

    public async Task AssignmentAsync(MenuPermissionAssignmentRequest request)
    {
        (request.UniqueType == MenuPermissionTypeEnumType.Role).ThrowIfTrue("暂不支持角色分配");

        //清空覆盖
        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.Select(x => new MenuPermissionEntity
        {
            Code = x,
            UniqueType = request.UniqueType,
            UniqueValue = request.UniqueValue

        }).ToList();


        await _dbContext.InsertAsync(permissions);
    }

    public Task<List<string>> GetAssignmentCodesAsync(MenuPermissionTypeEnumType permissionType, string uniqueData)
    {
        throw new NotImplementedException();
    }

    public Task<List<string>> GetAllAssignmentPermissionsAsync()
    {
        throw new NotImplementedException();
    }

    public Task<List<MenuResponse>> GetCurrentMenusAsync()
    {
        throw new NotImplementedException();
    }

    public Task<bool> IsPass(IEnumerable<string> p)
    {
        throw new NotImplementedException();
    }

    public Task ResetAsync(List<SaveMenuRequest> request)
    {
        throw new NotImplementedException();
    }


    private 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
        var exists = await _dbContext.Queryable<MenuEntity>()
                            .Where(x => x.Code == request.Code)
                            .WhereIF(request.Id.HasValue, x => x.Id != request.Id).AnyAsync();
        exists.ThrowIfTrue($"{request.Title}存在重复code");

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

        //判断权限重复
        if (request.Permission.IsPresent())
        {
            exists = 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();
            exists.ThrowIfTrue($"{request.Title}存在重复权限标识");
        }

        //request.PCode
        var menu = await _dbContext.Queryable<MenuEntity>().Where(x => x.Code == request.PCode).FirstAsync();
        (menu == null && request.MenuType != MenuEnumType.Folder).ThrowIfTrue($"{request.Title}上级不存在");

        if (request.MenuType == MenuEnumType.Folder)
        {
            request.PCode = null;
        }
        else if (request.MenuType == MenuEnumType.Menu)
        {
            if (menu.MenuType != MenuEnumType.Folder)
            {
                throw new Exception($"{request.Title}菜单上级需要为目录");
            }
        }
        else
        {
            //button
            if (menu.MenuType != MenuEnumType.Menu)
            {
                throw new Exception($"{request.Title}按钮上级需要为菜单");
            }
        }
    }
}