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

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
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.BaseFactory;
import org.jeecg.modules.system.entity.BaseFactoryUser;
import org.jeecg.modules.system.mapper.BaseFactoryMapper;
import org.jeecg.modules.system.mapper.BaseFactoryUserMapper;
import org.jeecg.modules.system.model.EamBaseFactoryIdModel;
import org.jeecg.modules.system.model.EamBaseFactoryTreeModel;
import org.jeecg.modules.system.service.IBaseFactoryService;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.util.FindsBaseFactorysChildrenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * @Description: 设备车间管理
 * @Author: jeecg-boot
 * @Date:   2025-06-30
 * @Version: V1.0
 */
@Service("BaseFactoryServiceImpl")
public class BaseFactoryServiceImpl extends ServiceImpl<BaseFactoryMapper, BaseFactory> implements IBaseFactoryService {

    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private BaseFactoryUserMapper BaseFactoryUserMapper;

    /**
     * queryTreeList 对应 queryTreeList 查询所有的设备车间管理数据,以树结构形式响应给前端
     */
    @Override
    public List<EamBaseFactoryTreeModel> queryTreeList() {
        LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<BaseFactory>();
        query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.orderByAsc(BaseFactory::getSorter);
        List<BaseFactory> list = this.list(query);
        //设置用户id，让前台显示
        this.setUserIdsByProList(list);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsBaseFactorysChildrenUtil.wrapTreeDataToTreeList(list);
    }

    /**
     * queryTreeList 根据设备车间管理id查询,前端回显调用
     */
    @Override
    public List<EamBaseFactoryTreeModel> queryTreeList(String ids) {
        List<EamBaseFactoryTreeModel> listResult = new ArrayList<>();
        LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<BaseFactory>();
        query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        if (oConvertUtils.isNotEmpty(ids)) {
            query.in(true, BaseFactory::getId, ids.split(","));
        }
        query.orderByAsc(BaseFactory::getSorter);
        List<BaseFactory> list = this.list(query);
        for (BaseFactory production : list) {
            if (production.getRemark().isEmpty()){
                production.setRemark("");
            }
            listResult.add(new EamBaseFactoryTreeModel(production));
        }
        return listResult;
    }

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

    /**
     * saveProductionData 对应 add 保存用户在页面添加的新的设备车间管理对象数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveBaseFactoryData(BaseFactory BaseFactory) {
        if (BaseFactory != null) {
            if (BaseFactory.getParentId() == null|| StrUtil.isEmpty(BaseFactory.getParentId())) {
                BaseFactory.setParentId("");
                BaseFactory.setFactoryCategory("0");
            }
            if (BaseFactory.getFactoryCategory() == null|| StrUtil.isEmpty(BaseFactory.getFactoryCategory())) {
                BaseFactory.setFactoryCategory("1");
            }
            BaseFactory.setId(IdWorker.getIdStr(BaseFactory));
            // 先判断该对象有无父级ID,有则意味着不是最高级,否则意味着是最高级
            // 获取父级ID
            String parentId = BaseFactory.getParentId();
            JSONObject formData = new JSONObject();
            formData.put("parentId",parentId);
            String[] codeArray = (String[]) FillRuleUtil.executeRule(FillRuleConstant.WORKSHOP,formData);
            BaseFactory.setOrgCode(codeArray[0]);
            String orgType = codeArray[1];
            BaseFactory.setOrgType(String.valueOf(orgType));
            BaseFactory.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
            this.save(BaseFactory);
        }
    }

    @Override
    public List<EamBaseFactoryIdModel> queryProductionIdTreeList() {
        LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
        query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.orderByAsc(BaseFactory::getSorter);
        List<BaseFactory> list = this.list(query);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsBaseFactorysChildrenUtil.wrapTreeDataToProductionIdTreeList(list);
    }


    /**
     * updateProductionDataById 对应 edit 根据设备车间管理主键来更新对应的设备车间管理数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateBaseFactoryDataById(BaseFactory BaseFactory) {
        if (BaseFactory != null) {
            this.updateById(BaseFactory);
            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删除用户与设备车间管理关系
        BaseFactoryUserMapper.delete(new LambdaQueryWrapper<BaseFactoryUser>().in(BaseFactoryUser::getFactoryId, 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删除用户与设备车间管理关系
        BaseFactoryUserMapper.delete(new LambdaQueryWrapper<BaseFactoryUser>().in(BaseFactoryUser::getFactoryId, idList));
    }

    /**
     * 通过设备车间管理集合为设备车间管理设置用户id，用于前台展示
     */
    private void setUserIdsByProList(List<BaseFactory> productionList) {
        //查询负责部门不为空的情况
        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 productionIds = user.getProductionIds();
            if (StringUtils.isNotBlank(productionIds)) {
                String[] productionIdArray = productionIds.split(",");
                for (String productionId : productionIdArray) {
                    if (map.containsKey(productionId)) {
                        String userIds = map.get(productionId) + "," + user.getId();
                        map.put(productionId, userIds);
                    } else {
                        map.put(productionId, user.getId());
                    }
                }
            }
        }
    }

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