package com.moral.api.service.impl;


import com.moral.api.config.Interceptor.UserHelper;
import com.moral.api.entity.SysDictData;
import com.moral.api.exception.BusinessException;
import com.moral.api.mapper.*;
import com.moral.api.pojo.enums.SysDictTypeEnum;
import com.moral.api.pojo.vo.user.QxUser;
import com.moral.api.service.SysDictTypeService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.system.ApplicationHome;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.Serializable;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.moral.api.entity.Dustld;
import com.moral.api.entity.ManageCoordinate;
import com.moral.api.entity.MaxRoad;
import com.moral.api.pojo.dto.historySecondCruiser.DustldDTO;
import com.moral.api.pojo.dust.DustForm;
import com.moral.api.pojo.dust.TimeForm;
import com.moral.api.service.DustldService;
import com.moral.util.DateUtils;
import com.moral.util.FileUtils;
import com.moral.util.TokenUtils;

@Service
@Slf4j
public class DustldServiceImpl implements DustldService {


    @Autowired
    private HistorySecondCruiserMapper  historySecondCruiserMapper;

    @Autowired
    private DustldMapper dustldMapper;

    /**
     * 保存日报信息
     * @param params
     * @param file
     * @return
     * @throws ParseException
     */
    @Override
    public Integer getDailyDustld(Map<String, Object> params,MultipartFile file ) {
        SysDictData listDict = sysDictTypeService.listOne(SysDictTypeEnum.SYS_SECOND_CRUISER.getValue(),"dustld");
        //获取jar包所在目录
        ApplicationHome applicationHome = new ApplicationHome(getClass());
        //在jar包所在目录下生成一个upload文件夹用来存储上传的图片
        String path = applicationHome.getSource().getParentFile().toString() + "/static/img";


        String mac = params.get("mac").toString();
        String time3 = params.get("time3").toString();
        String time4 = params.get("time4").toString();
        String table = params.get("table").toString();
        String substring = time3.substring(0, 10);
        //路段名
        String road = params.get("road").toString();

        ArrayList<Double> list = new ArrayList<>();
        List<TimeForm> tables = JSONArray.parseArray(table, TimeForm.class);

        if (!ObjectUtils.isEmpty(tables)){
            for (TimeForm timeForm : tables) {
                String start = timeForm.getStart();
                String end = timeForm.getEnd();
                List<String> dust = historySecondCruiserMapper.getDust(start, end, mac);
                ArrayList<Double> rsDouble = new ArrayList<>();
                for (String s : dust) {
                    double aDouble = Double.parseDouble(s);
                    if(listDict.getDataValue().contains(",")){
                        List<String> resultStr = Arrays.asList(listDict.getDataValue().split(","));
                        if(resultStr.size() % 2 ==0){
                            aDouble = numAvg(resultStr,BigDecimal.valueOf(aDouble)).doubleValue();
                        }
                    }else {
                        BigDecimal dataValue = Objects.nonNull(listDict.getDataValue())?BigDecimal.valueOf(Double.parseDouble(listDict.getDataValue())):BigDecimal.ZERO;
                        aDouble = BigDecimal.valueOf(aDouble).add(dataValue).doubleValue();
                    }
                    /*if (aDouble>=0 && aDouble<40 ){
                        aDouble = aDouble + 170;
                    }else if (aDouble>=40 && aDouble<60){
                        aDouble = aDouble + 130;
                    }else if (aDouble>=60 && aDouble<100 ){
                        aDouble = aDouble + 110;
                    }else if (aDouble>=100 && aDouble<150){
                        aDouble = aDouble + 70;
                    }else if (aDouble>=150 && aDouble<180){
                        aDouble = aDouble + 30;
                    }else {
                        aDouble= aDouble+0;
                    }*/
                    rsDouble.add(aDouble);
                }
                list.addAll(rsDouble);
            }
        }
        String format = "";
        if (!ObjectUtils.isEmpty(list)){
            Double collect = (list.stream().collect(Collectors.averagingDouble(Double::doubleValue)))/1000;
            format = new DecimalFormat("0.000").format(collect);
        }

        QueryWrapper<Dustld> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("mac",mac).likeRight("time",substring);
        Dustld dustld = dustldMapper.selectOne(queryWrapper);

       if (ObjectUtils.isEmpty(dustld)){
           Dustld dustld1 = new Dustld();
           if (!ObjectUtils.isEmpty(file)){
               HashMap<String, Object> hashMap = new HashMap<>();
               String fileType = file.getContentType();
               if ("image/jpg".equals(fileType) || "image/png".equals(fileType) || "image/jpeg".equals(fileType)){
                   //获取文件名
                   String fileName = file.getOriginalFilename();
                   //获取文件后缀名
                   String suffixName = fileName.substring(fileName.lastIndexOf("."));
                   //每一次都需要
                   fileName.substring(fileName.lastIndexOf("."));
                   //重新生成文件名
                   fileName = UUID.randomUUID() + suffixName;
                   //图片上传
                   if (FileUtils.upload(file, path, fileName)) {
                       hashMap.put("file1",fileName);
                       String s = JSON.toJSONString(hashMap);
                       dustld1.setImages(s);
                   }
               }
           }

           HashMap<String, Object> map = new HashMap<>();

           map.put(road,format);
           String value = JSON.toJSONString(map);
           dustld1.setMac(mac);
           dustld1.setTime(DateUtils.getDate(time3,DateUtils.yyyy_MM_dd_HH_mm_ss_EN));
           dustld1.setValue(value);
           dustld1.setEndTime(DateUtils.getDate(time4,DateUtils.yyyy_MM_dd_HH_mm_ss_EN));
           dustldMapper.insert(dustld1);
           return 200;
       }else {
           if (!ObjectUtils.isEmpty(file)){
               HashMap<String, Object> hashMap = new HashMap<>();
               String fileType = file.getContentType();
               if ("image/jpg".equals(fileType) || "image/png".equals(fileType) || "image/jpeg".equals(fileType)){
                   //获取文件名
                   String fileName = file.getOriginalFilename();
                   //获取文件后缀名
                   String suffixName = fileName.substring(fileName.lastIndexOf("."));
                   //每一次都需要
                   fileName.substring(fileName.lastIndexOf("."));
                   //重新生成文件名
                   fileName = UUID.randomUUID() + suffixName;
                   //图片上传
                   if (FileUtils.upload(file, path, fileName)) {
                       hashMap.put("file1",fileName);
                       String s = JSON.toJSONString(hashMap);
                       dustld.setImages(s);
                   }
               }
           }
           String value = dustld.getValue();
           JSONObject jsonObject = JSONObject.parseObject(value);
           jsonObject.put(road,format);
           String rsValue = JSONObject.toJSONString(jsonObject);
           dustld.setValue(rsValue);
           dustldMapper.updateById(dustld);
           return 200;
       }

    }

    /**
     * 下载日报
     * @param id
     * @return
     */
    @Override
    public Map<String,Object> dailyDustld(Integer id,List<MultipartFile> files) {
        //获取jar包所在目录
        ApplicationHome applicationHome = new ApplicationHome(getClass());
        //在jar包所在目录下生成一个upload文件夹用来存储上传的图片
        String path = applicationHome.getSource().getParentFile().toString() + "/static/img";

        HashMap<String, Object> map = new HashMap<>();
        ArrayList<DustForm> list1 = new ArrayList<>();
        ArrayList<DustForm> list2= new ArrayList<>();

        Dustld dustld = dustldMapper.selectById(id);
        if (ObjectUtils.isEmpty(dustld)){
            return null;
        }
        String pathList = getList(path, files);
            String images = dustld.getImages();
            if (ObjectUtils.isEmpty(images)){
                HashMap<String, Object> map1 = new HashMap<>();
                map1.put("file1","");
                if (pathList==null){
                    map1.put("file2","");
                }else {
                    map1.put("file2",pathList);
                }

                String s = JSON.toJSONString(map1);
                dustld.setImages(s);
                dustldMapper.updateById(dustld);
            }else {
                JSONObject jsonObject = JSONObject.parseObject(images);
                if (ObjectUtils.isEmpty(pathList)){
                    jsonObject.put("file2","");
                }else {
                    jsonObject.put("file2",pathList);
                }
                String s = JSON.toJSONString(jsonObject);
                dustld.setImages(s);
                dustldMapper.updateById(dustld);
            }


        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
        String stsrtTime = sdf.format(dustld.getTime());
        String substring = stsrtTime.substring(5, 14);
        String endTime = sdf.format(dustld.getEndTime());
        String substring1 = endTime.substring(5, 14);

        String value = dustld.getValue();
        JSONObject jsonObject = JSONObject.parseObject(value);
        Iterator<Map.Entry<String, Object>> iterator = jsonObject.entrySet().iterator();
        while (iterator.hasNext()) {
            DustForm dustForm = new DustForm();
            Map.Entry entry = (Map.Entry) iterator.next();
            dustForm.setRoad(entry.getKey().toString());
            dustForm.setValue(Double.parseDouble(entry.getValue().toString()));
            double aDouble = Double.parseDouble(entry.getValue().toString());
            list2.add(dustForm);
            if (aDouble>=0.3){
                list1.add(dustForm);
            }
        }

        //排序
        list1.sort(Comparator.comparing(DustForm::getValue).reversed());
        list2.sort(Comparator.comparing(DustForm::getValue).reversed());
        map.put("list1",list1);
        map.put("list2",list2);
        map.put("time",substring+"-"+substring1);
        map.put("images",JSON.parseObject(dustld.getImages()));
        return map;
    }

    @Autowired
    private ManageCoordinateMapper manageCoordinateMapper;
    @Autowired
    private MaxRoadMapper maxRoadMapper;
    @Autowired
    private OrganizationMapper organizationMapper;
    @Autowired
    private SysDictTypeService sysDictTypeService;

    @Override
    @Transactional
    public Map<String, Object> dailyDustlds(Map<String, Object> params) {
        SysDictData list = sysDictTypeService.listOne(SysDictTypeEnum.SYS_SECOND_CRUISER.getValue(),"dustld");
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
        Map<String, Object> orgInfo = (Map<String, Object>) userInfo.get("organization");
        Integer orgId = (Integer) orgInfo.get("id");
        String mac = params.get("mac").toString();
        List<Integer> orgList = organizationMapper.orgIdSpecialDevList(orgId,mac);
        if(CollectionUtils.isEmpty(orgList)){
            throw new BusinessException("该设备没有路段组织信息！");
        }
        String time1 = params.get("startTime").toString();
        String dateString1 = DateUtils.stringToDateString(time1, DateUtils.yyyy_MM_dd_HH_mm_ss_EN, DateUtils.yyyy_MM_dd_HH_mm_CN);
        String rsTime1 = dateString1.substring(5, 14);
        String time2 = params.get("endTime").toString();
        String dateString2 = DateUtils.stringToDateString(time2, DateUtils.yyyy_MM_dd_HH_mm_ss_EN, DateUtils.yyyy_MM_dd_HH_mm_CN);
        String rsTime2 = dateString2.substring(5, 14);
        HashMap<String, Object> rsMap = new HashMap<>();
        List<Map<String, Object>> dusts = historySecondCruiserMapper.getDusts(params);
        Map<String, List<DustldDTO>> collect = manageCoordinateMapper.CompareTo(orgList.get(0)).stream().collect(Collectors.groupingBy(o -> o.getName()));
        if (ObjectUtils.isEmpty(dusts) || ObjectUtils.isEmpty(collect)){
            return null;
        }
        Set<String> strings = collect.keySet();
        ArrayList<DustForm> list1 = new ArrayList<>();
        //所有的高值路段
        StringBuilder builder = new StringBuilder();

        int i = 1;
        long timestamp = System.currentTimeMillis();
        for (String string : strings) {
            DustForm dustForm = new DustForm();
            ArrayList<Double> doubleArrayList = new ArrayList<>();
            List<DustldDTO> dustldDTOS = collect.get(string);
            for (DustldDTO dustldDTO : dustldDTOS) {
                String flyLat = dustldDTO.getFlyLat();
                String flyLon = dustldDTO.getFlyLon();
                if (flyLon==null && flyLat==null){
                    continue;
                }
                double latDouble1 = Double.parseDouble(flyLat);
                double lonDouble1 = Double.parseDouble(flyLon);
                for (Map<String, Object> dust : dusts) {
                    String flyLat1 = Objects.nonNull(dust.get("flyLat")) ? dust.get("flyLat").toString() :"0";
                    String flyLon1 = Objects.nonNull(dust.get("flyLon")) ? dust.get("flyLon").toString() :"0";
                    double latDouble = Double.parseDouble(flyLat1);
                    double lonDouble = Double.parseDouble(flyLon1);
//                    String flyLon1 = dust.get("flyLon").toString();
                    if (latDouble1==latDouble && lonDouble1==lonDouble){
                        Double dustld = Objects.nonNull(dust.get("dustld"))?Double.parseDouble(dust.get("dustld").toString()):0d;
                        if(list.getDataValue().contains(",")){
                            List<String> resultStr = Arrays.asList(list.getDataValue().split(","));
                            if(resultStr.size() % 2 ==0){
                                dustld = numAvg(resultStr,BigDecimal.valueOf(dustld)).doubleValue();
                            }
                        }else {
                            BigDecimal dataValue = Objects.nonNull(list.getDataValue())?BigDecimal.valueOf(Double.parseDouble(list.getDataValue())):BigDecimal.ZERO;
                            dustld = BigDecimal.valueOf(dustld).add(dataValue).doubleValue();
                        }
                        doubleArrayList.add(dustld);
                        break;
                    }
                }
            }
            if (ObjectUtils.isEmpty(doubleArrayList)){
                continue;
            }
            Double ListAva = doubleArrayList.stream() .collect(Collectors.averagingDouble(Double::doubleValue));
            double rsAvg = new BigDecimal(ListAva/1000).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
            dustForm.setRoad(string);
            dustForm.setValue(rsAvg);
            list1.add(dustForm);
            if (rsAvg>=0.3){
             builder.append("("+i+")"+string);
             i++;
             //添加高值路段
                QueryWrapper<MaxRoad> wrapper = new QueryWrapper<>();
                wrapper.eq("name",string);
                wrapper.eq("time",DateUtils.getDate(time1,DateUtils.yyyy_MM_dd_EN));
                Integer integer = maxRoadMapper.selectCount(wrapper);
                if (integer==0){
                    MaxRoad maxRoad = new MaxRoad();
                    maxRoad.setData(rsAvg);
                    maxRoad.setName(string);
                    maxRoad.setTime(DateUtils.getDate(time1,DateUtils.yyyy_MM_dd_EN));
                    maxRoadMapper.insert(maxRoad);
                }
            }
        }
        long timestamp2 = System.currentTimeMillis();
        log.info(timestamp2-timestamp+"");
        //排序
        list1.sort(Comparator.comparing(DustForm::getValue).reversed());
        rsMap.put("list1",list1);


        //获取上一次的高值路段
        ArrayList<Map<String, Object>> list3 = new ArrayList<>();
        QueryWrapper<MaxRoad> wrapper = new QueryWrapper<>();
        wrapper.lt("time",DateUtils.getDate(time1,DateUtils.yyyy_MM_dd_EN));
        wrapper.orderByDesc("time");

        List<MaxRoad> maxRoads = maxRoadMapper.selectList(wrapper);
        String dateString3 = DateUtils.dateToDateString(maxRoads.get(0).getTime(), DateUtils.yyyy_MM_dd_CN);
        QueryWrapper<MaxRoad> wrapper2 = new QueryWrapper<>();
        wrapper2.eq("time",maxRoads.get(0).getTime());
        List<MaxRoad> maxRoads1 = maxRoadMapper.selectList(wrapper2);

        //获取两次路段相同的值
        for (MaxRoad road : maxRoads1) {
            for (DustForm dustForm : list1) {
                if (road.getName().equals(dustForm.getRoad())){
                    HashMap<String, Object> map = new HashMap<>();
                    map.put("road",road.getName());
                    map.put("value1",String.format("%.2f",road.getData()));
                    map.put("value2",String.format("%.2f",dustForm.getValue()));
                    map.put("value3",String.format("%.2f",road.getData()-dustForm.getValue()));
                    list3.add(map);
                }
            }
        }
        rsMap.put("data",ObjectUtils.isEmpty(builder)?"暂无高值路段":builder);
        rsMap.put("list3",list3);
        rsMap.put("time",rsTime1+"-"+rsTime2);
        rsMap.put("date1",dateString3.substring(5,10));
        rsMap.put("date2",dateString1.substring(5,10));
        return rsMap;
    }

    /**
     * 查询尘负荷高值
     * @param id
     * @return
     */
    @Override
    public Map<String,Object> selectDust(Integer id) {

        HashMap<String, Object> rsMap = new HashMap<>();
        ArrayList<DustForm> list1 = new ArrayList<>();

        Dustld dustld = dustldMapper.selectById(id);
        if (ObjectUtils.isEmpty(dustld)){
            return null;
        }
        String value = dustld.getValue();
        JSONObject jsonObject = JSONObject.parseObject(value);
        Iterator<Map.Entry<String, Object>> iterator = jsonObject.entrySet().iterator();
        while (iterator.hasNext()) {
            DustForm dustForm = new DustForm();
            Map.Entry entry = (Map.Entry) iterator.next();
            dustForm.setRoad(entry.getKey().toString());
            dustForm.setValue(Double.parseDouble(entry.getValue().toString()));
            double aDouble = Double.parseDouble(entry.getValue().toString());
            if (aDouble>=0.3){
                list1.add(dustForm);
            }
        }
        if (!ObjectUtils.isEmpty(list1)){
            list1.sort(Comparator.comparing(DustForm::getValue).reversed());
        }
        rsMap.put("list",list1);
        rsMap.put("count",list1.size());
        return rsMap;
    }

    /**
     * 查询日报记录
     * @param params
     * @return
     */
    @Override
    public List<Dustld> selectAll(Map<String, Object> params) {
        String mac = params.get("mac").toString();
        String time1 = params.get("startTime").toString();
        String time2 = params.get("endTime").toString();

        QueryWrapper<Dustld> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("mac",mac).between("time",time1,time2);
        List<Dustld> dustlds = dustldMapper.selectList(queryWrapper);
        if (ObjectUtils.isEmpty(dustlds)){
            return null;
        }
        return dustlds;
    }


    //获取图片地址
    private String getList(String path, List<MultipartFile> files1) {
        ArrayList<String> images = new ArrayList<>();
        if (!ObjectUtils.isEmpty(files1)){
            for (MultipartFile file : files1) {
                String fileType = file.getContentType();
                if ("image/jpg".equals(fileType) || "image/png".equals(fileType) || "image/jpeg".equals(fileType)){
                    //获取文件名
                    String fileName = file.getOriginalFilename();
                    //获取文件后缀名
                    String suffixName = fileName.substring(fileName.lastIndexOf("."));
                    //每一次都需要
                    fileName.substring(fileName.lastIndexOf("."));
                    //重新生成文件名
                    fileName = UUID.randomUUID() + suffixName;
                    //图片上传
                    if (FileUtils.upload(file, path, fileName)) {
                        images.add(fileName);
                    }
                }
            }
        }

        if (!ObjectUtils.isEmpty(images)) {
            String image = images.stream()
                    .map(String::valueOf)
                    .collect(Collectors.joining(","));

            return image;
        }
        return null;
    }
    private BigDecimal numAvg(List<String> list , BigDecimal num){
        int nums = 1;
        for (int i=0;i<list.size();i=i+2){
            if(num.compareTo(BigDecimal.valueOf(Double.parseDouble(list.get(i))))>= 0 ){
                return num.add(BigDecimal.valueOf(Double.parseDouble(list.get(i+1))));
            }
            nums+=2;
        }
        return num;
    }
}