package org.jeecg.modules.project.controller;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.feign.WeeklyClient;
import org.jeecg.modules.feign.model.WekRecord;
import org.jeecg.modules.project.entity.ProProject;
import org.jeecg.modules.project.entity.ProProjectLink;
import org.jeecg.modules.project.entity.ProProjectLinkTree;
import org.jeecg.modules.project.entity.ProSummary;
import org.jeecg.modules.project.service.IProProjectLinkService;
import org.jeecg.modules.project.service.IProProjectService;
import org.jeecg.modules.project.service.IProSummaryService;
import org.jeecg.modules.project.vo.ProjectVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

@Slf4j
@Api(tags = "总看板")
@RestController
@RequestMapping("/pro/project")
public class BulletinBoardController {
    @Autowired
    private IProProjectService proProjectService;
    @Autowired
    private IProProjectLinkService proLinkService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private WeeklyClient weeklyClient;
    @Autowired
    private IProSummaryService summaryService;


    @ApiOperation(value = "总看板", notes = "总看板")
    @RequestMapping(value = "/main", method = RequestMethod.GET)
    public Result<Map<String, Object>> generalBulletinBoard(ProProject project, HttpServletRequest req) {

        Map<String, Object> res = new HashMap<>();
        QueryWrapper<ProProject> queryWrapper = QueryGenerator.initQueryWrapper(project, req.getParameterMap());
        //只查询最近三年数据
        int curYear = DateUtils.getCurYear();
        queryWrapper.between("ksrq", (curYear - 2) + "-01-01 00:00:00", curYear + "-12-31 23:59:59");
        Result<Map<String, Object>> result = new Result<>();
        //接口查询一次  组装成多个图表数据
        List<ProProject> list = proProjectService.list(queryWrapper);

        // 转化为Vo
        List<ProjectVo> listVo = coverToVo(list);

        //项目总数

        res.put("s1c1", getS1c1(listVo));
        res.put("s1c2", getS1c2(listVo));
        res.put("s1c3", getS1c3(listVo));
        res.put("s1c4", getS1c4(listVo));
        res.put("s2c1", getS2c1(listVo));
        res.put("s2c2", getS2c2(listVo));
        res.put("s2c3", getS2c3(listVo));
        res.put("s2c4", getS2c4(listVo));
        res.put("s2c5", getS2c5(listVo));
        res.put("s2c6", getS2c6(listVo));
        res.put("s2c7", getS2c7(listVo));
        res.put("s2c8", getS2c8(listVo));
        res.put("s2c31", getS2c31(listVo));
        // res.put("s3",getS3(listVo));

        res.put("s4c1", getS4(listVo));


        result.setResult(res);


        return result.success("查询成功~");
    }


    @GetMapping("/detail")
    public Result<ProProject> queryProById(@RequestParam("id") String id) {
        Result<ProProject> result = new Result<ProProject>();
        ProProject byId = proProjectService.getById(id);
        if(byId==null) return  result.error500("未查询匹配数据！");
        QueryWrapper<ProSummary> summaryQueryWrapper = new QueryWrapper<>();
        summaryQueryWrapper.lambda().eq(ProSummary::getPro,byId.getId());
        summaryQueryWrapper.lambda().inSql(ProSummary::getCreateTime,"SELECT MAX(create_time) FROM pro_summary WHERE pro  = "+byId.getId());
        ProSummary summary = summaryService.getOne(summaryQueryWrapper);
        byId.setSummary(summary);
        Map<String, Object> map = new HashMap<>();
        map.put("pro", id);
        List<ProProjectLink> linkList = proLinkService.listByMap(map);
        Collections.sort(linkList, new Comparator<ProProjectLink>() {
            @Override
            public int compare(ProProjectLink o1, ProProjectLink o2) {
                return o1.getSortNo().compareTo(o2.getSortNo());
            }
        });

        List<ProProjectLinkTree> res = new ArrayList<>();
        getTreeList(res, linkList, null);
        byId.setLinkListTree(res);
        result.setResult(byId);
        return result.success("查询成功");
    }

    private void getTreeList(List<ProProjectLinkTree> treeList, List<ProProjectLink> metaList, ProProjectLinkTree temp) {
        for (int i = 0 ; i<  metaList.size() ; i ++) {
            ProProjectLink permission = metaList.get(i);
            String tempPid = permission.getPid();
            ProProjectLinkTree tree = new ProProjectLinkTree(permission);
            if (temp == null && oConvertUtils.isEmpty(tempPid)) {
                treeList.add(tree);
                if (!tree.isLeaf()) {
                    getTreeList(treeList, metaList, tree);
                }
            } else if (temp != null && tempPid != null && tempPid.equals(temp.getId())) {
                temp.getChildren().add(tree);
                if (!tree.isLeaf()) {
                    getTreeList(treeList, metaList, tree);
                }
            }

        }
    }



    private Map<String, Object> getS1c3(List<ProjectVo> list) {
        //返回结果
        Map<String, Object> res = new HashMap<>();
        //部门信息
        Object o = redisUtil.get(CacheConstant.SYS_ORG_DEPART_CACHE);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());

        List<Map<String, Object>> data = new ArrayList<>();

        //提取项目id
        Map<String, String> proMap = list.stream().collect(Collectors.toMap(ProjectVo::getId, ProjectVo::getId));

        //周报列表
        List<WekRecord> wekRecords = weeklyClient.queryListByYear();
        //只需要查询项目中周报数据
        wekRecords =  wekRecords.stream().filter(i->proMap.containsKey(i.getXm())).collect(Collectors.toList());
        //数据列
        List<String> fields = new ArrayList<>();
        Map<String, Object> colorMap = new HashMap<>();
        //颜色
        String[] colors = {"#3561A7", "#80B2D3", "#2d5da9", "#D9F0F6"};
        //按年、部门分组
        Map<Integer, Map<String, List<WekRecord>>> collect = wekRecords.stream().filter(i -> i.getYear() != null && i.getSysOrgCode() != null).collect(Collectors.groupingBy(t -> t.getYear(), Collectors.groupingBy(t -> t.getSysOrgCode())));
        //空数据处理
        int year = DateUtils.getCurYear();
        for (int i = year - 2; i <= year; i++) {
            if (!collect.containsKey(i)) {
                Map<String, Object> item = new HashMap<>();
                item.put("year", i + "年");
                item.put("group", i + "");
                item.put("负荷", 0);
                item.put("上海兰浦", 0);
                data.add(item);

            }
        }

        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            item.put("year", k + "年");
            item.put("group", k + "");
            item.put("负荷", 80);
            AtomicReference<Double> total = new AtomicReference<>((double) 0);
            AtomicInteger index = new AtomicInteger();
            v.forEach((m, n) -> {
                Object dep = maps.get(m);
                if(dep==null) {
                    return ;
                }
                double sum = n.stream().filter(i -> i.getGs() != null).mapToDouble(t -> t.getGs()).sum();
                total.updateAndGet(v1 -> new Double((double) (v1 + sum)));
                item.put(dep.toString(), sum);
                index.getAndIncrement();
                colorMap.put(dep.toString(), colors[index.get() % 3]);
                if (!fields.toString().contains(dep.toString()))
                    fields.add(dep.toString());

            });
            item.put("total", total.get());
            data.add(item);
        });

        //按照年份排序
        data.sort((Map<String, Object> m, Map<String, Object> n) -> n.get("group").toString().compareTo(m.get("group").toString()));


        res.put("data", data);
        fields.add("负荷");
        colorMap.put("负荷", "#CB2920");
        res.put("fields", fields.toArray(new String[fields.size()]));
        res.put("colors", colorMap);
        return res;
    }

    private List<ProjectVo> coverToVo(List<ProProject> list) {


        List<ProjectVo> listVo = list.stream().map(e -> {
            ProjectVo p = new ProjectVo();
            BeanUtils.copyProperties(e, p);
            return p;
        }).collect(Collectors.toList());

        return listVo;
    }


    private void addUserName(List<ProjectVo> list) {

    }

    //项目总数
    private Map<String, Object> getS1c1(List<ProjectVo> list) {


        Map<String, Object> res = new HashMap<>();
        try {
            List<Map<String, Object>> data = new ArrayList<>();

            Object o = redisUtil.get(CacheConstant.SYS_DICT_CACHE_XMLX);
            if (o == null) return res;
            Map maps = (Map) JSON.parse(o.toString());


            //按照年份和项目类型分类
            Map<Object, Map<Object, List<Map<String, Object>>>> collect = list.stream()
                    .map(e -> {
                        Map<String, Object> map = new HashMap<>();
                        //没有类型的设置为 未分类
                        if (e.getXmlx() == null) {
                            map.put("xmlx", "未分类");
                        } else {
                            map.put("xmlx", maps.get(e.getXmlx()));
                        }
                        String y = DateUtils.date2Str(e.getKsrq(), DateUtils.date_year.get());
                        map.put("year", y);
                        return map;
                    })
                    .collect(Collectors.groupingBy(t -> t.get("year"), Collectors.groupingBy(t -> t.get("xmlx"))));
            //判断是否有三年数据，没有则加入空数据
            int year = DateUtils.getCurYear();
            if (!collect.containsKey(year)) {
                Map<String, Object> item = new HashMap<>();
                item.put("year", year + "年");
                item.put("xmlx", "未分类");
                item.put("total", 0);
                data.add(item);
            }

            if (!collect.containsKey(year - 1)) {
                Map<String, Object> item = new HashMap<>();
                item.put("year", year - 1 + "年");
                item.put("xmlx", "未分类");
                item.put("total", 0);
                data.add(item);
            }

            if (!collect.containsKey(year - 2)) {
                Map<String, Object> item = new HashMap<>();
                item.put("year", year - 2 + "年");
                item.put("xmlx", "未分类");
                item.put("total", 0);
                data.add(item);
            }


            //今年项目数
            AtomicInteger total = new AtomicInteger();
            //统计数据
            collect.forEach((k, v) -> {
                v.forEach((m, n) -> {
                    if (Integer.parseInt(k.toString()) == DateUtils.getCurYear()) {
                        total.addAndGet(n.size());
                    }
                    Map<String, Object> item = new HashMap<>();
                    item.put("year", k + "年");
                    item.put("xmlx", m);
                    item.put("total", n.size());
                    data.add(item);
                });
            });
            //按照年份排序
            data.sort((Map<String, Object> m, Map<String, Object> n) -> m.get("year").toString().compareTo(n.get("year").toString()));


            res.put("data", data);
            res.put("total", total.get());

        } catch (Exception e) {
            e.printStackTrace();
        }
        return res;

    }

    //已完成项目数
    private Map<String, Object> getS1c2(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();

        Object o = redisUtil.get(CacheConstant.SYS_DEPARTS_CACHE);
        if (o == null) {
            return res;
        }
        Map maps = (Map) JSON.parse(o.toString());

        //本年开始项目
        Map<String, List<ProjectVo>> sList = list.stream().filter(i -> i.getXmfzz() != null && i.getKsrq() != null && Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.groupingBy(t -> t.getXmfzz()));
        sList.forEach((k, v) -> {
            //如果没有部门名称跳出
            if (!maps.containsKey(k)) {
                return;
            }
            Map<String, Object> item = new HashMap<>();
            item.put("depart", maps.get(k));
            item.put("type", "启动项目数");
            item.put("value", v.size());
            data.add(item);
        });
        //没有启动项目，空数据
        if (sList == null || sList.size() < 1) {
            Map<String, Object> item = new HashMap<>();
            item.put("depart", "上海兰浦");
            item.put("type", "启动项目数");
            item.put("value", 0);
            data.add(item);
        }

        //完成项目数
        AtomicInteger finish = new AtomicInteger();

        //本年完成项目
        Map<String, List<ProjectVo>> oList = list.stream().filter(i -> i.getXmfzz() != null && i.getXmzt() != null && i.getXmzt() == 0 && i.getJsrq() != null && Integer.parseInt(DateUtils.date2Str(i.getJsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.groupingBy(t -> t.getXmfzz()));
        //没数据时制作空数据
        if (oList.size() < 1) {
            Map<String, Object> item1 = new HashMap<>();
            item1.put("depart", "");
            item1.put("type", "一季度");
            item1.put("value", 0);
            data.add(item1);

            Map<String, Object> item2 = new HashMap<>();
            item2.put("depart", "");
            item2.put("type", "二季度");
            item2.put("value", 0);
            data.add(item2);

            Map<String, Object> item3 = new HashMap<>();
            item3.put("depart", "");
            item3.put("type", "三季度");
            item3.put("value", 0);
            data.add(item3);

            Map<String, Object> item4 = new HashMap<>();
            item4.put("depart", "");
            item4.put("type", "四季度");
            item4.put("value", 0);
            data.add(item4);

        }

        oList.forEach((k, v) -> {
            //如果没有部门名称跳出
            if (!maps.containsKey(k)) {
                return;
            }
            List<ProjectVo> list1 = new ArrayList<>();
            List<ProjectVo> list2 = new ArrayList<>();
            List<ProjectVo> list3 = new ArrayList<>();
            List<ProjectVo> list4 = new ArrayList<>();
            //
            for (int i = 0; i < v.size(); i++) {
                finish.getAndIncrement();
                Date jsrq = v.get(i).getJsrq();
                String s = DateUtils.date2Str(jsrq, DateUtils.date_month.get());
                int month = Integer.parseInt(s);
                //四个季度
                if (month <= 3) {
                    list1.add(v.get(i));

                } else if (month >= 4 && month <= 6) {
                    list2.add(v.get(i));
                } else if (month >= 7 && month <= 9) {
                    list3.add(v.get(i));
                } else {
                    list4.add(v.get(i));
                }
            }
            Map<String, Object> item1 = new HashMap<>();
            item1.put("depart", maps.get(k));
            item1.put("type", "一季度");
            item1.put("value", list1.size());
            data.add(item1);

            Map<String, Object> item2 = new HashMap<>();
            item2.put("depart", maps.get(k));
            item2.put("type", "二季度");
            item2.put("value", list2.size());
            data.add(item2);

            Map<String, Object> item3 = new HashMap<>();
            item3.put("depart", maps.get(k));
            item3.put("type", "三季度");
            item3.put("value", list3.size());
            data.add(item3);

            Map<String, Object> item4 = new HashMap<>();
            item4.put("depart", maps.get(k));
            item4.put("type", "四季度");
            item4.put("value", list4.size());
            data.add(item4);
        });
        res.put("data", data);
        res.put("finish", finish.get());


        return res;

    }

    //项目达成率
    private Map<String, Object> getS1c4(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        //过滤近三年今年完成的项目
        List<ProjectVo> list1 = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.toList());
        List<ProjectVo> list1ok = list.stream().filter(i -> i.getXmzt() != null && i.getXmzt() == 0 && Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.toList());
        List<ProjectVo> list2 = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear() - 1).collect(Collectors.toList());
        List<ProjectVo> list2ok = list.stream().filter(i -> i.getXmzt() != null && i.getXmzt() == 0 && Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear() - 1).collect(Collectors.toList());
        List<ProjectVo> list3 = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear() - 2).collect(Collectors.toList());
        List<ProjectVo> list3ok = list.stream().filter(i -> i.getXmzt() != null && i.getXmzt() == 0 && Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear() - 2).collect(Collectors.toList());

        //TODO  修改SYS_DEPARTS_CACHE缓存

        List<Map<String, Object>> data = new ArrayList<>();
        //本年项目达成率
        double bndcl = 0;
        Map<String, Object> map1 = new HashMap<>();
        map1.put("year", DateUtils.getCurYear() + "年");
        map1.put("type", "项目达成率");
        if (list1.size() > 0 && list1ok.size() > 0) {
            double d = list1ok.size() / (list1.size() * 1.0) * 100;
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

            map1.put("value", ds);
            bndcl = ds;
        } else {
            map1.put("value", 0);
        }
        data.add(map1);
        Map<String, Object> map2 = new HashMap<>();
        map2.put("year", DateUtils.getCurYear() - 1 + "年");
        map2.put("type", "项目达成率");
        if (list2.size() > 0 && list2ok.size() > 0) {
            double d = list2ok.size() / list2.size() * 100;
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

            map2.put("value", ds);

        } else {
            map2.put("value", 0);
        }
        data.add(map2);

        Map<String, Object> map3 = new HashMap<>();
        map3.put("year", DateUtils.getCurYear() - 2 + "年");
        map3.put("type", "项目达成率");
        if (list3.size() > 0 && list3ok.size() > 0) {
            double d = list3ok.size() / list3.size() * 100;
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            map3.put("value", ds);
        } else {
            map3.put("value", 0);
        }
        data.add(map3);
        res.put("data", data);
        res.put("dcl", bndcl); //本年达成率

        return res;
    }

    //项目分类
    private Map<String, Object> getS2c1(List<ProjectVo> list) {

        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        list = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear())
                .map(i -> {
                    if (i.getXmlx() == null) {
                        i.setXmlx(-1);
                    }
                    return i;
                })
                .collect(Collectors.toList());

        Object o = redisUtil.get(CacheConstant.SYS_DICT_CACHE_XMLX);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());

        int size = list.size();


        //以项目类型分组
        Map<Integer, List<ProjectVo>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getXmlx()));
        collect.forEach((k, v) -> {

            Map<String, Object> item = new HashMap<>();
            if (k == -1) {
                item.put("type", "未分类");
            } else {
                Object xmlx = maps.get(k);
                item.put("type", xmlx);
            }
            item.put("value", v.size());

            //百分比
            double d = v.size() / (size * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

            item.put("percent", ds);

            data.add(item);
        });
        res.put("data", data);

        return res;

    }

    //项目规划
    private Map<String, Object> getS2c2(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        list = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.toList());
        Map<Object, List<Map<String, Object>>> collect = list.stream().map(i -> {
            Map<String, Object> map = new HashMap<>();
            if (i.getIsNew() == null) map.put("isnew", 0);
            else map.put("isnew", i.getIsNew());
            map.put("name", i.getXmmc());
            return map;
        }).collect(Collectors.groupingBy(t -> t.get("isnew")));

        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            //是否新增项目
            int isnew = Integer.parseInt(k.toString());
            //统计项目总数
            double count = v.stream().filter(i -> i.get("isnew") != null).count();
            int size = finalList.size();
            if (count < 1.0) return;
            //百分比
            double d = count / size;
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

            item.put("type", isnew == 1 ? "新增项目" : "规划项目");
            item.put("percent", ds);
            item.put("count", count);
            data.add(item);


        });
        res.put("data", data);

        return res;

    }

    //项目状态
    private Map<String, Object> getS2c3(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        //过滤->今年数据
        list = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.toList());

        Object o = redisUtil.get(CacheConstant.SYS_DICT_CACHE_XMZT);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());

        Map<Object, List<Map<String, Object>>> collect = list.stream().map(i -> {
            Map<String, Object> item = new HashMap<>();
            if (i.getXmzt() == null) {
                item.put("type", "未启动");
            } else {
                Object xmzt = maps.get(i.getXmzt());
                if (xmzt == null) {
                    item.put("type", "未启动");
                } else {
                    item.put("type", xmzt.toString());
                }
            }
            item.put("name", i.getXmmc());


            return item;
        }).collect(Collectors.groupingBy(t -> t.get("type")));
        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            item.put("type", k);
            item.put("count", v.size());
            if (v.size() < 1.0) return;
            double d = v.size() / (finalList.size() * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.put("percent", ds);
            data.add(item);
        });
        res.put("data", data);
        res.put("total", list.size());

        return res;
    }
    //项目风险
    private Map<String, Object> getS2c4(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        //过滤->今年数据
        list = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.toList());

        Object o = redisUtil.get(CacheConstant.SYS_DICT_CACHE_FXDJ);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());

        Map<Object, List<Map<String, Object>>> collect = list.stream().map(i -> {
            Map<String, Object> item = new HashMap<>();
            if (i.getFxdj() == null) {
                item.put("type", "无风险");
            } else {
                Object fxdj = maps.get(i.getFxdj());
                if (fxdj == null) {
                    item.put("type", "无风险");
                } else {
                    item.put("type", fxdj.toString());
                }
            }
            item.put("name", i.getXmmc());


            return item;
        }).collect(Collectors.groupingBy(t -> t.get("type")));
        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            item.put("type", k);
            item.put("count", v.size());
            if (v.size() < 1.0) return;
            double d = v.size() / (finalList.size() * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.put("percent", ds);
            data.add(item);
        });
        res.put("data", data);
        res.put("total", list.size());

        return res;
    }

    //负责项目
    private Map<String, Object> getS2c5(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        Object o = redisUtil.get(CacheConstant.SYS_USER_ALL_CACHE);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());
        //过滤->今年数据
        list = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear()).collect(Collectors.toList());
        Map<String, List<ProjectVo>> collect = list.stream().filter(i -> i.getXmfzr() != null).collect(Collectors.groupingBy(t -> t.getXmfzr()));
        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            String key = k;

            Map<String, Object> item = new HashMap<>();


            //负责人存在多位
            String name = "";
            if (k.contains(",")) {
                String[] split = k.split(",");
                for (int i = 0; i < split.length; i++) {
                    String s = split[i];
                    if (maps.containsKey(s)) {
                        name += maps.get(s);
                        if(i!=(split.length-1)) name += ",";
                    }

                }
                if(name.length()>0){
                    item.put("name", name);
                }else {
                    return;
                }
            }else {
                if (!maps.containsKey(key)) return;
                item.put("name", maps.get(key));
            }
            item.put("count", v.size());
            if (v.size() < 1) return;
            double d = v.size() / (finalList.size() * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.put("percent", ds);
            data.add(item);

        });
        res.put("data", data);
        return res;
    }


    //产品类别
    private Map<String, Object> getS2c6(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        Object o = redisUtil.get(CacheConstant.SYS_DICT_CACHE_CPLB);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());

        list = list.stream().filter(i -> Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear())
                .map(i -> {
                    if (i.getCplb() == null) {
                        i.setCplb(-1);
                    }
                    return i;
                })
                .collect(Collectors.toList());
        Map<Integer, List<ProjectVo>> collect = list.stream().filter(i -> i.getCplb() != null).collect(Collectors.groupingBy(t -> t.getCplb()));
        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            if (k == -1) {
                item.put("name", "未分类");
            } else {
                if (!maps.containsKey(k)) return;

                    item.put("name", maps.get(k));


            }


            item.put("count", v.size());
            if (v.size() < 1) return;
            double d = v.size() / (finalList.size() * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.put("percent", ds);
            data.add(item);

        });
        res.put("data", data);
        return res;
    }

    //产品规格
    private Map<String, Object> getS2c7(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();

        list = list.stream().filter(i ->  Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear())
                .map(i->{
                    if(i.getCpgg()==null){
                        i.setCpgg(2);
                    }
                    return i;
                })
                .collect(Collectors.toList());
        Map<Integer, List<ProjectVo>> collect = list.stream().filter(i -> i.getCpgg() != null).collect(Collectors.groupingBy(t -> t.getCpgg()));
        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            if(k==1){
                item.put("name", "已完成");
            }else {
                item.put("name", "未完成");
            }
            item.put("count", v.size());
            if (v.size() < 1) return;
            double d = v.size() / (finalList.size() * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.put("percent", ds);
            data.add(item);

        });
        res.put("data", data);
        return res;

    }

    //里程碑
    private Map<String, Object> getS2c8(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();

        Object o = redisUtil.get(CacheConstant.SYS_DICT_CACHE_LCB);
        if (o == null) return res;
        Map maps = (Map) JSON.parse(o.toString());

        list = list.stream().filter(i ->  Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear())
                .map(i->{
                    if(i.getLcb()==null){
                        i.setLcb(-1);
                    }
                    return i;
                })
                .collect(Collectors.toList());
        Map<Integer, List<ProjectVo>> collect = list.stream().filter(i -> i.getLcb() != null).collect(Collectors.groupingBy(t -> t.getLcb()));
        List<ProjectVo> finalList = list;
        collect.forEach((k, v) -> {
            Map<String, Object> item = new HashMap<>();
            if(k==-1){
                item.put("name","未分类");
            }else {
                if (!maps.containsKey(k)) return;
                    item.put("name", maps.get(k));


            }

            item.put("count", v.size());
            if (v.size() < 1) return;
            double d = v.size() / (finalList.size() * 1.0);
            BigDecimal bigDecimal = new BigDecimal(d);
            double ds = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.put("percent", ds);
            data.add(item);

        });
        res.put("data", data);
        return res;

    }


    private Map<String, Object> getS2c31(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        //过滤没有开始时间和结束时间的项目
        List<Map<String, Object>> collect = list.stream()
                .filter(i->i.getKsrq()!=null && i.getJsrq()!=null)
                .map(i -> {
            Map<String, Object> item = new HashMap<>();
            item.put("id", i.getId());
            item.put("text", i.getXmmc());
            item.put("start_date", i.getKsrq());
            item.put("end_date", i.getJsrq());
            if(i.getWcjd()!=null&&i.getWcjd()>0){
                 i.setWcjd(i.getWcjd()/100);
            }
            item.put("progress",i.getWcjd());
            return item;
        }).collect(Collectors.toList());
        res.put("data", collect);
        return res;

    }

    private Map<String, Object> getS3(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        res.put("data", list);
        return res;

    }

    private Map<String, Object> getS4(List<ProjectVo> list) {
        Map<String, Object> res = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();

        List<ProProjectLink> linkList = proLinkService.list();
        //以项目编号分组
        Map<String, List<ProProjectLink>> collect = linkList.stream().filter(i -> i.getPro() != null).sorted(new Comparator<ProProjectLink>() {
            @Override
            public int compare(ProProjectLink o1, ProProjectLink o2) {
                return o1.getPro().compareTo(o2.getPro());
            }
        }).sorted(new Comparator<ProProjectLink>() {
            @Override
            public int compare(ProProjectLink o1, ProProjectLink o2) {
                if(o1.getSortNo()==null || o2.getSortNo() == null){
                    return -1;
                }

                return  o1.getSortNo().compareTo(o2.getSortNo());
            }
        }).collect(Collectors.groupingBy(t -> t.getPro()));


        list = list.stream().filter(i -> i.getKsrq() !=null && Integer.parseInt(DateUtils.date2Str(i.getKsrq(), DateUtils.date_year.get())) == DateUtils.getCurYear())
                .collect(Collectors.toList());

        Map<String, String> proCollect = list.stream().collect(Collectors.toMap(ProjectVo::getId, ProjectVo::getXmmc));
        //任务总数
        AtomicInteger link = new AtomicInteger();
        //未完成任务总数
        AtomicInteger ulink = new AtomicInteger();
        proCollect.forEach((k, v) -> {

            //项目名称
            String xmmc = v;
            //项目完成的任务
            AtomicInteger finish = new AtomicInteger();
            List<ProProjectLink> proProjectLinks = new ArrayList<>();

            if(collect.containsKey(k)){
                proProjectLinks.addAll(collect.get(k));
            }

            proProjectLinks.forEach(item -> {
                    link.getAndIncrement();
                    if (item.getWcjd() != null && item.getWcjd() == 1) {
                        finish.getAndIncrement();
                    }else {
                        ulink.getAndIncrement();
                    }
                });
            Map<String, Object> item = new HashMap<>();
            item.put("name", xmmc);
            item.put("type", "已完成");
            item.put("count", finish.get());


            Map<String, Object> item2 = new HashMap<>();
            item2.put("name", xmmc);
            item2.put("type", "未完成");
            item2.put("count", proProjectLinks.size() - finish.get());
            data.add(item2);
            data.add(item);
        });
        res.put("data", data);
        res.put("xm", list.size());
        res.put("link", link.get());
        res.put("ulink", ulink.get());
        return res;
    }


}