package com.ydtech.modules.admin.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.constants.SysConstants;
import com.ydtech.modules.admin.dao.SysMenuMapper;
import com.ydtech.modules.admin.model.SysMenu;
import com.ydtech.modules.admin.model.SysMenuVo;
import com.ydtech.modules.admin.model.SysRoleMenu;
import com.ydtech.modules.admin.service.SysMenuService;
import com.ydtech.modules.admin.service.SysRoleMenuKztService;
import com.ydtech.modules.admin.service.SysRoleMenuService;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;


@Service
public class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu>
        implements SysMenuService {

    @Autowired
    private SysRoleMenuService sysRoleMenuService;

    @Autowired
    private SysRoleMenuKztService sysRoleMenuKztService;

    @Autowired
    private SysMenuMapper sysMenuMapper;


    @Override
    public List<SysMenu> findTree(String userName, int menuType) {
        List<SysMenu> sysMenus = new ArrayList<>();
        List<SysMenu> menus = findByUser(userName);
        for (SysMenu menu : menus) {
            if (menu.getParentId() == null || menu.getParentId().equalsIgnoreCase("0")) {
                menu.setLevel(0);
                if (!exists(sysMenus, menu)) {
                    sysMenus.add(menu);
                }
            }
        }
        sysMenus.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
        findChildren(sysMenus, menus, menuType);
        return sysMenus;
    }

    @Override
    public List<SysMenu> findByUser(String userName) {
         LambdaQueryWrapper<SysMenu> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysMenu::getDelFlag, 0);
        lqw.eq(SysMenu::getSysType, 1);
        if (userName == null || "".equals(userName) || SysConstants.ADMIN.equalsIgnoreCase(userName)) {
//            return selectList(" where 1=1 and del_flag=0", null);
            return list(lqw);
        }

        return sysRoleMenuService.gainMenuIds(userName);

//        return selectList(" where t.id in (select menu_id from sys_role_menu t1 left join sys_user_role t2 on t1.role_id=t2.role_id where t2.user_id=?) and del_flag=0", new Object[]{userName});
    }

    @Override
    public List<SysMenu> findRoleMenus(Long roleId) {
        LambdaQueryWrapper<SysRoleMenu> srmLqw = new LambdaQueryWrapper<>();
        srmLqw.select(SysRoleMenu::getMenuId);
        srmLqw.eq(SysRoleMenu::getRoleId, roleId);
        //查询获取对象具体字段的集合
        List<Long> longs = sysRoleMenuService.listObjs(srmLqw, new Function<Object, Long>() {
            @Override
            public Long apply(Object id) {
                //进行一系列转换操作 ，最终返回我们所需要的类型V ， 这里只做简单演示。
                return Long.valueOf(id.toString());
            }
        });


        LambdaQueryWrapper<SysMenu> smlqw = new LambdaQueryWrapper<>();
        smlqw.eq(SysMenu::getDelFlag, 0);
        smlqw.in(SysMenu::getId, longs);
        smlqw.in(SysMenu::getSysType, "1");
        return list(smlqw);


//        String sql = "select m.* from sys_menu m, sys_role_menu rm " +
//                "    where rm.role_id=" + roleId +
//                "    and m.id = rm.menu_id " +
//                "    and m.del_flag=0";
//
//        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
//
//        return jdbcTemplate.query(sql, new SysMenuRowMapper());
    }

    private void findChildren(List<SysMenu> SysMenus, List<SysMenu> menus, int menuType) {

        for (SysMenu SysMenu : SysMenus) {
            List<SysMenu> children = new ArrayList<>();
            for (SysMenu menu : menus) {
                if (menuType == 1 && menu.getType() == 2) {
                    // 如果是获取类型不需要按钮，且菜单类型是按钮的，直接过滤掉
                    continue;
                }
                if (SysMenu.getId() != null && SysMenu.getId().equals(menu.getParentId())) {
                    menu.setParentName(SysMenu.getName());
                    menu.setLevel(SysMenu.getLevel() + 1);
                    if (!exists(children, menu)) {
                        children.add(menu);
                    }
                }
            }
            SysMenu.setChildren(children);
            children.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
            findChildren(children, menus, menuType);
        }
    }
    @Override
    public ArrayList<SysMenuVo> v1findMenuTree() {
        List<SysMenu> tree = this.findTree(null, 0);
        ArrayList<SysMenuVo> menus = Lists.newArrayList();
        tree.forEach(menu->{
            SysMenuVo sysMenuVo = new SysMenuVo();
            BeanUtil.copyProperties(menu, sysMenuVo);
            sysMenuVo.setNodeName(menu.getName());
            sysMenuVo.setIsChecked(false);
            sysMenuVo.setEditable(false);
            if(CollectionUtil.isNotEmpty(menu.getChildren())){
                this.v1findMenuTreeChildren(menu.getChildren(),sysMenuVo);
            }else{
                sysMenuVo.setChidrenList(CollectionUtil.newArrayList());
            }
            menus.add(sysMenuVo);
        });
        return menus;
    }

    private void v1findMenuTreeChildren(List<SysMenu> tree,SysMenuVo sysMenuVos){
        ArrayList<SysMenuVo> menus = Lists.newArrayList();
        tree.forEach(menu->{
            SysMenuVo sysMenuVo = new SysMenuVo();
            BeanUtil.copyProperties(menu, sysMenuVo);
            sysMenuVo.setNodeName(menu.getName());
            sysMenuVo.setIsChecked(false);
            sysMenuVo.setEditable(false);
            if(CollectionUtil.isNotEmpty(menu.getChildren())){
                this.v1findMenuTreeChildren(menu.getChildren(),sysMenuVo);
            }else{
                sysMenuVo.setChidrenList(CollectionUtil.newArrayList());
            }
            menus.add(sysMenuVo);
        });
        sysMenuVos.setChidrenList(menus);
    }
    private boolean exists(List<SysMenu> sysMenus, SysMenu sysMenu) {
        boolean exist = false;
        for (SysMenu menu : sysMenus) {
            if (menu.getId().equals(sysMenu.getId())) {
                exist = true;
            }
        }
        return exist;
    }
    /**
     *  @version
     *  @author: hxl
     *  @Date: 2024/8/14 14:30
     *  @Description:  查询控制台的所有菜单数据
     */
    @Override
    public List<SysMenu> queryKZTMenuList(String sysType,int menuType) {
        List<SysMenu> sysMenus = getSysMenus(sysType, menuType,null);
        return sysMenus;
    }

    private List<SysMenu> getSysMenusNew(String sysType, int menuType,String userId) {
        List<SysMenu> sysMenus = new ArrayList<>();
        List<SysMenu> menus  =new ArrayList<>();
        if(StringUtils.isBlank(userId) || (StringUtils.isNotBlank(userId) && "admin".equals(userId))){
            //  LambdaQueryWrapper<SysMenu> lqw = new LambdaQueryWrapper<>();
            //  lqw.eq(SysMenu::getDelFlag, 0);
            // lqw.eq(SysMenu::getSysType, sysType);
            menus= sysMenuMapper.findBySysTypeList(sysType,"0");
            // menus = list(lqw);
        }else{
            menus= sysRoleMenuService.gainMenuIdsByUserId(userId,sysType);
        }
        //填充父级菜单数据
        this.addParentMenu(menus);

        for (SysMenu menu : menus) {
            if (menu.getParentId() == null || menu.getParentId().equalsIgnoreCase("0")) {
                menu.setLevel(0);
                if (!exists(sysMenus, menu)) {
                    sysMenus.add(menu);
                }
            }
        }
        sysMenus.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
        findChildren(sysMenus, menus, menuType);
        return sysMenus;
    }

    private void addParentMenu(List<SysMenu>   menus) {
        List<String> menuIds = menus.stream().map(SysMenu::getId).collect(Collectors.toList()); //menuIds
        for (String menuId : menuIds) {
            this.addParentId(menuId,menuIds,menus);
        }
    }

    private void addParentId(String menuId, List<String> menuIds, List<SysMenu> menus) {
        SysMenu sysMenu = baseMapper.selectById(menuId);
        if(ObjectUtils.isNotEmpty(sysMenu)){
            if( !menuIds.contains(sysMenu.getParentId())){
                menus.add(sysMenu);
                this.addParentId(sysMenu.getParentId(),menuIds,menus);
            }
        }
    }

    private List<SysMenu> getSysMenus(String sysType, int menuType,String userId) {
        List<SysMenu> sysMenus = new ArrayList<>();
        List<SysMenu> menus  =new ArrayList<>();
        if(StringUtils.isBlank(userId) || (StringUtils.isNotBlank(userId) && "admin".equals(userId))){
          //  LambdaQueryWrapper<SysMenu> lqw = new LambdaQueryWrapper<>();
          //  lqw.eq(SysMenu::getDelFlag, 0);
           // lqw.eq(SysMenu::getSysType, sysType);
            menus= sysMenuMapper.findBySysTypeList(sysType,"0");
           // menus = list(lqw);
        }else{
            menus= sysRoleMenuService.gainMenuIdsByUserId(userId,sysType);
        }
        for (SysMenu menu : menus) {
            if (menu.getParentId() == null || menu.getParentId().equalsIgnoreCase("0")) {
                menu.setLevel(0);
                if (!exists(sysMenus, menu)) {
                    sysMenus.add(menu);
                }
            }
        }
        sysMenus.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
        findChildren(sysMenus, menus, menuType);
        return sysMenus;
    }

    /**
     *  @version
     *  @author: hxl
     *  @Date: 2024/8/14 14:59
     *  @Description: 通过用户id查询菜单树
     */
    @Override
    public List<SysMenu> findMenuListByUserId(String userId, String sysType) {
        return getSysMenusNew(sysType,0,userId);
    }



    /**
     *  @version
     *  @author: hxl
     *  @Date: 2024/8/15 11:38
     *  @Description: 通过角色查询菜单树
     */
    public List<SysMenu> getSysMenusByRoleId(Long roleId, String sysType) {
        List<SysMenu> sysMenus = new ArrayList<>();

        List<SysMenu> menus = sysRoleMenuKztService.findMenuIdsByRoleId(roleId,sysType);
//        for (SysMenu menu : menus) {
//            if (menu.getParentId() == null || menu.getParentId().equalsIgnoreCase("0")) {
//                menu.setLevel(0);
//                if (!exists(sysMenus, menu)) {
//                    sysMenus.add(menu);
//                }
//            }else {
//                SysMenu pidSysMenu = baseMapper.selectById(menu.getParentId());
//                if(ObjectUtils.isNotEmpty(pidSysMenu)){
//                    pidSysMenu.setLevel(0);
//                    if (!exists(sysMenus, pidSysMenu)) {
//                        sysMenus.add(pidSysMenu);
//                    }
//                }
//            }
//        }
//        sysMenus.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
        findChildren(sysMenus, menus, 0);
        return menus;
    }
    /**
     *  @version
     *  @author: hxl
     *  @Date: 2024/8/20 15:37
     *  @Description:  通過用戶id查询是否有权限
     */
    @Override
    public int findByUseId(String userId, String sysType) {
        return sysRoleMenuKztService.findByUseId(userId,sysType);
    }

}