package shop.alien.store.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import shop.alien.entity.store.StorePlatformMenu;
import shop.alien.mapper.StorePlatformMenuMapper;
import shop.alien.store.service.RoleMenuService;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 角色菜单服务实现类
 *
 * @author system
 * @since 2025-01-01
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class RoleMenuServiceImpl implements RoleMenuService {

    private final StorePlatformMenuMapper storePlatformMenuMapper;

    @Override
    public List<StorePlatformMenu> getMenusByRoleId(Long roleId) {
        log.info("RoleMenuServiceImpl.getMenusByRoleId?roleId={}", roleId);
        
        if (roleId == null) {
            log.warn("角色ID为空");
            return new ArrayList<>();
        }
        
        try {
            // 1. 查询角色直接关联的菜单列表
            List<StorePlatformMenu> directMenus = storePlatformMenuMapper.selectMenusByRoleId(roleId);
            
            if (directMenus == null || directMenus.isEmpty()) {
                log.info("角色未分配任何菜单权限 - roleId: {}", roleId);
                return new ArrayList<>();
            }
            
            // 2. 找出最高层级
            Integer maxLevel = directMenus.stream()
                    .map(StorePlatformMenu::getLevel)
                    .filter(Objects::nonNull)
                    .max(Integer::compareTo)
                    .orElse(1);
            
            // 3. 收集所有需要的菜单ID（包括父菜单）
            Set<Long> allMenuIds = directMenus.stream()
                    .map(StorePlatformMenu::getMenuId)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toSet());
            
            // 4. 如果需要，补充父级权限
            if (maxLevel >= 3) {
                // 如果有三级权限，需要补充一级和二级父权限
                for (StorePlatformMenu menu : directMenus) {
                    if (menu.getLevel() != null && menu.getLevel() == 3) {
                        // 补充二级父权限
                        if (menu.getParentId() != null && menu.getParentId() != 0) {
                            allMenuIds.add(menu.getParentId());
                            // 补充一级父权限
                            StorePlatformMenu level2Menu = storePlatformMenuMapper.selectById(menu.getParentId());
                            if (level2Menu != null && level2Menu.getParentId() != null && level2Menu.getParentId() != 0) {
                                allMenuIds.add(level2Menu.getParentId());
                            }
                        }
                    }
                }
            } else if (maxLevel == 2) {
                // 如果只有二级权限，需要补充一级父权限
                for (StorePlatformMenu menu : directMenus) {
                    if (menu.getLevel() != null && menu.getLevel() == 2) {
                        if (menu.getParentId() != null && menu.getParentId() != 0) {
                            allMenuIds.add(menu.getParentId());
                        }
                    }
                }
            }
            
            // 5. 查询所有需要的菜单（包括父菜单）
            List<StorePlatformMenu> allMenus = new ArrayList<>();
            if (!allMenuIds.isEmpty()) {
                LambdaQueryWrapper<StorePlatformMenu> menuWrapper = new LambdaQueryWrapper<>();
                menuWrapper.in(StorePlatformMenu::getMenuId, allMenuIds)
                        .eq(StorePlatformMenu::getDelFlag, "0")
                        .eq(StorePlatformMenu::getStatus, "0")
                        .orderByAsc(StorePlatformMenu::getMenuSort);
                allMenus = storePlatformMenuMapper.selectList(menuWrapper);
            }
            
            // 6. 构建树形结构
            List<StorePlatformMenu> treeMenus = buildMenuTree(allMenus);
            
            log.info("查询角色权限菜单成功 - roleId: {}, 菜单数量: {}, 树形结构数量: {}", 
                    roleId, allMenus.size(), treeMenus.size());
            return treeMenus;
            
        } catch (Exception e) {
            log.error("查询角色权限菜单失败 - roleId: {}", roleId, e);
            return new ArrayList<>();
        }
    }
    
    /**
     * 构建菜单树形结构
     *
     * @param menus 菜单列表
     * @return 树形结构的菜单列表
     */
    private List<StorePlatformMenu> buildMenuTree(List<StorePlatformMenu> menus) {
        if (menus == null || menus.isEmpty()) {
            return new ArrayList<>();
        }
        
        // 按层级和排序顺序排序
        menus.sort(Comparator
                .comparing(StorePlatformMenu::getLevel, Comparator.nullsLast(Integer::compareTo))
                .thenComparing(StorePlatformMenu::getMenuSort, Comparator.nullsLast(Integer::compareTo)));
        
        // 创建菜单映射表（menuId -> menu）
        Map<Long, StorePlatformMenu> menuMap = menus.stream()
                .collect(Collectors.toMap(
                        StorePlatformMenu::getMenuId,
                        menu -> {
                            // 初始化 children 列表
                            if (menu.getChildren() == null) {
                                menu.setChildren(new ArrayList<>());
                            }
                            return menu;
                        },
                        (existing, replacement) -> existing
                ));
        
        // 构建树形结构
        List<StorePlatformMenu> rootMenus = new ArrayList<>();
        for (StorePlatformMenu menu : menus) {
            Long parentId = menu.getParentId();
            
            if (parentId == null || parentId == 0) {
                // 根菜单（一级菜单）
                rootMenus.add(menu);
            } else {
                // 子菜单，添加到父菜单的 children 中
                StorePlatformMenu parentMenu = menuMap.get(parentId);
                if (parentMenu != null) {
                    if (parentMenu.getChildren() == null) {
                        parentMenu.setChildren(new ArrayList<>());
                    }
                    parentMenu.getChildren().add(menu);
                } else {
                    // 如果找不到父菜单，作为根菜单处理
                    rootMenus.add(menu);
                }
            }
        }
        
        // 对每个层级的 children 进行排序
        sortMenuChildren(rootMenus);
        
        return rootMenus;
    }
    
    /**
     * 递归排序菜单的 children
     *
     * @param menus 菜单列表
     */
    private void sortMenuChildren(List<StorePlatformMenu> menus) {
        if (menus == null || menus.isEmpty()) {
            return;
        }
        
        // 对当前层级排序
        menus.sort(Comparator
                .comparing(StorePlatformMenu::getMenuSort, Comparator.nullsLast(Integer::compareTo)));
        
        // 递归排序子菜单
        for (StorePlatformMenu menu : menus) {
            if (menu.getChildren() != null && !menu.getChildren().isEmpty()) {
                sortMenuChildren(menu.getChildren());
            }
        }
    }
}
