package com.sercurityControl.proteam.service.impl;

import com.alibaba.nacos.common.utils.CollectionUtils;
import com.github.pagehelper.PageInfo;
import com.google.common.collect.Maps;
import com.securityControl.common.core.utils.StringUtils;
import com.securityControl.common.core.utils.aes.DateTimeHelper;
import com.securityControl.common.core.utils.aes.ListHelper;
import com.securityControl.common.core.utils.aes.StringHelper;
import com.securityControl.common.redis.service.RedisService;
import com.sercurityControl.proteam.domain.*;
import com.sercurityControl.proteam.domain.dto.WeathQo;
import com.sercurityControl.proteam.domain.vo.StatEntity;
import com.sercurityControl.proteam.domain.vo.WeekPlanVo;
import com.sercurityControl.proteam.dutyTask.domain.TowerVo;
import com.sercurityControl.proteam.mapper.HomeDataMapper;
import com.sercurityControl.proteam.service.HomeDataService;

import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.eac.EACException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
@Slf4j
public class HomeDataServiceImpl implements HomeDataService {

    @Autowired
    private HomeDataMapper mapper;
    @Resource
    private RedisService redisService;

    @Override
    public ProDataNum getProNum(String orgId, String protType) {
        //查询在建工程数量
        int buildingNum = mapper.getProNum(orgId, protType, null);
        //查询在施工工程数量
        String workDate = DateTimeHelper.getNowDate();
        int workingNum = mapper.getProNumByWork(workDate, orgId, protType);
        //查询在停工程数量
        int stopProNum = mapper.getProNum(orgId, protType, "1");
        ProDataNum proDataNum = new ProDataNum();
        proDataNum.setBuildingNum(buildingNum);
        proDataNum.setStopProNum(stopProNum);
        proDataNum.setWorkingNum(workingNum);
        return proDataNum;
    }

    @Override
    public PageInfo<ProData> getProList(ProData proData) {
        if (StringUtils.isNotBlank(proData.getBuildCode())) {
            String[] buildCodeArr = proData.getBuildCode().split(",");
            List<String> buildCodeList = Arrays.asList(buildCodeArr);
            proData.setBuildCodeList(buildCodeList);
        }
        List<ProData> list = mapper.getProList(proData);
        PageInfo<ProData> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public DayPlanNum getDayPlan(DayPlanNum dayPlanNum) {
        return mapper.getDayPlan(dayPlanNum);
    }

    @Override
    public  Map<String, Object> getWeekRiskNum(WeekRiskData weekRiskData) {
        Map<String, Object> map= Maps.newHashMap();
        List<String> orgList=new ArrayList<>();
        List<String> toList=new ArrayList<>();
        List<String> thList=new ArrayList<>();
     try{
         if(StringHelper.isEmpty(weekRiskData.getCurryDay())){
             weekRiskData.setCurryDay(DateTimeHelper.getNowDay());
         }
         List<StatEntity> list2 = mapper.getWeekPlanDayNum(weekRiskData);
         for (StatEntity vo:list2) {
             orgList.add(vo.getName());
             toList.add(vo.getNum());
             thList.add(vo.getNum2());
         }
         map.put("data",orgList);
         map.put("data1",toList);
         map.put("data2",thList);
         map.put("msg","周风险统计成功data1是二级风险 data2是三级风险");
     }catch (Exception e){
         map=null;
         log.error(e.toString(),e);
     }
        return map;


    }

    /**
     * 初始化数据
     *
     * @param list
     */
    private List<Integer> initListData(List<Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            list.set(i, 0);
        }
        return list;
    }

    @Override
    public PageInfo<WeekRiskData> getWeekPlanList(WeekRiskData weekRiskData) {
        // 地市多选切割
        if (StringUtils.isNotBlank(weekRiskData.getBuildUnitCode())) {
            String[] buildUnitCodeArr = weekRiskData.getBuildUnitCode().split(",");
            List<String> buildUnitCodeList = Arrays.asList(buildUnitCodeArr);
            weekRiskData.setBuildUnitCodeList(buildUnitCodeList);
        }
        if(StringHelper.isEmpty(weekRiskData.getCurryDay())){
            weekRiskData.setCurryDay(DateTimeHelper.getNowDay());
        }
        List<WeekRiskData> list = mapper.getWeekPlanListByTime(weekRiskData);
        PageInfo<WeekRiskData> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public List<RiskMapData> getRiskMap(RiskMapData riskMapData) {
        List<RiskMapData> list = mapper.getRiskMap(riskMapData);
        return list;
    }

    @Override
    public List<WeatherMapData> getWeatherMap() {
        String weatherDay = DateTimeHelper.getNowDay();
        String currentHour = DateTimeHelper.getNowHours();
        return mapper.getWeatherMap(weatherDay, currentHour + "时");
    }

    @Override
    public List<String> getWeatherAlert(String currentDay, String orgId) {
        return mapper.getWeatherAlert(currentDay, orgId);
    }

    @Override
    public List<Map<String, String>> getWeatherAlertPlus(WeathQo weathQo) {
        return mapper.getWeatherAlertPlus(weathQo);
    }

    @Override
    public Map<String, Object> getTicketNumByType(TicketTypeNum ticketTypeNum) {
        List<TicketTypeNum> list = mapper.getTicketNumByType(ticketTypeNum);
        Map<String, Object> map = new HashMap<>(16);
        int ticketNumA = 0;//A票数量
        int ticketNumB = 0;//B票数量
        map.put("two", 0);
        map.put("three", 0);
        map.put("four", 0);
        map.put("five", 0);
        for (int i = 0; i < list.size(); i++) {
            TicketTypeNum num = list.get(i);
            String ticketType = num.getTicketType();
            if ("2".equals(ticketType) || "二级".equals(ticketType) || Objects.equals("2级",ticketType)) {
                map.put("two", num.getRiskNum());
            } else if ("3".equals(ticketType) || "三级".equals(ticketType) || Objects.equals("3级",ticketType)) {
                map.put("three", num.getRiskNum());
            } else if ("4".equals(ticketType) || "四级".equals(ticketType) || Objects.equals("4级",ticketType)) {
                map.put("four", num.getRiskNum());
            } else if ("5".equals(ticketType) || "五级".equals(ticketType) || Objects.equals("5级",ticketType)) {
                map.put("five", num.getRiskNum());
            }
            if ("2".equals(ticketType) || "3".equals(ticketType) || "二级".equals(ticketType) || "三级".equals(ticketType) || Objects.equals("2级",ticketType) || Objects.equals("3级",ticketType)) {
                ticketNumB += num.getRiskNum();
            } else if ("4".equals(ticketType) || "5".equals(ticketType) || "四级".equals(ticketType) || "五级".equals(ticketType) || Objects.equals("4级",ticketType) || Objects.equals("5级",ticketType)) {
                ticketNumA += num.getRiskNum();
            }
        }
        map.put("ticketNumA", ticketNumA);
        map.put("ticketNumB", ticketNumB);
        return map;
    }

    @Override
    public Map<String, Object> getTicketNumByCicty(TicketCityNum ticketCityNum) {
        if (ticketCityNum == null) {
            return null;
        }
        int dayType = ticketCityNum.getDateType();

        String format = null;//查询的日期格式
        String date = null;//查询的日期
        if (dayType == 1) {//上月
            String[] monthArr = getLastMonth().split(",");
            format = monthArr[0];
            date = monthArr[1];
        } else if (dayType == 2) {//上周
            String temp = DateTimeHelper.getPrevWeek();
            String[] times = temp.split(",");
            format = times[0];
            date = times[1];
        } else if (dayType == 3) {//当日
            date = DateTimeHelper.getNowDate();
        } else if (dayType == 4) {//本周
            String temp = DateTimeHelper.getCurrentWeekTime();
            String[] times = temp.split(",");
            format = times[0];
            date = times[1];
        } else if (dayType == 5) {//本月
            String[] monthArr = getNowMonth().split(",");
            format = monthArr[0];
            date = monthArr[1];
        }

        ticketCityNum.setTicketDate(date);
        ticketCityNum.setFormat(format);
        List<TicketCityNum> list = mapper.getTicketNumByCicty(ticketCityNum);
        Map<String, Object> map = new HashMap<>(16);
        List<String> cictyList = new ArrayList<>();
        List<Integer> numList = new ArrayList<>();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                TicketCityNum num = list.get(i);
                String cictyName = num.getCictyName();
                int ticketNum = num.getTicketNum();
                cictyList.add(cictyName);
                numList.add(ticketNum);
            }
        }
        map.put("cictyName", cictyList);
        map.put("ticketNum", numList);
        return map;
    }


    @Override
    public PageInfo<TicketData> getTicketList(TicketData ticketData) {
        // 地市多选切割
        if (StringUtils.isNotBlank(ticketData.getBuildCode())) {
            String[] buildCodeArr = ticketData.getBuildCode().split(",");
            List<String> buildCodeArrList = Arrays.asList(buildCodeArr);
            ticketData.setBuildCodeList(buildCodeArrList);
        }
        // 风险等级多选切割
        if (StringUtils.isNotBlank(ticketData.getRiskType())) {
            String[] riskTypeArr = ticketData.getRiskType().split(",");
            List<String> riskTypeList = Arrays.asList(riskTypeArr);
            ticketData.setRiskTypeList(riskTypeList);
        }
        List<TicketData> list = mapper.getTicketList(ticketData);
        if(ListHelper.isNotEmpty(list)){
            list.forEach(voo->{
                WorkInfoVo workInfoVo=getWorkInfo(voo.getId());
                voo.setWorkContent(workInfoVo.getWorkContent());
            });

        }

        PageInfo<TicketData> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }


    public static String getNowMonth(){
        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, 0);
        c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
        String first = format.format(c.getTime());
        //获取当前月最后一天
        Calendar ca = Calendar.getInstance();
        ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
        String last = format.format(ca.getTime());
        return first + "," + last;
    }

    public static String getLastMonth(){
        SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
        Calendar ca=Calendar.getInstance();
        ca.add(Calendar.MONTH, -1);
        ca.set(Calendar.DAY_OF_MONTH, 1);

        Calendar calendar=Calendar.getInstance();
        int month=calendar.get(Calendar.MONTH);
        calendar.set(Calendar.MONTH, month-1);
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return sf.format(ca.getTime()) + "," + sf.format(calendar.getTime());
    }


    @Override
    public Map<String, Object> getDayAttendanceNum(String currentDay) {
        /**
         * 获取人员数据
         */
        List<PersonNum> list = mapper.getDayAttendanceNum(currentDay);
        Map<String, Object> map = new HashMap<>(16);
        int teamNum = 0;//班组骨干
        int tzzyNum = 0;//特种作业
        int ptsgNum = 0;//普通施工
        //循环处理数据
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                PersonNum personNum = list.get(i);
                int personTypeId = personNum.getPersonTypeId();
                String personType = personNum.getPersonType();
                if ("副班长".equals(personType) || "工作负责人".equals(personType) || "班长兼指挥".equals(personType) || "班组安全员".equals(personType)) {
                    teamNum += personNum.getPersonNum();
                } else if ("牵张机械操作手".equals(personType) || "其他技术人员".equals(personType) || "班组技术兼质检员".equals(personType) || "特殊工种作业人员".equals(personType) || "班组技术员兼质检员".equals(personType)) {
                    tzzyNum += personNum.getPersonNum();
                } else {
                    ptsgNum += personNum.getPersonNum();
                }

            }
        }

        map.put("teamNum", teamNum);
        map.put("tzzyNum", tzzyNum);
        map.put("ptsgNum", ptsgNum);
        return map;
    }

    @Override
    public Map<String, Object> getRealTimeNum(String currentDay) {
        /**
         * 获取人员数据
         */
        List<PersonNum> list = mapper.getRealTimeNum(currentDay);
        Map<String, Object> map = new HashMap<>(16);
        int teamNum = 0;//班组骨干
        int tzzyNum = 0;//特种作业
        int ptsgNum = 0;//普通施工
        //循环处理数据
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                PersonNum personNum = list.get(i);
                String personType = personNum.getPersonType();
                if ("副班长".equals(personType) || "工作负责人".equals(personType) || "班长兼指挥".equals(personType) || "班组安全员".equals(personType)) {
                    teamNum += personNum.getPersonNum();
                } else if ("牵张机械操作手".equals(personType) || "其他技术人员".equals(personType) || "班组技术兼质检员".equals(personType) || "特殊工种作业人员".equals(personType) || "班组技术员兼质检员".equals(personType)) {
                    tzzyNum += personNum.getPersonNum();
                } else {
                    ptsgNum += personNum.getPersonNum();
                }

            }

        }
        map.put("teamNum", teamNum);
        map.put("tzzyNum", tzzyNum);
        map.put("ptsgNum", ptsgNum);
        return map;
    }

    @Override
    public PageInfo<PersonData> getPersonList(PersonData personData) {
        if (personData == null) {
            personData = new PersonData();
            personData.setQueryType(1);
            personData.setCurrentDay(DateTimeHelper.getNowDay());
        }
        if(StringHelper.isEmpty(personData.getCurrentDay())){
            personData.setCurrentDay(DateTimeHelper.getNowDay());
        }
      //  int queryType = personData.getQueryType();
        List<PersonData> list = null;
        if(StringHelper.isNotEmpty(personData.getPersonType())){
            List<String>  tyList=getPeopleTypeList(Integer.parseInt(personData.getPersonType()));
            personData.setTypeList(tyList);
        }
        if(DateTimeHelper.getNowDay().equals(personData.getCurrentDay())){
            list = mapper.getPersonList(personData);
            PageInfo<PersonData> pageInfo = new PageInfo<>(list);
            return pageInfo;
        }else{
            list = mapper.getPersonList(personData);
            PageInfo<PersonData> pageInfo = new PageInfo<>(list);
            return pageInfo;
        }


    }

    @Override
    public Map<String, Object> getRiskByDate(String orgId, String dateType) {
        String date;
        if ("1".equals(dateType)) {//今日
            date = DateTimeHelper.getNowDate();
        } else {//昨日
            date = DateTimeHelper.getFrontDay();
        }
        List<RiskDay> list = mapper.getRiskByDate(orgId, date);
        Map<String, Object> map = new HashMap<>(16);
        int twoNum = 0;
        int threeNum = 0;
        int fourNum = 0;
        int fiveNum = 0;
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                RiskDay riskDay = list.get(i);
                String riskType = riskDay.getRiskType();
                if ("2".equals(riskType) || "二级".equals(riskType)) {
                    twoNum += riskDay.getRiskNum();
                } else if ("3".equals(riskType) || "三级".equals(riskType)) {
                    threeNum += riskDay.getRiskNum();
                } else if ("4".equals(riskType) || "四级".equals(riskType)) {
                    fourNum += riskDay.getRiskNum();
                } else if ("5".equals(riskType) || "五级".equals(riskType)) {
                    fiveNum += riskDay.getRiskNum();
                }
            }
        }
        map.put("twoNum", twoNum);
        map.put("threeNum", threeNum);
        map.put("fourNum", fourNum);
        map.put("fiveNum", fiveNum);
        return map;
    }

    @Override
    public Map<String, Object> getDayPlanNum(String proType, String dayType) {
        Map<String, Object> map = new HashMap<>(16);
        List<Integer> list = mapper.getDayPlanNum(proType, dayType);
        List<Map<String, Object>> listMap = mapper.getDayPlanOrgNum(proType, dayType);
        map.put("totalDayNum", list.get(0));
        map.put("executedDayNum", list.get(1));
        map.put("listMap", listMap);
        return map;
    }

    /**
     * 获取日计划及施工人员数据
     * @param proType
     * @param dayType
     * @return
     */
    @Override
    public Map<String, Object> getNewDayPlanNum(String proType, String dayType) {
        Map<String, Object> map = new HashMap<>(16);
        try{
            List<Integer> list = mapper.getNewDayPlanNum(proType, dayType);
            List<Map<String, Object>> listMap = mapper.getNewDayPlanOrgNum(proType, dayType);
            map.put("totalDayNum", list.get(0));
            map.put("executedDayNum", list.get(1));
            map.put("listMap", listMap);
        }catch (Exception e){
            log.error(e.toString(),e);
        }

        return map;
    }

    @Override
    public Map<String, Object> getWeekRiskNumByWeekTime(String startWeek, String endWeek) {
        Map<String, Object> map = new HashMap<>(16);
          try{
                 map = mapper.getWeekRiskNumByWeekTime(startWeek, endWeek);
          }catch (Exception e){
              log.error(e.toString(),e);
          }
         return map;
    }

    /**
     * 查询
     * @param startWeek
     * @param endWeek
     * @param riskLevel
     * @return
     */
    @Override
    public List<MapsValueVo> getWeekRiskByRiskLevel(String startWeek, String endWeek, String riskLevel) {

        return mapper.getWeekRiskByRiskLevel(startWeek,endWeek,riskLevel);
    }

    @Override
    public List<WeekPlanVo> getNexWeekPro(String startWeek, String endWeek, String riskLevel) {
        return mapper.getNexWeekPro(startWeek,endWeek,riskLevel);
    }

    @Override
    public Map<String, Object> getAllRiskLevelNum(String time) {
        return mapper.getAllRiskLevelNum(time);
    }

    @Override
    public Integer getWzXx(String orgId) {
        return mapper.getWzXx(orgId);
    }

    /**
     * h用户是否报岗
     * @param orgId
     * @return
     */
    @Override
    public Integer getIsBg(String orgId) {
        try{
            return mapper.getIsBg(orgId,DateTimeHelper.getNowDay());
        }catch (Exception e){
            log.error(e.toString(),e);
        }
        return 0;
    }

    /**
     *
     * @param params
     * @return
     */
    @Override
    public List<TowerVo> getGtList(TowerVo params) {
      try{
          List<TowerVo> list=mapper.getGtList(params);
          return list;
      }catch (Exception e){
          log.error(e.toString(),e);
      }
      return  new ArrayList<>();
    }

    @Override
    public Map<String, Object> getAttendanceNum(String orgId) {
        HashMap<String, Object> map = new HashMap<>(16);
        List<Integer> list = mapper.getAttendanceNum(orgId);
        if (CollectionUtils.isNotEmpty(list)) {
            map.put("attendanceNum", list.get(0));
            map.put("attendanceNum2", list.get(1));
        } else {
            map.put("attendanceNum", 0);
            map.put("attendanceNum2", 0);
        }
        return map;
    }

    @Override
    public List<Map<String, Object>> getOrgNumAndRateByPro(ProData proData) {

        List<Map<String, Object>> list = mapper.getOrgNumAndRateByPro(proData);
        int totalNum = 0;
        for (Map<String, Object> map : list) {
            totalNum += Integer.parseInt(String.valueOf(map.get("num")));
        }
        DecimalFormat decimalFormat = new DecimalFormat("0.00%");
        for (Map<String, Object> map : list) {
            if (totalNum == 0 || Integer.parseInt(String.valueOf(map.get("num"))) == 0) {
                map.put("rate", "0.00%");
            } else {
                map.put("rate", decimalFormat.format(Integer.parseInt(String.valueOf(map.get("num"))) * 1.0 / totalNum * 1.0));
            }
        }
        return list;
    }
    @Override
    public List<Map<String, Object>> getOrgNumAndRateByProNew(ProData proData) {

        List<Map<String, Object>> list = mapper.getOrgNumAndRateByProNew(proData);
        int totalNum = 0;
        for (Map<String, Object> map : list) {
            totalNum += Integer.parseInt(String.valueOf(map.get("num")));
        }
        DecimalFormat decimalFormat = new DecimalFormat("0.00%");
        for (Map<String, Object> map : list) {
            if (totalNum == 0 || Integer.parseInt(String.valueOf(map.get("num"))) == 0) {
                map.put("rate", "0.00%");
            } else {
                map.put("rate", decimalFormat.format(Integer.parseInt(String.valueOf(map.get("num"))) * 1.0 / totalNum * 1.0));
            }
        }
        return list;
    }

    @Override
    public Map<String, Object> getOrgNumAndRateByWeek(WeekRiskData weekRiskData) {
            if(StringHelper.isEmpty(weekRiskData.getCurryDay())){
                weekRiskData.setCurryDay(DateTimeHelper.getNowDay());
            }
        Map<String, Object> map= Maps.newHashMap();
        weekRiskData.setWeekType(2);
        List<Map<String, Object>> list2 = mapper.getOrgNumAndRateByWeek(weekRiskData);
        weekRiskData.setWeekType(3);
        List<Map<String, Object>> list3 = mapper.getOrgNumAndRateByWeek(weekRiskData);
        map.put("data1",list2);
        map.put("data2",list3);
        map.put("msg","周风险统计成功data1是二级风险 data2是三级风险");
        return map;
    }

    @Override
    public List<Map<String, Object>> getOrgNumAndRateByWeekChild(WeekRiskData weekRiskData) {
        if(StringHelper.isEmpty(weekRiskData.getCurryDay())){
            weekRiskData.setCurryDay(DateTimeHelper.getNowDay());
        }

        List<Map<String, Object>> list = mapper.getOrgNumAndRateByWeekChild(weekRiskData);
        int totalNum = 0;
        for (Map<String, Object> map : list) {
            totalNum += Integer.parseInt(String.valueOf(map.get("num")));
        }
        DecimalFormat decimalFormat = new DecimalFormat("0.00%");
        for (Map<String, Object> map : list) {
            if (totalNum == 0 || Integer.parseInt(String.valueOf(map.get("num"))) == 0) {
                map.put("rate", "0.00%");
            } else {
                map.put("rate", decimalFormat.format(Integer.parseInt(String.valueOf(map.get("num"))) * 1.0 / totalNum * 1.0));
            }
        }
        return list;
    }

    @Override
    public List<Map<String, Object>> getOrgNumAndRateByTicket(TicketData ticketData) {
        // 风险等级多选切割
        if (StringUtils.isNotBlank(ticketData.getRiskType())) {
            String[] riskTypeArr = ticketData.getRiskType().split(",");
            List<String> riskTypeList = Arrays.asList(riskTypeArr);
            ticketData.setRiskTypeList(riskTypeList);
        }
        List<Map<String, Object>> list = mapper.getOrgNumAndRateByTicket(ticketData);
        int totalNum = 0;
        for (Map<String, Object> map : list) {
            totalNum += Integer.parseInt(String.valueOf(map.get("num")));
        }
        DecimalFormat decimalFormat = new DecimalFormat("0.00%");
        for (Map<String, Object> map : list) {
            if (totalNum == 0 || Integer.parseInt(String.valueOf(map.get("num"))) == 0) {
                map.put("rate", "0.00%");
            } else {
                map.put("rate", decimalFormat.format(Integer.parseInt(String.valueOf(map.get("num"))) * 1.0 / totalNum * 1.0));
            }
        }
        return list;
    }

    @Override
    public Map<String, Object> getProNumByType(String proType, String orgId) {
        Map<String, Object> map = new HashMap<>(16);
      //  List<Integer> list = mapper.getProNumByType(proType,orgId);
        String year=DateTimeHelper.getNowYear();
        List<Integer> list = mapper.getNewProNumByType(proType,orgId,year);
        map.put("allZjNum",list.get(0));
        map.put("zjNum",list.get(1));
        map.put("sgNum",list.get(2));
        map.put("tgNum",list.get(3));
        map.put("dkgNum",list.get(4));
        return map;
    }

    @Override
    public PageInfo<ProData> getProListByType(ProData proData) {
        if (StringUtils.isNotBlank(proData.getBuildCode())) {
            String[] buildCodeArr = proData.getBuildCode().split(",");
            List<String> buildCodeList = Arrays.asList(buildCodeArr);
            proData.setBuildCodeList(buildCodeList);
        }
       // List<ProData> list = mapper.getProListByType(proData);
        List<ProData> list = mapper.getNewProListByType(proData);
        PageInfo<ProData> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    /**
     * 站班会统计
     * @param vo
     * @return
     */
    @Override
    public Map<String, Object> getClassMettingData(ClassMettingStaVo vo) {
        Map<String, Object> map=Maps.newHashMap();
        List<String> nameList=new ArrayList<>();
        List<String> values=new ArrayList<>();
        try{
            if (StringHelper.isEmpty(vo.getCurryDay())){
                vo.setCurryDay(DateTimeHelper.getNowDay());
            }
            List<ClassMettingStaVo> list = mapper.getClassMettingData(vo);
            for (ClassMettingStaVo ent: list) {
                nameList.add(ent.getName());
                values.add(ent.getNum());
            }
            map.put("data",nameList);
            map.put("value",values);
            map.put("msg","获取站班会数据成功");
        }catch (Exception e){
            log.error(e.toString(),e);
        }

        return map;
    }

    /**
     * 分页查询站班会数据
     * @param vo
     * @return
     */
    @Override
    public PageInfo<ProData> getClassMettingList(ClassMettingStaVo vo) {
        if (StringUtils.isNotBlank(vo.getBuildCode())) {
            String[] buildCodeArr = vo.getBuildCode().split(",");
            List<String> buildCodeList = Arrays.asList(buildCodeArr);
            vo.setOrgList(buildCodeList);
        }
        if(StringHelper.isNotEmpty(vo.getRiskLevel())){
            List<String> riskList=Arrays.asList(vo.getRiskLevel().split(","));
            vo.setRiskList(riskList);
        }
        if(StringHelper.isEmpty(vo.getCurryDay())){
            vo.setCurryDay(DateTimeHelper.getNowDay());
        }

        List<ProData> list = mapper.getClassMettingList(vo);
        PageInfo<ProData> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public List<Map<String, Object>> getOrgNumAndRateByClass(ClassMettingStaVo vo) {
        // 风险等级多选切割
        if(StringHelper.isNotEmpty(vo.getRiskLevel())){
            List<String> riskList=Arrays.asList(vo.getRiskLevel().split("，"));
            vo.setRiskList(riskList);
        }
        List<Map<String, Object>> list = mapper.getOrgNumAndRateByClass(vo);
        int totalNum = 0;
        for (Map<String, Object> map : list) {
            totalNum += Integer.parseInt(String.valueOf(map.get("num")));
        }
        DecimalFormat decimalFormat = new DecimalFormat("0.00%");
        for (Map<String, Object> map : list) {
            if (totalNum == 0 || Integer.parseInt(String.valueOf(map.get("num"))) == 0) {
                map.put("rate", "0.00%");
            } else {
                map.put("rate", decimalFormat.format(Integer.parseInt(String.valueOf(map.get("num"))) * 1.0 / totalNum * 1.0));
            }
        }
        return list;
    }


    public  List<String>  getPeopleTypeList(int type){
        List<String> list=new ArrayList<>();
        if(type==1){
            list.add("班组负责人");
            list.add("班组安全员");
            list.add("班组技术员");
            list.add("副班长");
        }else if(type ==2){
            list.add("特种作业人员");
        }else if(type ==3){
            list.add("一般作业人员");
            list.add("其他技术人员");
        }else{
            list.add("班组负责人");
            list.add("班组安全员");
            list.add("班组技术员");
            list.add("特种作业人员");
            list.add("副班长");
            list.add("一般作业人员");
            list.add("其他技术人员");
        }
        return  list;
    }
    /**
     * 人员数量统计展示
     * @param
     * @return
     */
    @Override
    public Map<String, Object> getClassPeopleNum(PersonNum person) {
        Map<String, Object> map=Maps.newHashMap();
        Map<String, Object> maps=Maps.newHashMap();
        Map<String, Object> maps1=Maps.newHashMap();
        Map<String, Object> maps2=Maps.newHashMap();
        List<Map<String, Object>> data=new ArrayList<>();
        try{
            List<String> bzgg=getPeopleTypeList(1);
            List<String> tzzy=getPeopleTypeList(2);
            List<PersonNum> list = mapper.getClassPeopleNum(person);
            int allNUM=0;//全部人数;
            int teamNum = 0;//班组骨干
            int tzzyNum = 0;//特种作业
            int ptsgNum = 0;//普通施工
            //循环处理数据
            for (  PersonNum personNum:list) {
                if(personNum!=null){
                    String personType = personNum.getPersonType();
                    if(bzgg.contains(personType)){//班组骨干
                        teamNum += personNum.getPersonNum();
                    }else   if(tzzy.contains(personType)){//特种作业
                        tzzyNum += personNum.getPersonNum();
                    }else{//其他
                        ptsgNum += personNum.getPersonNum();
                    }
                }
            }
            allNUM=teamNum+tzzyNum+ptsgNum;
            maps.put("bzgg",teamNum);
            maps1.put("ttzy",tzzyNum);
            maps2.put("ptzy",ptsgNum);
            data.add(maps);
            data.add(maps1);
            data.add(maps2);
            redisService.set("allPeopleNum",allNUM+"");
            String allPeopleNum=(String)redisService.get("allPeopleNum");
            System.err.println(allPeopleNum);
            map.put("data",data);
            map.put("all",allNUM);
       }catch (Exception e){
            maps.put("bzgg",0);
            maps1.put("ttzy",0);
            maps2.put("ptzy",0);
            data.add(maps);
            data.add(maps1);
            data.add(maps2);
            map.put("data",data);
            map.put("all",0);
           log.error(e.toString(),e);
       }
        return map;
    }

    @Override
    public PageInfo<DailyPlanHome> getNewDailPlanList(DailyPlanHome dailyPlanVo) {
        if (StringUtils.isNotBlank(dailyPlanVo.getOrgId())) {
            String[] buildCodeArr = dailyPlanVo.getOrgId().split(",");
            List<String> buildCodeList = Arrays.asList(buildCodeArr);
            dailyPlanVo.setOrgList(buildCodeList);
        }
        if("01".equals(dailyPlanVo.getPlanType())){//01 站班会
            List<DailyPlanHome> list = mapper.getNewDailPlanList2(dailyPlanVo);
            PageInfo<DailyPlanHome> pageInfo = new PageInfo<>(list);
            return pageInfo;
        }else{//02 日计划
            List<DailyPlanHome> list = mapper.getNewDailPlanList1(dailyPlanVo);
            if(ListHelper.isNotEmpty(list)){
                //依据周计划查询施工信息
                list.forEach(vo->{
                    WorkInfoVo workInfoVo=getWorkInfo(vo.getTicketId());
                    vo.setJobGx(workInfoVo.getWorkGx());
                    vo.setJobLx(workInfoVo.getWorkType());
                    vo.setWorkContent(workInfoVo.getWorkContent());
                    vo.setJobSite(workInfoVo.getWorkSite());
                });
            }
            PageInfo<DailyPlanHome> pageInfo = new PageInfo<>(list);
            return pageInfo;
        }

    }

    /**
     * 作业票施工内容信息查询
     * 作业票统一查询 关联信息接口
     * @param ticketId
     * @return
     */
    public WorkInfoVo getWorkInfo(String ticketId) {
        WorkInfoVo vo=new WorkInfoVo();
        try{
        if (StringHelper.isEmpty(ticketId)) {
            return vo;
        }
        List<WorkInfoVo> list=mapper.getWorkInfo(ticketId);
        if(ListHelper.isEmpty(list)){
            return vo;
        }
        StringBuffer workType=new StringBuffer();
        StringBuffer workContent=new StringBuffer();
        StringBuffer workGx=new StringBuffer();
        StringBuffer workSite=new StringBuffer();
            list.forEach(voi->{
                getStringBuffer(workType,voi.getWorkType());
                getStringBuffer(workContent,voi.getWorkContent());
                getStringBuffer(workGx,voi.getWorkGx());
                getStringBuffer(workSite,voi.getWorkSite());
            });
            vo.setWorkContent(workContent.toString());
            vo.setWorkType(workType.toString());
            vo.setWorkGx(workGx.toString());
            vo.setWorkSite(workSite.toString());
        }catch (Exception e){
            log.error(e.toString(),e);
        }
        return vo;
    }
    private void getStringBuffer(StringBuffer str,String data){
        if(StringHelper.isNotEmpty(data)){
            if(StringHelper.isNotEmpty(str.toString())){
                str.append(";");
            }
            str.append(data);
        }
    }


    @Override
    public PageInfo<DailyPlanVo> getDailPlanList(DailyPlanVo dailyPlanVo) {
        if (StringUtils.isNotBlank(dailyPlanVo.getOrgId())) {
            String[] buildCodeArr = dailyPlanVo.getOrgId().split(",");
            List<String> buildCodeList = Arrays.asList(buildCodeArr);
            dailyPlanVo.setOrgList(buildCodeList);
        }
        String workDay=DateTimeHelper.getNowDay();
        if(StringHelper.isNotEmpty(dailyPlanVo.getDayTypeParam())){
            if("2".equals(dailyPlanVo.getDayTypeParam())){
                workDay=DateTimeHelper.getYesTodayt();//昨天
            }else  if("1".equals(dailyPlanVo.getDayTypeParam())){
                workDay=DateTimeHelper.getQtDay();//前天
            }
        }
        dailyPlanVo.setWorkTime(workDay);
        List<DailyPlanVo> list = mapper.getDailPlanList(dailyPlanVo);
        PageInfo<DailyPlanVo> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    /**
     *
     * @param dailyPlanVo
     * @return
     */
    public List<Map<String, Object>> getOrgNumAndRateByDailPlan(DailyPlanVo dailyPlanVo) {
        String workDay=DateTimeHelper.getNowDay();
        if(StringHelper.isNotEmpty(dailyPlanVo.getDayTypeParam())){
            if("2".equals(dailyPlanVo.getDayTypeParam())){
                workDay=DateTimeHelper.getYesTodayt();//昨天
            }else  if("1".equals(dailyPlanVo.getDayTypeParam())){
                workDay=DateTimeHelper.getQtDay();//前天
            }
        }
        dailyPlanVo.setWorkTime(workDay);
        List<Map<String, Object>> list = mapper.getOrgNumAndRateByDailPlan(dailyPlanVo);
        int totalNum = 0;
        for (Map<String, Object> map : list) {
            totalNum += Integer.parseInt(String.valueOf(map.get("num")));
        }
        DecimalFormat decimalFormat = new DecimalFormat("0.00%");
        for (Map<String, Object> map : list) {
            if (totalNum == 0 || Integer.parseInt(String.valueOf(map.get("num"))) == 0) {
                map.put("rate", "0.00%");
            } else {
                map.put("rate", decimalFormat.format(Integer.parseInt(String.valueOf(map.get("num"))) * 1.0 / totalNum * 1.0));
            }
        }
        return list;
    }



}