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.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import net.sf.saxon.expr.Component;
import org.jeecg.common.system.vo.SelectTreeModel;
import org.jeecg.modules.base.entity.Enterprise;
import org.jeecg.modules.base.mapper.EnterpriseMapper;
import org.jeecg.modules.base.service.IEnterpriseService;
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.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

/**
 * @Description: 企业架构
 * @Author: jeecg-boot
 * @Date:   2022-11-21
 * @Version: V1.0
 */
@Service
@Transactional
public class EnterpriseServiceImpl extends ServiceImpl<EnterpriseMapper, Enterprise> implements IEnterpriseService {

    @Autowired
    private  EnterpriseMapper enterpriseMapper;
    @Override
    public List<SelectTreeModel> getEnterpriseVersionTree(String pid,Integer version) {
       List<SelectTreeModel> list = baseMapper.getEnterpriseVersionTree(pid,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(getEnterpriseVersionTree(selectTreeModel.getKey(),version));
            }
        }
        return list;
    }

    @Override
    public Page<Map<String,Object>> getEnterpriseListByPid(Page<Map<String,Object>> page,Integer version,String parentId) {
        return page.setRecords(baseMapper.getEnterpriseListByIds(page,version,parentId));
    }

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

    @Override
    public Set<Integer> getAllVersion() {
        Set<Integer> set = new TreeSet<Integer>(Comparator.reverseOrder());
        set.addAll(enterpriseMapper.getAllVersion());
        return set;
    }
    @Override
    public Integer  getInitVersion() {
       List<Integer> usableVersionList = baseMapper.getUsableVersion();
       Set<Integer> allVersionList = getAllVersion();
       if(CollectionUtils.isNotEmpty(usableVersionList)){
           return usableVersionList.get(0);
       }else if(CollectionUtils.isNotEmpty(allVersionList)){
           return allVersionList.stream().findFirst().get();
       }
       return null;
    }

    @Override
    public List<Enterprise> getLastUsableList() {
        return baseMapper.getLastUsableList();
    }

    @Override
    public List<Enterprise> getUsableList() {
        return baseMapper.getUsableList();
    }

    @Override
    public Map<String, Object> getNowAndLastUsableVersion() {
        List<Enterprise> usableList = baseMapper.getUsableList();
        List<Enterprise> lastUsableList = baseMapper.getLastUsableList();
        Map<String,Object> map = new HashMap<>(2);
        if(CollectionUtils.isNotEmpty(usableList)){
            map.put("usableVersion",usableList.get(0).getVersion());
        }
        if(CollectionUtils.isNotEmpty(lastUsableList)){
            map.put("lastUsableVersion",lastUsableList.get(0).getVersion());
        }
        return map;
    }

    @Override
    public List<String> getUsableIdList() {
        return enterpriseMapper.getUsableIdList();
    }

    public List<String> getAllChild(String parentId){
        List<String> list =enterpriseMapper.getAllChildrenIdByParentId(parentId);
        List<String> child = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(list)){
            list.forEach(str->{
                child.add(str);
                child.addAll(getAllChild(str));
            });
        }
        return child;
    }

}