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

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.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.dnc.entity.DevicePermission;
import org.jeecg.modules.dnc.mapper.DevicePermissionMapper;
import org.jeecg.modules.dnc.service.IDevicePermissionService;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.mdc.entity.MdcEquipment;
import org.jeecg.modules.mdc.mapper.MdcEquipmentMapper;
import org.jeecg.modules.mdc.model.MdcEquipmentTree;
import org.jeecg.modules.mdc.util.FindsEquipmentProductionUtil;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.jeecg.modules.system.service.IMdcUserProductionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Service
public class DevicePermissionServiceImpl extends ServiceImpl<DevicePermissionMapper, DevicePermission> implements IDevicePermissionService {
    @Resource
    private IMdcProductionService mdcProductionService;
    @Resource
    private IMdcUserProductionService mdcUserProductionService;
    @Resource
    private MdcEquipmentMapper mdcEquipmentMapper;
    @Resource
    private ISysUserService sysUserService;

    @Override
    public DevicePermission getByUserIdAndDeviceId(String userId, String deviceId) {
        if(!ValidateUtil.validateString(userId) || !ValidateUtil.validateString(deviceId))
            return null;
        List<DevicePermission> list = super.lambdaQuery().eq(DevicePermission::getDeviceId, deviceId).eq(DevicePermission::getUserId, userId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public List<UserDepartExt> getUserPermsByDeviceId(String deviceId) {
        return super.getBaseMapper().getUserPermsByDeviceId(deviceId);
    }

    @Override
    public List<SysUser> getUserNonPermsByDeviceId(String deviceId) {
        return super.getBaseMapper().getUserNonPermsByDeviceId(deviceId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean removeByCollection(List<DevicePermission> devicePermissions) {
        if(devicePermissions == null || devicePermissions.isEmpty())
            return false;
        if(devicePermissions.size() == 1)
            return super.removeById(devicePermissions.get(0).getDevicePermId());
        List<String> ids = new ArrayList<>();
        devicePermissions.forEach(item -> {
            ids.add(item.getDevicePermId());
        });
        return super.removeByIds(ids);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByDeviceId(String deviceId) {
        LambdaQueryWrapper<DevicePermission> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(DevicePermission::getDeviceId, deviceId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    public List<DevicePermission> getByDeviceId(String deviceId) {
        List<DevicePermission> list = super.lambdaQuery().eq(DevicePermission::getDeviceId, deviceId).list();
        if(list == null)
            list = Collections.emptyList();
        return list;
    }


    /**
     * * 加载产线设备树
     */
    @Override
    public List<MdcEquipmentTree> DncLoadTreeListByProduction() {
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // 获取所有有效产线并建立快速查询映射
        Map<String, MdcProduction> productionMap = getValidProductions();

        // 获取用户权限相关的所有产线ID（包含层级祖先）
        Set<String> authorizedProductionIds = getAuthorizedProductionIds(user.getId(), productionMap);

        // 构建产线树结构
        List<MdcEquipmentTree> treeList = buildProductionTree(new ArrayList<>(authorizedProductionIds), productionMap);

        // 批量填充设备数据
        fillEquipmentData(treeList, user);

        return treeList;
    }

    /**
     * 获取所有有效产线并建立ID映射
    */
    private Map<String, MdcProduction> getValidProductions() {
        List<MdcProduction> productions = mdcProductionService.list(
                new LambdaQueryWrapper<MdcProduction>()
                        .eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0)
                        .orderByAsc(MdcProduction::getProductionOrder)
        );
        return productions.stream().collect(Collectors.toMap(MdcProduction::getId, Function.identity()));
    }

    /**
     * 获取用户权限相关的所有产线ID（包含层级祖先）
    */
    private Set<String> getAuthorizedProductionIds(String userId, Map<String, MdcProduction> productionMap) {
        Set<String> result = new HashSet<>();

        // 获取直接关联的产线ID
        List<String> directProductionIds = Optional.ofNullable(mdcUserProductionService.queryProductionIdsByUserId(userId))
                .orElse(Collections.emptyList());

        // 递归收集所有层级ID
        directProductionIds.forEach(id -> collectHierarchyIds(id, productionMap, result));

        return result;
    }

    /**
    * 递归收集层级ID（包含自身及所有祖先）
    */
    private void collectHierarchyIds(String productionId, Map<String, MdcProduction> productionMap, Set<String> collector) {
        if (collector.contains(productionId)) return;

        MdcProduction current = productionMap.get(productionId);
        if (current == null) return;

        collector.add(productionId);
        if (StringUtils.isNotBlank(current.getParentId())) {
            collectHierarchyIds(current.getParentId(), productionMap, collector);
        }
    }

    /**
     构建产线树结构
    */
    private List<MdcEquipmentTree> buildProductionTree(List<String> productionIds, Map<String, MdcProduction> productionMap) {
        List<MdcProduction> filteredProductions = new ArrayList<>();
        productionIds.forEach(id -> {
            MdcProduction production = productionMap.get(id);
            if (production != null) {
                filteredProductions.add(production);
            }
        });
        // 按创建时间升序排序（空值排在最后）
        filteredProductions.sort(
                Comparator.comparing(
                        MdcProduction::getCreateTime,
                        Comparator.nullsLast(Comparator.naturalOrder()) // 自然顺序即升序
                )
        );
        return FindsEquipmentProductionUtil.wrapEquipmentProductionTreeList(filteredProductions);
    }
    /**
    * 批量填充设备数据
    */
    private void fillEquipmentData(List<MdcEquipmentTree> treeList, LoginUser user) {
        // 获取用户设备权限
        Set<String> deviceIds = getAuthorizedDeviceIds(user.getId());
        if (deviceIds.isEmpty()) return;

        // 批量获取所有相关设备
        Map<String, List<MdcEquipment>> equipmentMap = getEquipmentMap(user, deviceIds);

        // 批量获取用户信息
        Map<String, String> userRealNameMap = getUserRealNameMapping(equipmentMap.values());

        // 填充设备数据到树节点
        populateEquipmentNodes(treeList, equipmentMap, userRealNameMap);
    }

/**
        * 获取授权设备ID集合
 */
    private Set<String> getAuthorizedDeviceIds(String userId) {
        return super.list(new QueryWrapper<DevicePermission>().select("device_id").eq("user_id", userId))
                .stream()
                .map(DevicePermission::getDeviceId)
                .collect(Collectors.toSet());
    }

    /**
     * 批量获取设备数据并按产线分组
    */
    private Map<String, List<MdcEquipment>> getEquipmentMap(LoginUser user, Set<String> deviceIds) {
        List<String> productionIds=Arrays.asList(user.getProductionIds().split(","));
        return mdcEquipmentMapper.queryByDepartIdsAndType(productionIds, new ArrayList<>(deviceIds))
                .stream()
                .collect(Collectors.groupingBy(MdcEquipment::getProductionId));
    }


    /*** 批量获取用户真实姓名映射
    */
    private Map<String, String> getUserRealNameMapping(Collection<List<MdcEquipment>> equipmentLists) {
        Set<String> userNames = equipmentLists.stream()
                .flatMap(List::stream)
                .flatMap(e -> Stream.of(e.getCreateBy(), e.getUpdateBy()))
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toSet());

        return sysUserService.getUserRealNamesByUserNames(new ArrayList<>(userNames));
    }

    /**
     * 填充设备节点数据
    */
    private void populateEquipmentNodes(List<MdcEquipmentTree> nodes,
                                        Map<String, List<MdcEquipment>> equipmentMap,
                                        Map<String, String> userRealNameMap) {
        for (MdcEquipmentTree node : nodes) {
            if (!isProductionNode(node)) continue;

            List<MdcEquipment> equipments = equipmentMap.getOrDefault(node.getKey(), Collections.emptyList());
            List<MdcEquipmentTree> equipmentNodes = convertToEquipmentNodes(equipments, userRealNameMap, node.getKey());

            node.getChildren().addAll(equipmentNodes);
            node.setLeaf(equipmentNodes.isEmpty());

            // 递归处理子节点
            populateEquipmentNodes(node.getChildren(), equipmentMap, userRealNameMap);
        }
    }

/**
        * 转换设备数据为树节点
 */
    private List<MdcEquipmentTree> convertToEquipmentNodes(List<MdcEquipment> equipments,
                                                           Map<String, String> userRealNameMap,
                                                           String parentId) {
        return equipments.stream().map(e -> {
            // 更新用户显示名称
            Optional.ofNullable(e.getCreateBy()).ifPresent(name ->
                    e.setCreateBy(userRealNameMap.getOrDefault(name, name)));
            Optional.ofNullable(e.getUpdateBy()).ifPresent(name ->
                    e.setUpdateBy(userRealNameMap.getOrDefault(name, name)));

            MdcEquipmentTree node = new MdcEquipmentTree().convert(e);
            node.setParentId(parentId);
            node.setEntity(e);
            node.setType(2); // 设备节点类型
            return node;
        }).collect(Collectors.toList());
    }

/**
        * 判断是否为产线节点（根据业务逻辑定义）
            */
    private boolean isProductionNode(MdcEquipmentTree node) {
        return node.getType() == 1; // 假设类型1表示产线节点
    }

}