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

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.common.system.vo.SelectTreeModel;
import org.jeecg.modules.base.entity.FactoryModel;
import org.jeecg.modules.base.entity.FactoryModelDetail;
import org.jeecg.modules.base.mapper.FactoryModelMapper;
import org.jeecg.modules.base.service.IFactoryModelService;
import org.jeecg.modules.system.entity.SysDepart;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * @Description: 工厂建模
 * @Author: jeecg-boot
 * @Date:   2022-11-08
 * @Version: V1.0
 */
@Service
@Transactional
public class FactoryModelServiceImpl extends ServiceImpl<FactoryModelMapper, FactoryModel> implements IFactoryModelService {
    @Autowired
    private FactoryModelMapper factoryModelMapper;

    @Override
    public List<SelectTreeModel> loadTree(String enterpriseId,Integer version) {
	    List<SelectTreeModel> list = baseMapper.loadTreeByEnterpriseIdAndVersion(enterpriseId,version).stream().sorted((e1,e2)->{
            Integer subfix1 = Integer.parseInt(e1.getValue().substring(e1.getValue().lastIndexOf(".")+1));
            Integer subfix2 = Integer.parseInt(e2.getValue().substring(e2.getValue().lastIndexOf(".")+1));
            return Integer.compare(subfix1,subfix2);
        }).collect(Collectors.toList());
	    if(CollectionUtils.isNotEmpty(list)){
	        for(SelectTreeModel selectTreeModel:list){
	            selectTreeModel.setChildren(loadTree(selectTreeModel.getKey(),version));
	        }
	    }
        return list;
    }

    @Override
    public Page<Map<String, Object>> getFactoryList(Page<Map<String,Object>> page,
                                                    Integer version,
                                                    String parentId,
                                                    List<String> ids
                                                    ) {
//        List<String> list = getAllChild(parentId);
//        list.add("-1");
        return page.setRecords(baseMapper.getFactoryList(page,version,parentId,ids));
    }

    @Override
    public List<SysDepart> getDepartList() {
        return baseMapper.getDepartList();
    }

    @Override//根据用户id查企业id
    public String getEidByUid(String uid) {
        return baseMapper.selectEnterpriseIdByUid(uid);
    }

    @Override
    public List<FactoryModelDetail> getListByEid(String eid) {
        return baseMapper.getListByEid(eid);
    }

    @Override
    public Set<Integer> getVersionList() {
        Set<Integer> set = new TreeSet<Integer>(Comparator.reverseOrder());
        set.addAll(baseMapper.getAllVersion());
        return set;
    }
    @Override
    public List<FactoryModel> getLastUsableList(List<String> parentIds) {
        return baseMapper.getLastUsableList(parentIds);
    }

    @Override
    public List<FactoryModel> getUsableList(List<String> parentIds) {
        return baseMapper.getUsableList(parentIds);
    }

    @Override
    public Map<String, Object> getNowAndLastUsableVersion() {
        List<Integer> usableList = baseMapper.getUsableVersion();
        List<Integer> lastUsableList = baseMapper.getLastUsableVersion();
        Map<String,Object> map = new HashMap<>(2);
        if(CollectionUtils.isNotEmpty(usableList)){
            map.put("usableVersion",usableList.get(0));
        }
        if(CollectionUtils.isNotEmpty(lastUsableList)){
            map.put("lastUsableVersion",lastUsableList.get(0));
        }
        return map;
    }
    @Override
    public Integer getInitVersion() {
        List<Integer> usableVersionList = baseMapper.getUsableVersion();
        Set<Integer> allVersionList = getVersionList();
        if(CollectionUtils.isNotEmpty(usableVersionList)){
            return usableVersionList.get(0);
        }else if(CollectionUtils.isNotEmpty(allVersionList)){
            return allVersionList.stream().findFirst().get();
        }
        return null;
    }
    public List<String> getAllChild(String parentId){
        List<String> list = baseMapper.getAllChildrenIdByParentId(parentId);
        List<String> child = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(list)){
            list.forEach(str->{
                child.add(str);
                child.addAll(getAllChild(str));
            });
        }
        return child;
    }
    @Override
    public List<FactoryModel> getAllDepartByPid(Integer version) {
        return baseMapper.selectList(new QueryWrapper<FactoryModel>()
                .eq("version",version)
                .eq("del_flag",0));
    }

    @Override
    public List<String> getVersionStatusByVersion(Integer version) {
        return baseMapper.getVersionStatusByVersion(version);
    }

    @Override
    public List<Map<String,Object>>  getUsableWorkShopList() {
        return baseMapper.getUsableWorkShopList();
    }

    @Override
    public List<Integer> getUsableVersion() {
        return baseMapper.getUsableVersion();
    }
}