AGSSbackend/AGSS/Services/MenuService.cs

using AGSS.DbSet;
using AGSS.Models.DTOs;
using AGSS.Models.Entities;
using AGSS.Models.Template;
using Microsoft.EntityFrameworkCore;

namespace AGSS.Services;

public class MenuService
{
    private readonly ApplicationDbContext _context;

    public MenuService(ApplicationDbContext context)
    {
        _context = context;
    }

    /// <summary>
    /// 新增父级菜单
    /// </summary>
    public async Task<ReturnTemplate> CreateParentMenu(MenuRequest request)
    {
        try
        {
            var menu = new MenuModel
            {
                Uuid = Guid.NewGuid().ToString(),
                ParentId = null,
                Path = request.Path,
                Label = request.Label,
                Icon = request.Icon,
                MenuCode = request.MenuCode,
                Adaptability = request.Adaptability,
                Component = request.Component,
                Sort = request.Sort,
                Status = request.Status,
                Query = request.Query,
                CreateTime = DateTime.Now
            };

            _context.Menus.Add(menu);
            await _context.SaveChangesAsync();

            return new ReturnTemplate(200, "父级菜单创建成功", menu);
        }
        catch (Exception ex)
        {
            return new ReturnTemplate(500, $"创建父级菜单失败: {ex.Message}", null);
        }
    }

    /// <summary>
    /// 编辑父级菜单
    /// </summary>
    public async Task<ReturnTemplate> UpdateParentMenu(MenuRequest request)
    {
        try
        {
            if (string.IsNullOrEmpty(request.Uuid))
            {
                return new ReturnTemplate(400, "UUID不能为空", null);
            }

            var menu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == request.Uuid);
            if (menu == null)
            {
                return new ReturnTemplate(404, "菜单不存在", null);
            }

            // 确保是父级菜单
            if (!string.IsNullOrEmpty(menu.ParentId))
            {
                return new ReturnTemplate(400, "只能编辑父级菜单", null);
            }

            menu.Path = request.Path;
            menu.Label = request.Label;
            menu.Icon = request.Icon;
            menu.MenuCode = request.MenuCode;
            menu.Adaptability = request.Adaptability;
            menu.Component = request.Component;
            menu.Sort = request.Sort;
            menu.Status = request.Status;
            menu.Query = request.Query;
            menu.UpdateTime = DateTime.Now;

            await _context.SaveChangesAsync();

            return new ReturnTemplate(200, "父级菜单更新成功", menu);
        }
        catch (Exception ex)
        {
            return new ReturnTemplate(500, $"更新父级菜单失败: {ex.Message}", null);
        }
    }

    /// <summary>
    /// 新增子级菜单
    /// </summary>
    public async Task<ReturnTemplate> CreateChildMenu(MenuRequest request)
    {
        try
        {
            if (string.IsNullOrEmpty(request.ParentId))
            {
                return new ReturnTemplate(400, "父级ID不能为空", null);
            }

            // 验证父级菜单是否存在
            var parentMenu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == request.ParentId);
            if (parentMenu == null)
            {
                return new ReturnTemplate(404, "父级菜单不存在", null);
            }

            var menu = new MenuModel
            {
                Uuid = Guid.NewGuid().ToString(),
                ParentId = request.ParentId,
                Path = request.Path,
                Label = request.Label,
                Icon = request.Icon,
                MenuCode = request.MenuCode,
                Adaptability = request.Adaptability,
                Component = request.Component,
                Sort = request.Sort,
                Status = request.Status,
                Query = request.Query,
                CreateTime = DateTime.Now
            };

            _context.Menus.Add(menu);
            await _context.SaveChangesAsync();

            return new ReturnTemplate(200, "子级菜单创建成功", menu);
        }
        catch (Exception ex)
        {
            return new ReturnTemplate(500, $"创建子级菜单失败: {ex.Message}", null);
        }
    }

    /// <summary>
    /// 编辑子级菜单
    /// </summary>
    public async Task<ReturnTemplate> UpdateChildMenu(MenuRequest request)
    {
        try
        {
            if (string.IsNullOrEmpty(request.Uuid))
            {
                return new ReturnTemplate(400, "UUID不能为空", null);
            }

            var menu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == request.Uuid);
            if (menu == null)
            {
                return new ReturnTemplate(404, "菜单不存在", null);
            }

            // 确保是子级菜单
            if (string.IsNullOrEmpty(menu.ParentId))
            {
                return new ReturnTemplate(400, "只能编辑子级菜单", null);
            }

            menu.Path = request.Path;
            menu.Label = request.Label;
            menu.Icon = request.Icon;
            menu.MenuCode = request.MenuCode;
            menu.Adaptability = request.Adaptability;
            menu.Component = request.Component;
            menu.Sort = request.Sort;
            menu.Status = request.Status;
            menu.Query = request.Query;
            menu.UpdateTime = DateTime.Now;

            await _context.SaveChangesAsync();

            return new ReturnTemplate(200, "子级菜单更新成功", menu);
        }
        catch (Exception ex)
        {
            return new ReturnTemplate(500, $"更新子级菜单失败: {ex.Message}", null);
        }
    }

    /// <summary>
    /// 查询菜单全量返回（树形结构）
    /// </summary>
    public async Task<ReturnTemplate> GetAllMenus()
    {
        try
        {
            var allMenus = await _context.Menus
                .OrderBy(m => m.Sort)
                .ToListAsync();

            var menuTree = BuildMenuTree(allMenus);

            return new ReturnTemplate(200, "成功", menuTree);
        }
        catch (Exception ex)
        {
            return new ReturnTemplate(500, $"查询菜单失败: {ex.Message}", null);
        }
    }

    /// <summary>
    /// 删除菜单（递归删除）
    /// </summary>
    public async Task<ReturnTemplate> DeleteMenu(string uuid)
    {
        try
        {
            if (string.IsNullOrEmpty(uuid))
            {
                return new ReturnTemplate(400, "UUID不能为空", null);
            }

            var menuToDelete = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == uuid);
            if (menuToDelete == null)
            {
                return new ReturnTemplate(404, "菜单不存在", null);
            }

            // 递归删除所有子菜单
            await DeleteMenuRecursive(uuid);

            return new ReturnTemplate(200, "菜单删除成功", null);
        }
        catch (Exception ex)
        {
            return new ReturnTemplate(500, $"删除菜单失败: {ex.Message}", null);
        }
    }

    /// <summary>
    /// 递归删除菜单及其子菜单
    /// </summary>
    private async Task DeleteMenuRecursive(string parentUuid)
    {
        var children = await _context.Menus.Where(m => m.ParentId == parentUuid).ToListAsync();
        
        foreach (var child in children)
        {
            await DeleteMenuRecursive(child.Uuid);
        }

        var menu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == parentUuid);
        if (menu != null)
        {
            _context.Menus.Remove(menu);
        }
    }

    /// <summary>
    /// 构建菜单树形结构
    /// </summary>
    private List<MenuResponse> BuildMenuTree(List<MenuModel> allMenus)
    {
        var menuDict = allMenus.ToDictionary(m => m.Uuid);
        var rootMenus = new List<MenuResponse>();

        foreach (var menu in allMenus)
        {
            var menuResponse = new MenuResponse
            {
                Uuid = menu.Uuid,
                ParentId = menu.ParentId,
                Path = menu.Path,
                Label = menu.Label,
                Icon = menu.Icon,
                MenuCode = menu.MenuCode,
                Adaptability = menu.Adaptability,
                Component = menu.Component,
                Sort = menu.Sort,
                Status = menu.Status,
                Query = menu.Query,
                CreateTime = menu.CreateTime,
                UpdateTime = menu.UpdateTime
            };

            if (string.IsNullOrEmpty(menu.ParentId))
            {
                // 根菜单
                rootMenus.Add(menuResponse);
            }
            else
            {
                // 子菜单
                if (menuDict.TryGetValue(menu.ParentId, out var parentMenu))
                {
                    var parentResponse = FindMenuResponse(rootMenus, menu.ParentId);
                    if (parentResponse != null)
                    {
                        parentResponse.Children.Add(menuResponse);
                    }
                }
            }
        }

        return rootMenus;
    }

    /// <summary>
    /// 在菜单树中查找指定UUID的菜单响应对象
    /// </summary>
    private MenuResponse? FindMenuResponse(List<MenuResponse> menus, string uuid)
    {
        foreach (var menu in menus)
        {
            if (menu.Uuid == uuid)
            {
                return menu;
            }

            var found = FindMenuResponse(menu.Children, uuid);
            if (found != null)
            {
                return found;
            }
        }

        return null;
    }
}