package org.jeecg.modules.dnc.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections4.ListUtils;
import org.jeecg.modules.dnc.entity.PermissionStreamNew;
import org.jeecg.modules.dnc.entity.ProductMix;
import org.jeecg.modules.dnc.mapper.PermissionStreamNewMapper;
import org.jeecg.modules.dnc.service.IPermissionStreamNewService;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

@Service
public class PermissionStreamNewServiceImpl extends ServiceImpl<PermissionStreamNewMapper, PermissionStreamNew> implements IPermissionStreamNewService {
    @Autowired
    private ISysUserService sysUserService;

    /**
     * 根据用户id获取结构树权限
     * @param userId
     * @return
     */
    @Override
    public List<ProductMix> loadProductMix(String userId,List<String> productIdList){
        return baseMapper.loadProductMix(userId,productIdList);
    }

    /**
     * 根据用户id、部门列表、id、业务类型获取对应结构树权限
     * @param userId
     * @param productIdList
     * @param businessId
     * @param businessType
     * @return
     */
    @Override
    public List<ProductMix> loadProductMixByBusinessIdAndBusinessType(String userId,List<String> productIdList,
                                                String businessId,String businessType){
        return baseMapper.loadProductMixByBusinessId(userId,productIdList,businessId,businessType);
    }

    /**
     * 管理员获取所有权限
     * @return
     */
    @Override
    public List<ProductMix> loadProductMixAll(String userId){
        return baseMapper.loadProductMixAll(userId);
    }

    /**
     * 通过业务id和业务类型获取权限
     * @param businessId
     * @param businessType
     * @return
     */
    @Override
    public  List<PermissionStreamNew> loadPermissionStreamNewByBusinessId(String businessId,String businessType,String type){
        QueryWrapper<PermissionStreamNew> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(businessId),"business_id",businessId);
        queryWrapper.eq(StrUtil.isNotEmpty(businessType),"business_type",businessType);
        //用户权限，部门字段为空
        if("0".equals(type)) {
            queryWrapper.isNotNull("user_id");
        }else if("1".equals(type)){
            queryWrapper.isNull("user_id");
        }
        queryWrapper.eq("delete_flag",0);
        return baseMapper.selectList(queryWrapper);
    }

    /**
     * 通过业务id和用户id获取权限
     * @param businessId
     * @param userId
     * @return
     */
    @Override
    public PermissionStreamNew loadPermissionStreamNewByBusinessIdAndUserId(String businessId, String userId,String businessType){
        QueryWrapper<PermissionStreamNew> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(businessId),"business_id",businessId);
        queryWrapper.eq(StrUtil.isNotEmpty(userId),"user_id",userId);
        queryWrapper.eq(StrUtil.isNotEmpty(businessType),"business_type",businessType);
        queryWrapper.eq("delete_flag",0);
        queryWrapper.isNull("depart_id");
        return baseMapper.selectOne(queryWrapper);
    }

    /**
     * 通过业务id和业务类型和部门id获取部门权限
     * @param businessId
     * @param businessType
     * @param departId
     * @return
     */
    @Override
    public  PermissionStreamNew loadPermissionStreamNewByBusinessIdAndDepartId(String businessId, String departId,String businessType){
        QueryWrapper<PermissionStreamNew> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(businessId),"business_id",businessId);
        queryWrapper.eq(StrUtil.isNotEmpty(departId),"depart_id",departId);
        queryWrapper.eq(StrUtil.isNotEmpty(businessType),"business_type",businessType);
        queryWrapper.eq("delete_flag",0);
        queryWrapper.isNull("user_id");
        return baseMapper.selectOne(queryWrapper);
    }

    /**
     * 通过businessId获取权限
     * @param businessId
     * @return
     */
    @Override
    public List<PermissionStreamNew> loadProductMixByBusinessId(String businessId,String businessType){
        QueryWrapper<PermissionStreamNew> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(businessId),"business_id",businessId);
        queryWrapper.eq(StrUtil.isNotEmpty(businessType),"business_type",businessType);
        queryWrapper.eq("delete_flag",0);
        return baseMapper.selectList(queryWrapper);
    }

    /**
     * 通过业务id与类型删除权限
     * @param businessId
     * @param businessType
     * @param type 0：用户权限，1：部门权限
     * @return
     */
    @Override
    public boolean deletePermissionStreamNewByBusinessId(String businessId,String businessType,String type){
        QueryWrapper<PermissionStreamNew> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(businessId),"business_id",businessId);
        queryWrapper.eq(StrUtil.isNotEmpty(businessType),"business_type",businessType);
        //用户权限，部门字段为空
        if("0".equals(type)){
            queryWrapper.isNotNull("user_id");
            queryWrapper.isNull("depart_id");
        }else if("1".equals(type)){
            queryWrapper.isNull("user_id");
            queryWrapper.isNotNull("depart_id");
        }
        queryWrapper.eq("delete_flag",0);
        return baseMapper.delete(queryWrapper)>0;
    }

    /**
     * 通过List<PermissionStreamNew>批量删除
     * @param permissionStreamNewList
     * @return
     */
    @Override
    public boolean deletePermissionStreamNewByList(List<PermissionStreamNew> permissionStreamNewList){
        if(permissionStreamNewList == null || permissionStreamNewList.isEmpty())
            return false;
        if(permissionStreamNewList.size() == 1) {
            return super.removeById(permissionStreamNewList.get(0).getId());
        }
        List<String> ids = new ArrayList<>();
        permissionStreamNewList.forEach(item -> {
            ids.add(item.getId());
        });
        if (ids.size()>1000) {
            List<List<String>> partition = ListUtils.partition(ids, 1000);
            for (List<String> partitionList : partition) {
                super.removeByIds(partitionList);
            }
        }else {
            super.removeByIds(ids);
        }
        return true;
    }

    /**
     * 通过一组业务id和用户id和类型查询
     * @param businessIds
     * @param userIds
     * @param businessType
     * @return
     */
    @Override
    public List<PermissionStreamNew> loadPermissionStreamNewByBusinessIdsAndUserIds(List<String> businessIds,List<String> userIds,String businessType){
        if(businessIds == null || businessIds.isEmpty() || userIds == null || userIds.isEmpty())
            return null;
        List<PermissionStreamNew> total = new ArrayList<>();
        List<List<String>> compListArr;
        List<List<String>> userIdsArr;
        if(businessIds.size() > 1000){
            compListArr = ListUtils.partition(businessIds, 100);
        }else {
            compListArr = ListUtils.partition(businessIds, 1000);
        }
        if(userIds.size() > 1000){
            userIdsArr = ListUtils.partition(userIds, 100);
        }else {
            userIdsArr = ListUtils.partition(userIds, 1000);
        }
        for(List<String> compList : compListArr) {
            for(List<String> userIdList : userIdsArr){
                LambdaQueryWrapper<PermissionStreamNew> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(PermissionStreamNew::getBusinessId, compList);
                queryWrapper.in(PermissionStreamNew::getUserId, userIdList);
                queryWrapper.eq(PermissionStreamNew::getBusinessType, businessType);
                queryWrapper.isNull(PermissionStreamNew::getDepartId);
                queryWrapper.eq(PermissionStreamNew::getDeleteFlag,0);
                List<PermissionStreamNew> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }

    /**
     * 通过一组业务id和部门id和类型查询
     * @param businessIds
     * @param departIds
     * @param businessType
     * @return
     */
    @Override
    public List<PermissionStreamNew> loadPermissionStreamNewByBusinessIdsAndDepartIds(List<String> businessIds,List<String> departIds,String businessType){
        if(businessIds == null || businessIds.isEmpty() || departIds == null || departIds.isEmpty())
            return null;
        List<PermissionStreamNew> total = new ArrayList<>();
        List<List<String>> compListArr;
        List<List<String>> departListArr;
        if(businessIds.size() > 1000){
            compListArr = ListUtils.partition(businessIds, 100);
        }else {
            compListArr = ListUtils.partition(businessIds, 1000);
        }
        if(departIds.size() > 1000){
            departListArr = ListUtils.partition(departIds, 100);
        }else {
            departListArr = ListUtils.partition(departIds, 1000);
        }
        for(List<String> compList : compListArr) {
            for(List<String> departList : departListArr){
                LambdaQueryWrapper<PermissionStreamNew> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(PermissionStreamNew::getBusinessId, compList);
                queryWrapper.in(PermissionStreamNew::getDepartId, departList);
                queryWrapper.eq(PermissionStreamNew::getBusinessType, businessType);
                queryWrapper.isNull(PermissionStreamNew::getUserId);
                queryWrapper.eq(PermissionStreamNew::getDeleteFlag,0);
                List<PermissionStreamNew> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }

    /**
     * 通过添加权限
     * @param permissionStream
     * @return
     */
    @Override
    public boolean addPermissionStreamNew(PermissionStreamNew permissionStream) {
        // 验证参数有效性
        if (permissionStream == null) {
            return false;
        }
        // 获取管理员用户
        SysUser adminUser = sysUserService.getUserByName("admin");
        if (adminUser == null) {
            // 若管理员用户不存在，可根据实际情况处理，这里简单返回 false
            return false;
        }
        try {
            boolean isAdmin = Objects.equals(permissionStream.getUserId(), adminUser.getId());
            // 保存本身权限
            super.save(permissionStream);
            if (!isAdmin) {
                // 若不是管理员，复制一个新的 PermissionStreamNew 对象并设置为管理员 ID 后保存
                PermissionStreamNew adminPermissionStream = new PermissionStreamNew();
                adminPermissionStream.setUserId(adminUser.getId());
                adminPermissionStream.setBusinessId(permissionStream.getBusinessId());
                adminPermissionStream.setBusinessType(permissionStream.getBusinessType());
                super.save(adminPermissionStream);
            }
            return true;
        } catch (Exception e) {
            // 记录异常信息，方便后续排查问题
            e.printStackTrace();
            return false;
        }
    }

}