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

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.FillRuleConstant;
import org.jeecg.common.util.FillRuleUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.EamBaseRepairDepart;
import org.jeecg.modules.system.entity.EamBaseRepairDepartUser;
import org.jeecg.modules.system.mapper.EamBaseRepairDepartMapper;
import org.jeecg.modules.system.mapper.EamBaseRepairDepartUserMapper;
import org.jeecg.modules.system.service.IEamBaseRepairDepartService;
import org.jeecg.modules.system.model.EamBaseRepairDepartTreeModel;
import org.jeecg.modules.system.model.RepairDepartIdModel;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.util.FindsRepairDepartsChildrenUtil;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author: Lius
 * @CreateTime: 2025-07-01
 * @Description:
 */
@Service
public class EamBaseRepairDepartImpl extends ServiceImpl<EamBaseRepairDepartMapper, EamBaseRepairDepart> implements IEamBaseRepairDepartService {

    @Resource
    private SysUserMapper sysUserMapper;

    @Resource
    private EamBaseRepairDepartUserMapper repairDepartUserMapper;

    /**
     * queryTreeList 对应 queryTreeList 查询所有的维修部门班组数据,以树结构形式响应给前端
     */
    @Override
    @Cacheable(value = "eam:cache:repairDepart:alldata")
    public List<EamBaseRepairDepartTreeModel> queryTreeList() {
        LambdaQueryWrapper<EamBaseRepairDepart> query = new LambdaQueryWrapper<EamBaseRepairDepart>();
        query.eq(EamBaseRepairDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.orderByAsc(EamBaseRepairDepart::getDepartOrder);
        List<EamBaseRepairDepart> list = this.list(query);
        //设置用户id，让前台显示
        this.setUserIdsByProList(list);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsRepairDepartsChildrenUtil.wrapTreeDataToTreeList(list);
    }

    /**
     * queryTreeList 根据维修部门班组id查询,前端回显调用
     */
    @Override
    public List<EamBaseRepairDepartTreeModel> queryTreeList(String ids) {
        List<EamBaseRepairDepartTreeModel> listResult = new ArrayList<>();
        LambdaQueryWrapper<EamBaseRepairDepart> query = new LambdaQueryWrapper<EamBaseRepairDepart>();
        query.eq(EamBaseRepairDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        if (oConvertUtils.isNotEmpty(ids)) {
            query.in(true, EamBaseRepairDepart::getId, ids.split(","));
        }
        query.orderByAsc(EamBaseRepairDepart::getDepartOrder);
        List<EamBaseRepairDepart> list = this.list(query);
        for (EamBaseRepairDepart repairDepart : list) {
            listResult.add(new EamBaseRepairDepartTreeModel(repairDepart));
        }
        return listResult;
    }

    @Override
    @Cacheable(value = "eam:cache:repairDepart:allids")
    public List<RepairDepartIdModel> queryMaintainDepartIdTreeList() {
        LambdaQueryWrapper<EamBaseRepairDepart> query = new LambdaQueryWrapper<>();
        query.eq(EamBaseRepairDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.orderByAsc(EamBaseRepairDepart::getDepartOrder);
        List<EamBaseRepairDepart> list = this.list(query);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsRepairDepartsChildrenUtil.wrapTreeDataToMaintainDepartIdTreeList(list);
    }

    /**
     * 根据关键字搜索相关的部门数据
     */
    @Override
    public List<EamBaseRepairDepartTreeModel> searchByKeyWord(String keyWord) {
        LambdaQueryWrapper<EamBaseRepairDepart> query = new LambdaQueryWrapper<>();
        List<EamBaseRepairDepartTreeModel> newList = new ArrayList<>();
        query.like(EamBaseRepairDepart::getDepartName, keyWord);
        EamBaseRepairDepartTreeModel model = new EamBaseRepairDepartTreeModel();
        List<EamBaseRepairDepart> repairDepartList = this.list(query);
        if (!repairDepartList.isEmpty()) {
            for (EamBaseRepairDepart eamBaseRepairDepart : repairDepartList) {
                model = new EamBaseRepairDepartTreeModel(eamBaseRepairDepart);
                model.setChildren(null);
                newList.add(model);
            }
            return newList;
        }
        return Collections.emptyList();
    }

    /**
     * saveMaintainDepartData 对应 add 保存用户在页面添加的新的维修部门班组对象数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveMaintainDepartData(EamBaseRepairDepart eamBaseRepairDepart) {
        if (eamBaseRepairDepart != null) {
            if (eamBaseRepairDepart.getParentId() == null) {
                eamBaseRepairDepart.setParentId("");
            }
            eamBaseRepairDepart.setId(IdWorker.getIdStr(eamBaseRepairDepart));
            // 先判断该对象有无父级ID,有则意味着不是最高级,否则意味着是最高级
            // 获取父级ID
            String parentId = eamBaseRepairDepart.getParentId();
            JSONObject formData = new JSONObject();
            formData.put("parentId",parentId);
            String[] codeArray = (String[]) FillRuleUtil.executeRule(FillRuleConstant.REPAIRDEPART,formData);
            eamBaseRepairDepart.setOrgCode(codeArray[0]);
            String orgType = codeArray[1];
            eamBaseRepairDepart.setOrgType(String.valueOf(orgType));
            eamBaseRepairDepart.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
            this.save(eamBaseRepairDepart);
        }
    }

    /**
     * updateMaintainDepartDataById 对应 edit 根据维修部门班组主键来更新对应的维修部门班组数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateMaintainDepartDataById(EamBaseRepairDepart eamBaseRepairDepart) {
        if (eamBaseRepairDepart != null) {
            this.updateById(eamBaseRepairDepart);
            return true;
        }
        return false;
    }

    /**
     * 根据维修部门班组id删除并删除其可能存在的子级维修部门班组
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delete(String id) {
        List<String> idList = new ArrayList<>();
        idList.add(id);
        this.checkChildrenExists(id, idList);
        boolean result = this.removeByIds(idList);
        //根据维修部门班组id删除用户与维修部门班组关系
        repairDepartUserMapper.delete(new LambdaQueryWrapper<EamBaseRepairDepartUser>().in(EamBaseRepairDepartUser::getDepartId, idList));
        //根据维修部门班组id删除维修部门班组与设备关系
//        repairDepartEquipmentMapper.delete(new LambdaQueryWrapper<SysMaintainDepartEquipment>().in(SysMaintainDepartEquipment::getMaintainDepartId, idList));
        return result;
    }

    /**
     * 根据维修部门班组id批量删除并删除其可能存在的子级维修部门班组
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteBatchWithChildren(List<String> ids) {
        List<String> idList = new ArrayList<>();
        for (String id : ids) {
            idList.add(id);
            this.checkChildrenExists(id, idList);
        }
        this.removeByIds(idList);
        //根据维修部门班组id删除用户与维修部门班组关系
        repairDepartUserMapper.delete(new LambdaQueryWrapper<EamBaseRepairDepartUser>().in(EamBaseRepairDepartUser::getDepartId, idList));
        //根据维修部门班组id删除维修部门班组与设备关系
//        repairDepartEquipmentMapper.delete(new LambdaQueryWrapper<SysMaintainDepartEquipment>().in(SysMaintainDepartEquipment::getMaintainDepartId, idList));
    }

//    /**
//     * 根据id查询下级维修部门班组
//     */
//    @Override
//    public List<EamBaseRepairDepart> queryRepDepByPid(String pid) {
//        return this.baseMapper.queryRepDepByPid(pid);
//    }
//
    /**
     * 根据用户id获取维修部门班组下拉树选项
     */
    @Override
    public List<RepairDepartIdModel> loadMaintainDepartTreeOptions(String userId) {
        //获取所有维修部门班组数据
        List<EamBaseRepairDepart> repairDepartList = this.baseMapper.selectList(new LambdaQueryWrapper<EamBaseRepairDepart>().eq(EamBaseRepairDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).orderByAsc(EamBaseRepairDepart::getDepartOrder));
        //根据用户id获取拥有的维修部门班组信息集合
        List<String> repairDepartIds = repairDepartUserMapper.queryRepairDepartIdsByUserId(userId);
        List<String> allMaintainDepartIds = new ArrayList<>();
        //找到所有维修部门班组id的上级id
        if (repairDepartIds != null && !repairDepartIds.isEmpty()) {
            for (String repairDepartId : repairDepartIds) {
                this.getAllMaintainDepartIds(repairDepartList, repairDepartId, allMaintainDepartIds);
            }
        }
        //过滤维修部门班组数据
        List<EamBaseRepairDepart> list = repairDepartList.stream().filter((EamBaseRepairDepart eamBaseRepairDepart) -> allMaintainDepartIds.contains(eamBaseRepairDepart.getId())).collect(Collectors.toList());
        return FindsRepairDepartsChildrenUtil.wrapTreeDataToMaintainDepartIdTreeList(list);
    }
//
//    /**
//     * 递归查询所有子节点id
//     */
//    @Override
//    public List<String> recursionChildren(String repairDepartId) {
//        return this.baseMapper.recursionChildren(repairDepartId);
//    }
//
//    /**
//     * 根据用户id和车间id获取用户拥有的车间id
//     * @param userId
//     * @param repairDepartId
//     * @return
//     */
//    @Override
//    public String findFirstMaintainDepart(String userId, String repairDepartId) {
//        return this.baseMapper.findFirstMaintain(userId, repairDepartId);
//    }
//
//    /**
//     * 根据用户id查询用户维修部门班组权限
//     */
//    @Override
//    public String findThreeMaintainDepartId(String userId) {
//        return this.baseMapper.findThreeMaintainId(userId);
//    }
//
//    @Override
//    public EamBaseRepairDepart findMaintainDepartList(String equipmentId) {
//        return this.baseMapper.findMaintainList(equipmentId);
//    }

    /**
     * delete 方法调用 递归查找子集id
     */
    private void checkChildrenExists(String id, List<String> idList) {
        LambdaQueryWrapper<EamBaseRepairDepart> query = new LambdaQueryWrapper<>();
        query.eq(EamBaseRepairDepart::getParentId, id);
        List<EamBaseRepairDepart> repairDepartList = this.list(query);
        if (repairDepartList != null && !repairDepartList.isEmpty()) {
            for (EamBaseRepairDepart repairDepart : repairDepartList) {
                idList.add(repairDepart.getId());
                this.checkChildrenExists(repairDepart.getId(), idList);
            }
        }
    }

    /**
     * 获取所有的维修部门班组id（包含所有上级）
     */
    private void getAllMaintainDepartIds(List<EamBaseRepairDepart> repairDepartList, String repairDepartId, List<String> allMaintainDepartIds) {
        if (!allMaintainDepartIds.contains(repairDepartId)) {
            allMaintainDepartIds.add(repairDepartId);
        }
        for (EamBaseRepairDepart eamBaseRepairDepart : repairDepartList) {
            if (StringUtils.isEmpty(eamBaseRepairDepart.getParentId())) {
                continue;
            }
            if (repairDepartId.equals(eamBaseRepairDepart.getId())) {
                if (!allMaintainDepartIds.contains(eamBaseRepairDepart.getParentId())) {
                    allMaintainDepartIds.add(eamBaseRepairDepart.getParentId());
                    getAllMaintainDepartIds(repairDepartList, eamBaseRepairDepart.getParentId(), allMaintainDepartIds);
                }
            }
        }
    }

    /**
     * 通过维修部门班组集合为维修部门班组设置用户id，用于前台展示
     */
    private void setUserIdsByProList(List<EamBaseRepairDepart> repairDepartList) {
        //查询负责部门不为空的情况
        LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
        query.isNotNull(SysUser::getDepartIds);
        List<SysUser> users = sysUserMapper.selectList(query);
        Map<String, Object> map = new HashMap(5);
        //先循环一遍找到不同的负责维修部门班组id
        for (SysUser user : users) {
            String repairDepartIds = user.getRepairDepartIds();
            if (StringUtils.isNotBlank(repairDepartIds)) {
                String[] repairDepartIdArray = repairDepartIds.split(",");
                for (String repairDepartId : repairDepartIdArray) {
                    if (map.containsKey(repairDepartId)) {
                        String userIds = map.get(repairDepartId) + "," + user.getId();
                        map.put(repairDepartId, userIds);
                    } else {
                        map.put(repairDepartId, user.getId());
                    }
                }
            }
        }
        //循环维修部门班组集合找到维修部门班组id对应的负责用户
        for (EamBaseRepairDepart eamBaseRepairDepart : repairDepartList) {
            if (map.containsKey(eamBaseRepairDepart.getId())) {
                eamBaseRepairDepart.setDirectorUserIds(map.get(eamBaseRepairDepart.getId()).toString());
            }
        }
    }

    /**
     * 根据关键字获取中心数据
     */
    @Override
    public EamBaseRepairDepart searchCenterByKeyWord(String keyWord) {
        if (StringUtils.isBlank(keyWord)) {
            return null;
        }
        // 先按名称查询
        LambdaQueryWrapper<EamBaseRepairDepart> query = new LambdaQueryWrapper<>();
        query.eq(EamBaseRepairDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.eq(EamBaseRepairDepart::getDepartName, keyWord);
        EamBaseRepairDepart result = this.baseMapper.selectOne(query);
        if (result != null) {
            return result;
        }

        // 再按编码查询
        query = new LambdaQueryWrapper<>();
        query.eq(EamBaseRepairDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.eq(EamBaseRepairDepart::getDepartCode, keyWord);
        return this.baseMapper.selectOne(query);
    }

}