package com.ruoyi.web.controller.manage;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.fuzhou.domain.DpEquipment;
import com.ruoyi.fuzhou.domain.ReceiveElectricityValue;
import com.ruoyi.fuzhou.domain.ReceiveOilValue;
import com.ruoyi.fuzhou.domain.ReceiveWaterValue;
import com.ruoyi.fuzhou.domain.vo.DpEquipmentVO;
import com.ruoyi.fuzhou.domain.vo.QueryAnalysisVO;
import com.ruoyi.fuzhou.domain.vo.ReceiveValueListVo;
import com.ruoyi.fuzhou.enums.DataTypeEnum;
import com.ruoyi.fuzhou.service.*;
import com.ruoyi.manage.domain.DpEquipmentType;
import com.ruoyi.manage.domain.DsTaskList;
import com.ruoyi.manage.domain.SysFileManage;
import com.ruoyi.manage.domain.vo.Tree;
import com.ruoyi.manage.service.DpEquipmentTypeService;
import com.ruoyi.manage.service.SysFileService;
import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.web.controller.fuzhou.ReceiveInfoController;
import io.swagger.v3.oas.annotations.Hidden;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author zhangyy
 * @since 2025-03-11
 */
@RestController
@RequestMapping("/dp/dpEquipment")
@Tag(name = "大屏--设备管理")
public class DpEquipmentController extends BaseController {
    @Resource
    private EquipmentService dpEquipmentService;

    @Resource
    private ReceiveInfoController receiveInfoController;

    @Resource
    private ISysDictDataService iSysDictDataService;

    @Resource
    ReceiveModuleInfoService receiveModuleInfoService;

    @Resource
    DsTaskListController dsTaskListController;

    @Resource
    private ReceiveOilValueService receiveOilValueService;

    @Resource
    private ReceiveWaterValueService receiveWaterValueService;

    @Resource
    private ReceiveElectricityValueService receiveElectricityValueService;

    @Resource
    private HikService hikService;

    @Resource
    private DpEquipmentTypeService dpEquipmentTypeService;

    @Autowired
    SysFileService sysFileService;
    @Autowired
    RuoYiConfig ruoYiConfig;


    @GetMapping("/list")
    @Operation(summary = "设备列表")
    public AjaxResult getList(Integer beId) {
        List<Tree> treeList = new ArrayList<>();
        if (null != beId) {
            List<DpEquipmentVO> list = dpEquipmentService.getListByBeId(beId);
            if (null != list) {
                Map<String, List<DpEquipmentVO>> result = list.stream().collect(Collectors.groupingBy(DpEquipmentVO::getEqutype));
                treeList = buildTree(result);
            }
        }
        return AjaxResult.success(treeList);
    }

    private List<Tree> buildTree(Map<String, List<DpEquipmentVO>> result) {
        // 构建树节点
        List<Tree> tree = new ArrayList<>();
        for (Map.Entry<String, List<DpEquipmentVO>> entry : result.entrySet()) {
            Tree typeNode = new Tree();
            typeNode.setId(generateId());
            typeNode.setLabel(entry.getKey());
            typeNode.setChildren(entry.getValue().stream()
                    .map(equipment -> {
                        Tree equipmentNode = new Tree();
                        equipmentNode.setLabel(equipment.getEquName());
                        equipmentNode.setId(equipment.getId());
                        equipmentNode.setIntervalTime(equipment.getIntervalTime());
                        equipmentNode.setPeriodTime(equipment.getPeriodTime());
                        equipmentNode.setIcon(equipment.getIcon());
                        return equipmentNode;
                    })
                    .collect(Collectors.toList()));
            typeNode.setDisabled(true);
            tree.add(typeNode);
        }

        return tree;

    }

    //生成不重复ID
    private int generateId() {
        UUID uuid = UUID.randomUUID();
        long hash = uuid.hashCode();
        return (int) (hash & Integer.MAX_VALUE);
    }

    @GetMapping("/pageList")
    @Operation(summary = "泊位设备分页列表")
    public TableDataInfo getPageList(DpEquipment dpEquipmentVO) {
        return dpEquipmentService.getPageList(dpEquipmentVO);
    }

    @Operation(summary = "设备详情")
    @GetMapping("/{id}")
    public AjaxResult getById(@PathVariable Integer id) {
        DpEquipmentVO dpEquipmentVO = dpEquipmentService.selectById(id);
        DpEquipment dpEquipment1 = receiveModuleInfoService.getIp(String.valueOf(dpEquipmentVO.getId()), dpEquipmentVO.getEquipmentTypeId());
        dpEquipmentVO.setIp(dpEquipment1.getIp());
        dpEquipmentVO.setPort(dpEquipment1.getPort());
        dpEquipmentVO.setDeviceAddress(dpEquipment1.getDeviceAddress());
        return AjaxResult.success(dpEquipmentVO);
    }

    @GetMapping("/getListByWhId")
    @Operation(summary = "根据码头ID获取设备树")
    public AjaxResult getListByWhId(Integer whId) {
        List<Tree> treeList = new ArrayList<>();
        List<DpEquipmentVO> list = dpEquipmentService.getListByWhId(whId);
        if (null != list) {
            Map<String, List<DpEquipmentVO>> result = list.stream().collect(Collectors.groupingBy(DpEquipmentVO::getEqutype));
            treeList = buildTree(result);
        }
        //根据系统字典排序
        SysDictData sysDictData = new SysDictData();
        sysDictData.setDictType("dp_equipment_type");
        List<SysDictData> dictDataList = iSysDictDataService.selectDictDataList(sysDictData);
        Map<String, Integer> dictSortMap = new HashMap<>();
        for (SysDictData dictData : dictDataList) {
            dictSortMap.put(dictData.getDictLabel(), dictData.getDictSort().intValue());
        }
        treeList.sort(Comparator.comparingInt(tree -> dictSortMap.getOrDefault(tree.getLabel(), Integer.MAX_VALUE)));

        return AjaxResult.success(treeList);
    }

    @GetMapping("/getEquipmentsByWhId")
    @Operation(summary = "根据码头ID获取设备详情列表")
    public AjaxResult getEquipmentsByWhId(Integer whId) {
        List<DpEquipmentVO> list = dpEquipmentService.getListByWhId(whId);
        List<DpEquipmentVO> resList = new ArrayList<>();
        resList = equipmentStatusHandling(list);

        return AjaxResult.success(resList);
    }

    @GetMapping("/getEquipmentsCount")
    @Operation(summary = "设备状态数量统计")
    public AjaxResult getEquipmentsCount(Integer whId) {
        List<DpEquipmentVO> list = dpEquipmentService.getListByWhId(whId);
        List<DpEquipmentVO> resList = new ArrayList<>();
        resList = equipmentStatusHandling(list);

        LambdaQueryWrapper<DpEquipmentType> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.orderByAsc(DpEquipmentType::getId);
        List<DpEquipmentType> typeList = dpEquipmentTypeService.list(lambdaQueryWrapper);

        Map<Integer, List<DpEquipmentVO>> groupMap = resList.stream().collect(Collectors.groupingBy(DpEquipmentVO::getEquipmentTypeId));
        JSONArray jsonArray = new JSONArray();
        List<Integer> typeIds = Arrays.asList(1, 2, 3, 4);

        for (Map.Entry<Integer, List<DpEquipmentVO>> entry : groupMap.entrySet()) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("name", entry.getValue().get(0).getEqutype());
            Long online = (long) entry.getValue().size();
            if (typeIds.contains(entry.getKey())) {
                online = entry.getValue().stream().filter(e -> e.getStatus() == 1).count();
            }
            jsonObject.put("online", online);
            jsonObject.put("total", entry.getValue().size());
            jsonObject.put("typeId", entry.getKey());
            jsonArray.add(jsonObject);
        }

        Set<Integer> typeIDs = groupMap.keySet();
        for (DpEquipmentType dpEquipmentType : typeList) {
            if (!typeIDs.contains(dpEquipmentType.getId())) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("name", dpEquipmentType.getTypeName());
                jsonObject.put("online", 0);
                jsonObject.put("total", 0);
                jsonObject.put("typeId", dpEquipmentType.getId());
                jsonArray.add(jsonObject);
            }
        }

        List<JSONObject> objects = jsonArray.toList(JSONObject.class);
        objects.sort(Comparator.comparingInt(o -> o.getIntValue("typeId")));

        jsonArray.clear();
        jsonArray.addAll(objects);

        return AjaxResult.success(jsonArray);
    }


    @GetMapping("/getEquipmentsByBeId")
    @Operation(summary = "根据泊位ID获取设备工况信息")
    @Hidden
    public AjaxResult getEquipmentsByBeId(@RequestParam Integer beId, @RequestParam String startTime) {
        List<DpEquipmentVO> list = dpEquipmentService.getListByBeId(beId);
        return AjaxResult.success(list);
    }

    @GetMapping("/getListByBeIdTypeId")
    @Operation(summary = "根据泊位ID和设备类型ID获取设备信息列表")
    public AjaxResult getListByBeIdTypeId(@RequestParam Integer beId, @RequestParam Integer typeId) {
        R<DsTaskList> res = dsTaskListController.getByBeId(beId);
        DsTaskList dsTaskList = res.getData();
        Date psTime = dsTaskList.getPsTime();
        List<Integer> typeIds = new ArrayList<>();
        if (typeId == 1) {
            typeIds.add(1);
            typeIds.add(12);
            typeIds.add(13);
            typeIds.add(14);
        } else {
            typeIds.add(typeId);
        }
        List<DpEquipmentVO> equList = dpEquipmentService.getListByBeIdTypeId(beId, typeIds);
        List<DpEquipmentVO> voList = new ArrayList<>();
        for (DpEquipmentVO dpEquipmentVO : equList) {
            ReceiveValueListVo voEL = new ReceiveValueListVo();
            voEL.setId(dpEquipmentVO.getId().longValue());
            voEL.setEndTime(psTime);
            List dataList = receiveInfoController.dataList(voEL).getData();
            if (!dataList.isEmpty()) {
                dpEquipmentVO.setDataHis(dataList.get(0));
            }
            voList.add(dpEquipmentVO);
        }
        List<DpEquipmentVO> resList = equipmentStatusHandling(voList);

        JSONObject object = new JSONObject();
        if (!equList.isEmpty()) {
            ReceiveValueListVo vo = new ReceiveValueListVo();
            ReceiveValueListVo voNew = new ReceiveValueListVo();
            vo.setId(equList.get(0).getId().longValue());
            vo.setEndTime(psTime);
            voNew.setId(equList.get(0).getId().longValue());
            List dataList = receiveInfoController.dataList(vo).getData();
            List dataListNew = receiveInfoController.dataList(voNew).getData();
            List tableList = receiveInfoController.tableList(vo.getId()).getData();
            object.put("equList", resList);
            if (!dataListNew.isEmpty()) {
                object.put("dataOne", dataListNew.get(0));
            } else {
                object.put("dataOne", "");
            }
            if (!dataList.isEmpty()) {
                object.put("dataHis", dataList.get(0));
            } else {
                object.put("dataHis", "");
            }
            object.put("tableList", tableList);
        }
        return AjaxResult.success(object);
    }

    @GetMapping("/getDataOneById")
    @Operation(summary = "根据ID获取最新一条数据")
    public AjaxResult getDataOneById(Integer id) {
        DpEquipmentVO dpEquipmentVO = dpEquipmentService.selectById(id);
        R<DsTaskList> res = dsTaskListController.getByBeId(dpEquipmentVO.getBeId());
        DsTaskList dsTaskList = res.getData();
        Date psTime = dsTaskList.getPsTime();
        Date peTime = dsTaskList.getPeTime();
        Integer equTypeId = dpEquipmentVO.getEquipmentTypeId();

        ReceiveValueListVo vo = new ReceiveValueListVo();
        vo.setId(id.longValue());
        vo.setStartTime(psTime);
        vo.setEndTime(peTime);
        JSONObject object = new JSONObject();
        List dataList = receiveInfoController.dataList(vo).getData();
        List tableList = receiveInfoController.tableList(vo.getId()).getData();
        if (dataList.size() > 0) {
            object.put("dataOne", dataList.get(0));
            object.put("equUpTime", getEquUptime(dataList, equTypeId));
        } else {
            object.put("dataOne", new JSONObject());
            object.put("equUpTime", null);
        }
        object.put("tableList", tableList);
        return AjaxResult.success(object);
    }

    private List<DpEquipmentVO> equipmentStatusHandling(List<DpEquipmentVO> list) {

        List<DpEquipmentVO> resList = new ArrayList<>();
        Map<String, Integer> onlineMap = new LinkedHashMap<>();
        ArrayList<String> arrayList = new ArrayList<>();

        for (DpEquipmentVO equipmentVO : list) {
            Integer typeId = equipmentVO.getEquipmentTypeId();
            if (typeId == 4 && equipmentVO.getFieldName() != null && !equipmentVO.getFieldName().isEmpty()) {
                arrayList.add(equipmentVO.getFieldName());
            }
        }
        String[] indexCodes = arrayList.toArray(new String[arrayList.size()]);
        onlineMap = hikService.getCameraOnline(indexCodes);
        for (DpEquipmentVO dpEquipmentVO : list) {
            Integer typeId = dpEquipmentVO.getEquipmentTypeId();
            Integer id = dpEquipmentVO.getId();
            if (DataTypeEnum.LIJIUOIL.getCode().equals(typeId) || DataTypeEnum.OIL.getCode().equals(typeId) ||
                    DataTypeEnum.LIJIUJUN.getCode().equals(typeId)) {
                ReceiveOilValue receiveOilValue = receiveOilValueService.getOne(new LambdaQueryWrapper<ReceiveOilValue>() {{
                    or().eq(ReceiveOilValue::getDeviceName, String.valueOf(id))
                            .orderByDesc(ReceiveOilValue::getCreateTime).last("LIMIT 1");
                }});
                if (receiveOilValue != null && receiveOilValue.getOilTimeFlow() != null) {
                    if (Double.parseDouble(receiveOilValue.getOilTimeFlow()) != 0.0) {
                        dpEquipmentVO.setStatus(1);
                    }
                }

            } else if (DataTypeEnum.WATER_FLOW.getCode().equals(typeId) || DataTypeEnum.WATER_YA.getCode().equals(typeId)
                    || DataTypeEnum.WATER_DEPT.getCode().equals(typeId)) {
                ReceiveWaterValue receiveWaterValue = receiveWaterValueService.getOne(new LambdaQueryWrapper<ReceiveWaterValue>() {{
                    or().eq(ReceiveWaterValue::getDeviceName, String.valueOf(id))
                            .orderByDesc(ReceiveWaterValue::getCreateTime).last("LIMIT 1");
                }});
                if (receiveWaterValue != null && receiveWaterValue.getTimeFlow() != null) {
                    if (Double.parseDouble(receiveWaterValue.getTimeFlow()) != 0.0) {
                        dpEquipmentVO.setStatus(1);
                    }
                }

            } else if (DataTypeEnum.ELECTRICITY.getCode().equals(typeId)) {
                ReceiveElectricityValue receiveElectricityValue = receiveElectricityValueService.getOne(new LambdaQueryWrapper<ReceiveElectricityValue>() {{
                    or().eq(ReceiveElectricityValue::getDeviceName, String.valueOf(id))
                            .orderByDesc(ReceiveElectricityValue::getCreateTime).last("LIMIT 1");
                }});
                if (receiveElectricityValue != null && receiveElectricityValue.getCurrentA() != null
                        && receiveElectricityValue.getCurrentB() != null && receiveElectricityValue.getCurrentC() != null) {
                    if (Double.parseDouble(receiveElectricityValue.getCurrentA()) != 0.0 || Double.parseDouble(receiveElectricityValue.getCurrentB()) != 0.0
                            || Double.parseDouble(receiveElectricityValue.getCurrentC()) != 0.0) {
                        dpEquipmentVO.setStatus(1);
                    }
                }

            } else if (typeId == 4) {
                Integer status = onlineMap.getOrDefault(dpEquipmentVO.getFieldName(), 0);
                dpEquipmentVO.setStatus(status);
            }
            resList.add(dpEquipmentVO);
        }
        return resList;
    }

    private String getEquUptime(List dataList, Integer equTypeId) {
        Integer size = dataList.size();
        if (equTypeId == 1 || equTypeId == 12 || equTypeId == 13 || equTypeId == 14) {
            for (int i = size - 1; i >= 0; i--) {
                ReceiveOilValue receiveOilValue = (ReceiveOilValue) dataList.get(i);
                if (receiveOilValue.getOilTimeFlow() != null
                        && Double.parseDouble(receiveOilValue.getOilTimeFlow()) != 0.0) {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String timeStr = sdf.format(receiveOilValue.getCreateTime());
                    return timeCalculator(timeStr);
                }
            }
        } else if (equTypeId == 2) {
            for (int k = size - 1; k >= 0; k--) {
                ReceiveWaterValue receiveWaterValue = (ReceiveWaterValue) dataList.get(k);
                if (receiveWaterValue.getTimeFlow() != null
                        && Double.parseDouble(receiveWaterValue.getTimeFlow()) != 0.0) {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String timeStr = sdf.format(receiveWaterValue.getCreateTime());
                    return timeCalculator(timeStr);
                }
            }
        }
        return null;
    }

    private String timeCalculator(String timeStr) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.parse(timeStr, formatter);
        LocalDateTime now = LocalDateTime.now();
        Duration duration = Duration.between(dateTime, now);
        long total = Math.abs(duration.toMinutes());
        long hour = total / 60;
        long minutes = total % 60;
        return hour + "小时" + minutes + "分钟";
    }

    @GetMapping("/getXyzById")
    @Operation(summary = "根据ID获取设备详情")
    public AjaxResult getXyzById(Integer id) {
        DpEquipment dpEquipment = dpEquipmentService.getById(id);
        DpEquipment dpEquipment1 = receiveModuleInfoService.getIp(String.valueOf(dpEquipment.getId()), dpEquipment.getEquipmentTypeId());
        dpEquipment.setIp(dpEquipment1.getIp());
        dpEquipment.setPort(dpEquipment1.getPort());
        dpEquipment.setDeviceAddress(dpEquipment1.getDeviceAddress());
        return AjaxResult.success(dpEquipment);
    }

    //获取设备数据与表头
    @PostMapping("/getDataById")
    @Operation(summary = "获取设备数据与表头")
    public AjaxResult getDataById(@Validated @RequestBody ReceiveValueListVo vo) {
        List dataList = receiveInfoController.dataList(vo).getData();
        List tableList = receiveInfoController.tableList(vo.getId()).getData();
        JSONObject object = new JSONObject();
        object.put("dataList", dataList);
        object.put("tableList", tableList);
        return AjaxResult.success(object);
    }

    //获取设备数据与表头(分页)
    @PostMapping("/getPageListById")
    @Operation(summary = "获取设备数据与表头(分页)")
    public AjaxResult getPageListById(@Validated @RequestBody ReceiveValueListVo vo) {
        List dataList = receiveInfoController.dataList(vo).getData();
        List tableList = receiveInfoController.tableList(vo.getId()).getData();

        List sampledList = new ArrayList();
        for (int i = 0; i < dataList.size(); i++) {
            if (i % 5 == 0) {
                sampledList.add(dataList.get(i));
            }
        }
        TableDataInfo dataInfo = paginate(sampledList, vo.getPageNum(), vo.getPageSize());

//        TableDataInfo dataInfo = paginate(dataList, vo.getPageNum(), vo.getPageSize());
        JSONObject object = new JSONObject();
        object.put("dataList", dataInfo);
        object.put("tableList", tableList);
        return AjaxResult.success(object);
    }

    //获取设备数据与表头(分页)
    @PostMapping("/getPageListByIdRuoyi")
    @Operation(summary = "获取设备数据与表头(分页)")
    public AjaxResult getPageListByIdRuoyi(@Validated @RequestBody ReceiveValueListVo vo) {
        List dataList = receiveInfoController.dataList(vo).getData();
        List tableList = receiveInfoController.tableList(vo.getId()).getData();

        TableDataInfo dataInfo = paginate(dataList, vo.getPageNum(), vo.getPageSize());
        JSONObject object = new JSONObject();
        object.put("dataList", dataInfo);
        object.put("tableList", tableList);
        return AjaxResult.success(object);
    }


    /**
     * 新增泊位--设备
     */
    @Operation(summary = "新增")
    @PostMapping
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult add(@RequestBody DpEquipment dpEquipment) {
        dpEquipment.setEquSeType(dpEquipment.getEquipmentTypeId());
        dpEquipmentService.save(dpEquipment);
        receiveModuleInfoService.saveByModule(String.valueOf(dpEquipment.getId()), dpEquipment.getIp(), dpEquipment.getPort(), dpEquipment.getDeviceAddress(), dpEquipment.getEquipmentTypeId());
        return toAjax(true);
    }

    /**
     * 修改泊位--设备
     */
    @Operation(summary = "修改")
    @PutMapping
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult edit(@RequestBody DpEquipment dpEquipment) {
        DpEquipment equipment = dpEquipmentService.getById(dpEquipment.getId());
        if (equipment == null) {
            throw new ServiceException("设备不存在！");
        }
        receiveModuleInfoService.removeByModule(String.valueOf(equipment.getId()), equipment.getEquipmentTypeId());
        dpEquipment.setEquSeType(dpEquipment.getEquipmentTypeId());
        dpEquipmentService.updateById(dpEquipment);
        receiveModuleInfoService.saveByModule(String.valueOf(dpEquipment.getId()), dpEquipment.getIp(), dpEquipment.getPort(), dpEquipment.getDeviceAddress(), dpEquipment.getEquipmentTypeId());
        return toAjax(true);
    }

    /**
     * 删除泊位--设备
     */
    @Operation(summary = "删除")
    @Transactional(rollbackFor = Exception.class)
    @DeleteMapping("/{id}")
    public AjaxResult remove(@PathVariable Integer id) {
        DpEquipment equipment = dpEquipmentService.getById(id);
        if (equipment == null) {
            throw new ServiceException("设备不存在！");
        }
        receiveModuleInfoService.removeByModule(String.valueOf(equipment), equipment.getEquipmentTypeId());
        return toAjax(dpEquipmentService.removeById(id));
    }

    //多条件查询设备列表
    public List<DpEquipmentVO> queryDpEquipmentList(Integer beId, Integer typeId) {
        List<Integer> typeIds = new ArrayList<>();
        if (typeId == 1) {
            typeIds.add(1);
            typeIds.add(12);
            typeIds.add(13);
            typeIds.add(14);
        } else {
            typeIds.add(typeId);
        }
        List<DpEquipmentVO> equList = dpEquipmentService.getListByBeIdTypeId(beId, typeIds);
        return equList;
    }

    //多条件查询水深态势分析数据
    @PostMapping("/queryWaterDeepAnalysis")
    @Operation(summary = "多条件查询水深态势分析数据")
    public AjaxResult queryWaterDeepAnalysis(@Validated @RequestBody QueryAnalysisVO queryAnalysisVO) {
        List<String> ids = new ArrayList<>();
        Integer beId = queryAnalysisVO.getBeId();
        List<DpEquipmentVO> equList = queryDpEquipmentList(beId, 7);

        JSONArray jsonArray = new JSONArray();
        if (equList.size() > 0) {
            for (DpEquipmentVO dpEquipmentVO : equList) {
                ids.add(String.valueOf(dpEquipmentVO.getId()));
            }

            LambdaQueryWrapper<ReceiveWaterValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            Date startTime = queryAnalysisVO.getStartTime();
            Date endTime = queryAnalysisVO.getEndTime();
            Integer interval = queryAnalysisVO.getInterval();

            Map<String, Date> timeMap = new LinkedHashMap<>();
            LocalDate endDate = LocalDate.now();
            LocalDate startDate = LocalDate.now().minusDays(interval);

            if (startTime != null && endTime != null) {
                timeMap = convertStartEndTime(startTime, endTime);
                startDate = convertDate(timeMap.get("start")).toLocalDate();
                endDate = convertDate(timeMap.get("end")).toLocalDate();
            } else {
                timeMap = getStartEndTime(interval);
            }

            lambdaQueryWrapper.in(ReceiveWaterValue::getDeviceName, ids)
                    .ge(ReceiveWaterValue::getCreateTime, timeMap.get("start"))
                    .lt(ReceiveWaterValue::getCreateTime, timeMap.get("end"))
                    .orderByDesc(ReceiveWaterValue::getCreateTime);
            List<ReceiveWaterValue> waterValues = receiveWaterValueService.list(lambdaQueryWrapper);

            List<LocalDate> dateRange = startDate.datesUntil(endDate.plusDays(1)).collect(Collectors.toList());

            Map<LocalDate, List<ReceiveWaterValue>> groups = new LinkedHashMap<>();
            for (LocalDate localDate : dateRange) {
                groups.put(localDate, new ArrayList<>());
            }
            for (ReceiveWaterValue receiveWaterValue : waterValues) {
                LocalDateTime localDateTime = convertDate(receiveWaterValue.getCreateTime());
                LocalDate localDate = localDateTime.toLocalDate();
                groups.computeIfPresent(localDate, (key, list) -> {
                    list.add(receiveWaterValue);
                    return list;
                });
            }

            for (Map.Entry<LocalDate, List<ReceiveWaterValue>> entry : groups.entrySet()) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("date", entry.getKey());
                jsonObject.put("avg", "0.0");
                jsonObject.put("dif", "0.0");
                if (entry.getValue().size() > 0) {
                    Map<String, Double> map = waterDeepMaxMin(entry.getValue());
                    Double max = map.get("max");
                    Double min = map.get("min");
                    jsonObject.put("avg", String.format("%.3f", (max + min) / 2));
                    jsonObject.put("dif", String.format("%.3f", (max - min)));
                }
                jsonArray.add(jsonObject);
            }
        }
        return AjaxResult.success(jsonArray);
    }

    private LocalDateTime convertDate(Date date) {
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    private Map<String, Date> convertStartEndTime(Date startTime, Date endTime) {
        SimpleDateFormat timeSDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat dateSDF = new SimpleDateFormat("yyyy-MM-dd");

        String dateStartStr = dateSDF.format(startTime);
        String dateEndStr = dateSDF.format(endTime);

        String startTimeStr = " 00:00:00";
        String endTimeStr = " 23:59:59";

        String newStartStr = dateStartStr + startTimeStr;
        String newEndStr = dateEndStr + endTimeStr;

        Map<String, Date> map = new LinkedHashMap<>();
        try {
            Date start = timeSDF.parse(newStartStr);
            Date end = timeSDF.parse(newEndStr);
            map.put("start", start);
            map.put("end", end);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        return map;
    }

    private Map<String, Date> getStartEndTime(Integer interval) {
        LocalDate endDate = LocalDate.now();
        LocalDate startDate = LocalDate.now().minusDays(interval);
        String startTime = " 00:00:00";
        String endTime = " 23:59:59";
        DateTimeFormatter formatterDate = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        DateTimeFormatter formatterTime = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String startStr = startDate.format(formatterDate) + startTime;
        String endStr = endDate.format(formatterDate) + endTime;
        LocalDateTime localDateTimeStart = LocalDateTime.parse(startStr, formatterTime);
        LocalDateTime localDateTimeEnd = LocalDateTime.parse(endStr, formatterTime);
        Instant instantStart = localDateTimeStart.atZone(ZoneId.systemDefault()).toInstant();
        Instant instantEnd = localDateTimeEnd.atZone(ZoneId.systemDefault()).toInstant();
        Date start = Date.from(instantStart);
        Date end = Date.from(instantEnd);

        Map<String, Date> map = new HashMap<>();
        map.put("start", start);
        map.put("end", end);
        return map;
    }

    private Map<String, Double> waterDeepMaxMin(List<ReceiveWaterValue> list) {
        OptionalDouble max = list.stream()
                .mapToDouble(e -> Double.parseDouble(e.getWaterDeep()))
                .max();
        OptionalDouble min = list.stream()
                .mapToDouble(e -> Double.parseDouble(e.getWaterDeep()))
                .min();
        Map<String, Double> map = new HashMap<>();
        map.put("max", max.orElse(0.0));
        map.put("min", min.orElse(0.0));
        return map;
    }

    private Double convertString(String str) {
        if (str == null || str.trim().isEmpty()) {
            return 0.0;
        }
        if (str.matches(".*[eE].*")) {
            return 0.0;
        }
        try {
            double value = Double.parseDouble(str);
            return Math.abs(value);
        } catch (Exception e) {
            return 0.0;
        }
    }

    //多条件查询电表态势分析数据
    @PostMapping("/queryElectricityAnalysis")
    @Operation(summary = "多条件查询电表态势分析数据")
    public AjaxResult queryElectricityAnalysis(@Validated @RequestBody QueryAnalysisVO queryAnalysisVO) {
        List<String> ids = new ArrayList<>();
        Integer beId = queryAnalysisVO.getBeId();
        List<DpEquipmentVO> equList = queryDpEquipmentList(beId, 3);

        JSONArray jsonArray = new JSONArray();
        if (equList.size() > 0) {
            for (DpEquipmentVO dpEquipmentVO : equList) {
                ids.add(String.valueOf(dpEquipmentVO.getId()));
            }

            LambdaQueryWrapper<ReceiveElectricityValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            Date startTime = queryAnalysisVO.getStartTime();
            Date endTime = queryAnalysisVO.getEndTime();
            Integer interval = queryAnalysisVO.getInterval();

            Map<String, Date> timeMap = new LinkedHashMap<>();
            LocalDate endDate = LocalDate.now();
            LocalDate startDate = LocalDate.now().minusDays(interval);

            if (startTime != null && endTime != null) {
                timeMap = convertStartEndTime(startTime, endTime);
                startDate = convertDate(timeMap.get("start")).toLocalDate();
                endDate = convertDate(timeMap.get("end")).toLocalDate();
            } else {
                timeMap = getStartEndTime(interval);
            }

            lambdaQueryWrapper.in(ReceiveElectricityValue::getDeviceName, ids)
                    .ge(ReceiveElectricityValue::getCreateTime, timeMap.get("start"))
                    .lt(ReceiveElectricityValue::getCreateTime, timeMap.get("end"))
                    .orderByDesc(ReceiveElectricityValue::getCreateTime);
            List<ReceiveElectricityValue> electricityValues = receiveElectricityValueService.list(lambdaQueryWrapper);

            List<LocalDate> dateRange = startDate.datesUntil(endDate.plusDays(1)).collect(Collectors.toList());

            Map<LocalDate, List<ReceiveElectricityValue>> groups = new LinkedHashMap<>();
            for (LocalDate localDate : dateRange) {
                groups.put(localDate, new ArrayList<>());
            }
            for (ReceiveElectricityValue receiveElectricityValue : electricityValues) {
                LocalDateTime localDateTime = convertDate(receiveElectricityValue.getCreateTime());
                LocalDate localDate = localDateTime.toLocalDate();
                groups.computeIfPresent(localDate, (key, list) -> {
                    list.add(receiveElectricityValue);
                    return list;
                });
            }

            for (Map.Entry<LocalDate, List<ReceiveElectricityValue>> entry : groups.entrySet()) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("date", entry.getKey());
                jsonObject.put("avg", "0.0");
                if (entry.getValue().size() > 0) {
                    List<ReceiveElectricityValue> valueList = entry.getValue();
                    Integer size = valueList.size();
                    Double total = 0.0;
                    for (ReceiveElectricityValue receiveElectricityValue : valueList) {
                        Double zhengValue = convertString(receiveElectricityValue.getZhengPower());
                        total = total + zhengValue;
                    }
                    jsonObject.put("avg", String.format("%.3f", total / size));
                }
                jsonArray.add(jsonObject);
            }
        }
        return AjaxResult.success(jsonArray);
    }


    //多条件查询油表态势分析数据
    @PostMapping("/queryOilAnalysis")
    @Operation(summary = "多条件查询油表态势分析数据")
    public AjaxResult queryOilAnalysis(@Validated @RequestBody QueryAnalysisVO queryAnalysisVO) {
        List<String> ids = new ArrayList<>();
        Integer beId = queryAnalysisVO.getBeId();
        List<DpEquipmentVO> equList = queryDpEquipmentList(beId, 1);

        JSONArray jsonArray = new JSONArray();
        if (equList.size() > 0) {
            for (DpEquipmentVO dpEquipmentVO : equList) {
                ids.add(String.valueOf(dpEquipmentVO.getId()));
            }

            LambdaQueryWrapper<ReceiveOilValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            Date startTime = queryAnalysisVO.getStartTime();
            Date endTime = queryAnalysisVO.getEndTime();
            Integer interval = queryAnalysisVO.getInterval();

            Map<String, Date> timeMap = new LinkedHashMap<>();
            LocalDate endDate = LocalDate.now();
            LocalDate startDate = LocalDate.now().minusDays(interval);

            if (startTime != null && endTime != null) {
                timeMap = convertStartEndTime(startTime, endTime);
                startDate = convertDate(timeMap.get("start")).toLocalDate();
                endDate = convertDate(timeMap.get("end")).toLocalDate();
            } else {
                timeMap = getStartEndTime(interval);
            }

            lambdaQueryWrapper.in(ReceiveOilValue::getDeviceName, ids)
                    .ge(ReceiveOilValue::getCreateTime, timeMap.get("start"))
                    .lt(ReceiveOilValue::getCreateTime, timeMap.get("end"))
                    .orderByDesc(ReceiveOilValue::getCreateTime);
            List<ReceiveOilValue> oilValues = receiveOilValueService.list(lambdaQueryWrapper);

            List<LocalDate> dateRange = startDate.datesUntil(endDate.plusDays(1)).collect(Collectors.toList());

            Map<LocalDate, List<ReceiveOilValue>> groups = new LinkedHashMap<>();
            for (LocalDate localDate : dateRange) {
                groups.put(localDate, new ArrayList<>());
            }
            for (ReceiveOilValue receiveOilValue : oilValues) {
                LocalDateTime localDateTime = convertDate(receiveOilValue.getCreateTime());
                LocalDate localDate = localDateTime.toLocalDate();
                groups.computeIfPresent(localDate, (key, list) -> {
                    list.add(receiveOilValue);
                    return list;
                });
            }

            for (Map.Entry<LocalDate, List<ReceiveOilValue>> entry : groups.entrySet()) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("date", entry.getKey());
                jsonObject.put("avg", "0.0");
                if (entry.getValue().size() > 0) {
                    List<ReceiveOilValue> valueList = entry.getValue();
                    Integer size = valueList.size();
                    Double total = 0.0;
                    for (ReceiveOilValue receiveOilValue : valueList) {
                        Double flowTotalValue = convertString(receiveOilValue.getFlowTotal());
                        total = total + flowTotalValue;
                    }
                    jsonObject.put("avg", String.format("%.3f", total / size));
                }
                jsonArray.add(jsonObject);
            }
        }

        return AjaxResult.success(jsonArray);
    }

    //多条件查询水表态势分析数据
    @PostMapping("/queryWaterAnalysis")
    @Operation(summary = "多条件查询水表态势分析数据")
    public AjaxResult queryWaterAnalysis(@Validated @RequestBody QueryAnalysisVO queryAnalysisVO) {
        List<String> ids = new ArrayList<>();
        Integer beId = queryAnalysisVO.getBeId();
        List<DpEquipmentVO> equList = queryDpEquipmentList(beId, 2);

        JSONArray jsonArray = new JSONArray();
        if (equList.size() > 0) {
            for (DpEquipmentVO dpEquipmentVO : equList) {
                ids.add(String.valueOf(dpEquipmentVO.getId()));
            }

            LambdaQueryWrapper<ReceiveWaterValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            Date startTime = queryAnalysisVO.getStartTime();
            Date endTime = queryAnalysisVO.getEndTime();
            Integer interval = queryAnalysisVO.getInterval();

            Map<String, Date> timeMap = new LinkedHashMap<>();
            LocalDate endDate = LocalDate.now();
            LocalDate startDate = LocalDate.now().minusDays(interval);

            if (startTime != null && endTime != null) {
                timeMap = convertStartEndTime(startTime, endTime);
                startDate = convertDate(timeMap.get("start")).toLocalDate();
                endDate = convertDate(timeMap.get("end")).toLocalDate();
            } else {
                timeMap = getStartEndTime(interval);
            }

            lambdaQueryWrapper.in(ReceiveWaterValue::getDeviceName, ids)
                    .ge(ReceiveWaterValue::getCreateTime, timeMap.get("start"))
                    .lt(ReceiveWaterValue::getCreateTime, timeMap.get("end"))
                    .orderByDesc(ReceiveWaterValue::getCreateTime);
            List<ReceiveWaterValue> waterValues = receiveWaterValueService.list(lambdaQueryWrapper);

            List<LocalDate> dateRange = startDate.datesUntil(endDate.plusDays(1)).collect(Collectors.toList());

            Map<LocalDate, List<ReceiveWaterValue>> groups = new LinkedHashMap<>();
            for (LocalDate localDate : dateRange) {
                groups.put(localDate, new ArrayList<>());
            }
            for (ReceiveWaterValue receiveWaterValue : waterValues) {
                LocalDateTime localDateTime = convertDate(receiveWaterValue.getCreateTime());
                LocalDate localDate = localDateTime.toLocalDate();
                groups.computeIfPresent(localDate, (key, list) -> {
                    list.add(receiveWaterValue);
                    return list;
                });
            }

            for (Map.Entry<LocalDate, List<ReceiveWaterValue>> entry : groups.entrySet()) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("date", entry.getKey());
                jsonObject.put("avg", "0.0");
                if (entry.getValue().size() > 0) {
                    List<ReceiveWaterValue> valueList = entry.getValue();
                    Integer size = valueList.size();
                    Double total = 0.0;
                    for (ReceiveWaterValue receiveWaterValue : valueList) {
                        Double zhengTotalValue = convertString(receiveWaterValue.getZhengTotal());
                        total = total + zhengTotalValue;
                    }
                    jsonObject.put("avg", String.format("%.3f", total / size));
                }
                jsonArray.add(jsonObject);
            }
        }

        return AjaxResult.success(jsonArray);
    }

    /**
     * 下发json文件
     */
    @PostMapping("/uploadFile")
    @Operation(summary = "下发json文件")
    public AjaxResult uploadFile(@RequestBody JSONArray json,
                                 @RequestParam(value = "name") String name) {
        SysFileManage sysFileManage = new SysFileManage();
        sysFileManage.setName(name + "_" + System.currentTimeMillis());
        sysFileManage.setType("json");
        sysFileManage.setExt("json");
        String filePath = ruoYiConfig.getJson() + "/" + sysFileManage.getName() + ".json";
        String path = "/profile/" + sysFileManage.getName() + ".json";
        sysFileManage.setFilePath(path);
        try {
            File file = new File(filePath);
            file.createNewFile();
            String jsonStr = JSON.toJSONString(json);

            Writer writer = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
            writer.write(jsonStr);
            writer.flush();
            writer.close();

            return AjaxResult.success(sysFileService.saveData(sysFileManage));
        } catch (Exception e) {
            return AjaxResult.error(e.getMessage());
        }
    }

    //对列表进行分页
    private TableDataInfo paginate(List list, int pageNum, int pageSize) {
        if (list == null || list.isEmpty()) {
            return new TableDataInfo(new ArrayList<>(), 0);
        }
        int total = list.size();
        int formIndex = (pageNum - 1) * pageSize;
        int toIndex = Math.min(formIndex + pageSize, total);
        if (formIndex >= total) {
            return new TableDataInfo(new ArrayList<>(), total);
        }
        List subList = list.subList(formIndex, toIndex);
        return new TableDataInfo(subList, total);
    }


    @GetMapping("/getYdkfm")
    @Operation(summary = "获取油电控阀门")
    public AjaxResult getYdkfm(Integer id) throws Exception {
        if (null == id || id < 0L) return AjaxResult.error("id为空");
        DpEquipmentVO dpEquipmentVO = dpEquipmentService.selectById(id);
        DpEquipment dp = receiveModuleInfoService.getIp(String.valueOf(dpEquipmentVO.getId()), dpEquipmentVO.getEquipmentTypeId());

        DpEquipment eq = dpEquipmentService.getEpByField(String.valueOf(dp.getPort()));
        if (null == eq || null == eq.getId()) return AjaxResult.error("找不到油电控阀门");

        Map<String, Object> map = receiveModuleInfoService.getYdkfmStatus(String.valueOf(eq.getId()));
        return success(map);
    }

    @GetMapping("/ctrlYdkfm")
    @Operation(summary = "控制油电控阀门")
    public AjaxResult ctrlYdkfm(Integer id, Boolean flag) throws Exception {
        if (null == id || id < 0L) return AjaxResult.error("id为空");
        if (null == flag) return AjaxResult.error("flag为空");

        DpEquipmentVO dpEquipmentVO = dpEquipmentService.selectById(id);
        DpEquipment dp = receiveModuleInfoService.getIp(String.valueOf(dpEquipmentVO.getId()), dpEquipmentVO.getEquipmentTypeId());

        DpEquipment eq = dpEquipmentService.getEpByField(String.valueOf(dp.getPort()));
        if (null == eq || null == eq.getId()) return AjaxResult.error("找不到油电控阀门");

        Map<String, Object> map = receiveModuleInfoService.ctrlYdkfm(String.valueOf(eq.getId()), flag);
        return success(map);
    }
}