package com.ruoyi.fuzhou.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.fuzhou.domain.*;
import com.ruoyi.fuzhou.enums.DataTypeEnum;
import com.ruoyi.fuzhou.mapper.ReceiveModuleInfoMapper;
import com.ruoyi.fuzhou.service.ReceiveElectricityInfoService;
import com.ruoyi.fuzhou.service.ReceiveModuleInfoService;
import com.ruoyi.fuzhou.service.ReceiveOilInfoService;
import com.ruoyi.fuzhou.service.ReceiveWaterInfoService;
import com.ruoyi.fuzhou.utils.Modbus4jUtils;
import com.ruoyi.fuzhou.utils.RtuMasterUtils;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * modbus数据模板 服务实现类
 * </p>
 *
 * @author zhangyy
 * @since 2025-03-27
 */
@Service
public class ReceiveModuleInfoServiceImpl extends ServiceImpl<ReceiveModuleInfoMapper, ReceiveModuleInfo> implements ReceiveModuleInfoService {

    @Resource
    private ReceiveElectricityInfoService receiveElectricityInfoService;

    @Resource
    private ReceiveOilInfoService receiveOilInfoService;

    @Resource
    private ReceiveWaterInfoService receiveWaterInfoService;

    @Override
    public void saveByModule(String deviceName, String ip, Integer port, Byte deviceAddress, Integer dataType) {
        if (dataType == null || DataTypeEnum.of(dataType) == null) return;

        List<ReceiveModuleInfo> receiveModuleInfos;
        if (DataTypeEnum.YDKFM.getCode().equals(dataType)) {
            receiveModuleInfos = list(new LambdaQueryWrapper<ReceiveModuleInfo>() {{
                or().eq(ReceiveModuleInfo::getDataType, dataType).eq(ReceiveModuleInfo::getDeviceName, deviceName);
            }});
            boolean flag = null == receiveModuleInfos || receiveModuleInfos.isEmpty();

            ReceiveModuleInfo rmi = flag ? new ReceiveModuleInfo() : receiveModuleInfos.get(0);
            if (flag) rmi.setId(null);
            rmi.setDeviceAddress(deviceAddress);
            rmi.setDeviceName(deviceName);
            rmi.setPort(port);
            if (StringUtils.isNotEmpty(ip)) rmi.setIp(ip);
            rmi.setDataType(dataType);
            rmi.setRegisterCount(1);

            if (flag) save(rmi);
            else updateById(rmi);
            return;
        }
        receiveModuleInfos = list(new LambdaQueryWrapper<ReceiveModuleInfo>() {{
            or().eq(ReceiveModuleInfo::getDataType, dataType);
        }});
        if (receiveModuleInfos != null && receiveModuleInfos.size() > 0) {
            if (DataTypeEnum.WATER_DEPT.getCode().equals(dataType) || DataTypeEnum.WATER_YA.getCode().equals(dataType) ||
                    DataTypeEnum.WATER_FLOW.getCode().equals(dataType)) {
                List<ReceiveWaterInfo> receiveWaterInfos = new ArrayList<>();
                ReceiveWaterInfo receiveWaterInfo;
                for (ReceiveModuleInfo info : receiveModuleInfos
                ) {
                    receiveWaterInfo = new ReceiveWaterInfo();
                    receiveWaterInfo.setDeviceAddress(deviceAddress);
                    receiveWaterInfo.setDeviceName(deviceName);
                    receiveWaterInfo.setPort(port);
                    if (StringUtils.isNotEmpty(ip)) {
                        receiveWaterInfo.setIp(ip);
                    }
                    if (info.getFunctionCode() != null) {
                        receiveWaterInfo.setFunctionCode(info.getFunctionCode());
                    }
                    receiveWaterInfo.setRegisterAdress(info.getRegisterAdress());
                    receiveWaterInfo.setRegisterCount(info.getRegisterCount());
                    receiveWaterInfo.setParam(info.getParam());
                    receiveWaterInfo.setParamCode(info.getParamCode());
                    receiveWaterInfo.setUnit(info.getUnit());
                    receiveWaterInfo.setDataType(dataType);
                    receiveWaterInfos.add(receiveWaterInfo);
                }
                receiveWaterInfoService.remove(new LambdaQueryWrapper<ReceiveWaterInfo>() {{
                    or().eq(ReceiveWaterInfo::getDeviceName, deviceName);
                }});
                receiveWaterInfoService.saveBatch(receiveWaterInfos);
            } else if (DataTypeEnum.ELECTRICITY.getCode().equals(dataType)) {
                List<ReceiveElectricityInfo> receiveElectricityInfos = new ArrayList<>();
                ReceiveElectricityInfo electricityInfo;
                for (ReceiveModuleInfo info : receiveModuleInfos
                ) {
                    electricityInfo = new ReceiveElectricityInfo();
                    electricityInfo.setDeviceAddress(deviceAddress);
                    electricityInfo.setDeviceName(deviceName);
                    electricityInfo.setPort(port);
                    if (StringUtils.isNotEmpty(ip)) {
                        electricityInfo.setIp(ip);
                    }
                    electricityInfo.setDataType(dataType);
                    electricityInfo.setFunctionCode(info.getFunctionCode());
                    electricityInfo.setRegisterAdress(info.getRegisterAdress());
                    electricityInfo.setRegisterCount(info.getRegisterCount());
                    electricityInfo.setParam(info.getParam());
                    electricityInfo.setParamCode(info.getParamCode());
                    electricityInfo.setUnit(info.getUnit());
                    receiveElectricityInfos.add(electricityInfo);
                }
                receiveElectricityInfoService.remove(new LambdaQueryWrapper<ReceiveElectricityInfo>() {{
                    or().eq(ReceiveElectricityInfo::getDeviceName, deviceName);
                }});
                receiveElectricityInfoService.saveBatch(receiveElectricityInfos);
            } else if (DataTypeEnum.OIL.getCode().equals(dataType) || DataTypeEnum.LIJIUOIL.getCode().equals(dataType) ||
                    DataTypeEnum.LIJIUJUN.getCode().equals(dataType) || DataTypeEnum.NIGDETUIYOU.getCode().equals(dataType)) {
                List<ReceiveOilInfo> receiveOilInfos = new ArrayList<>();
                ReceiveOilInfo receiveOilInfo;
                for (ReceiveModuleInfo info : receiveModuleInfos
                ) {
                    receiveOilInfo = new ReceiveOilInfo();
                    receiveOilInfo.setDeviceAddress(deviceAddress);
                    receiveOilInfo.setDeviceName(deviceName);
                    receiveOilInfo.setPort(port);
                    if (StringUtils.isNotEmpty(ip)) {
                        receiveOilInfo.setIp(ip);
                    }
                    receiveOilInfo.setDataType(dataType);
                    if (info.getFunctionCode() != null) {
                        receiveOilInfo.setFunctionCode(info.getFunctionCode());
                    }
                    receiveOilInfo.setRegisterAdress(info.getRegisterAdress());
                    receiveOilInfo.setRegisterCount(info.getRegisterCount());
                    receiveOilInfo.setParam(info.getParam());
                    receiveOilInfo.setParamCode(info.getParamCode());
                    receiveOilInfo.setUnit(info.getUnit());
                    receiveOilInfos.add(receiveOilInfo);
                }
                receiveOilInfoService.remove(new LambdaQueryWrapper<ReceiveOilInfo>() {{
                    or().eq(ReceiveOilInfo::getDeviceName, deviceName);
                }});
                receiveOilInfoService.saveBatch(receiveOilInfos);
            }
        }
    }

    @Override
    public void removeByModule(String deviceName, Integer dataType) {
        if (dataType == null || DataTypeEnum.of(dataType) == null) {
            return;
        } else {
            if (DataTypeEnum.WATER_DEPT.getCode().equals(dataType) || DataTypeEnum.WATER_YA.getCode().equals(dataType) ||
                    DataTypeEnum.WATER_FLOW.getCode().equals(dataType)) {
                receiveWaterInfoService.remove(new LambdaQueryWrapper<ReceiveWaterInfo>() {{
                    or().eq(ReceiveWaterInfo::getDeviceName, deviceName);
                }});
            } else if (DataTypeEnum.ELECTRICITY.getCode().equals(dataType)) {
                receiveElectricityInfoService.remove(new LambdaQueryWrapper<ReceiveElectricityInfo>() {{
                    or().eq(ReceiveElectricityInfo::getDeviceName, deviceName);
                }});
            } else if (DataTypeEnum.OIL.getCode().equals(dataType) || DataTypeEnum.LIJIUOIL.getCode().equals(dataType) ||
                    DataTypeEnum.LIJIUJUN.getCode().equals(dataType) || DataTypeEnum.NIGDETUIYOU.getCode().equals(dataType)) {
                receiveOilInfoService.remove(new LambdaQueryWrapper<ReceiveOilInfo>() {{
                    or().eq(ReceiveOilInfo::getDeviceName, deviceName);
                }});
            }
        }
    }

    @Override
    public DpEquipment getIp(String deviceName, Integer dataType) {
        if (dataType == null || DataTypeEnum.of(dataType) == null) {
            return new DpEquipment();
        } else {
            DpEquipment dpEquipment = new DpEquipment();
            if (DataTypeEnum.YDKFM.getCode().equals(dataType)) {
                List<ReceiveModuleInfo> infos = list(new LambdaQueryWrapper<ReceiveModuleInfo>() {{
                    or().eq(ReceiveModuleInfo::getDeviceName, deviceName);
                }});
                if (null == infos || infos.isEmpty()) return dpEquipment;
                ReceiveModuleInfo rmi = infos.get(0);
                dpEquipment.setIp(rmi.getIp());
                dpEquipment.setPort(rmi.getPort());
                dpEquipment.setDeviceAddress(rmi.getDeviceAddress());
            }
            if (DataTypeEnum.WATER_DEPT.getCode().equals(dataType) || DataTypeEnum.WATER_YA.getCode().equals(dataType) ||
                    DataTypeEnum.WATER_FLOW.getCode().equals(dataType)) {
                List<ReceiveWaterInfo> receiveWaterInfos = receiveWaterInfoService.list(new LambdaQueryWrapper<ReceiveWaterInfo>() {{
                    or().eq(ReceiveWaterInfo::getDeviceName, deviceName);
                }});
                for (ReceiveWaterInfo r : receiveWaterInfos
                ) {
                    if (StringUtils.isNotEmpty(r.getIp())) {
                        dpEquipment.setIp(r.getIp());
                    }
                    if (r.getPort() != null) {
                        dpEquipment.setPort(r.getPort());
                    }
                    if (r.getDeviceAddress() != null) {
                        dpEquipment.setDeviceAddress(r.getDeviceAddress());
                    }
                }
            } else if (DataTypeEnum.ELECTRICITY.getCode().equals(dataType)) {
                List<ReceiveElectricityInfo> receiveElectricityInfos = receiveElectricityInfoService.list(new LambdaQueryWrapper<ReceiveElectricityInfo>() {{
                    or().eq(ReceiveElectricityInfo::getDeviceName, deviceName);
                }});
                for (ReceiveElectricityInfo r : receiveElectricityInfos
                ) {
                    if (StringUtils.isNotEmpty(r.getIp())) {
                        dpEquipment.setIp(r.getIp());
                    }
                    if (r.getPort() != null) {
                        dpEquipment.setPort(r.getPort());
                    }
                    if (r.getDeviceAddress() != null) {
                        dpEquipment.setDeviceAddress(r.getDeviceAddress());
                    }
                }
            } else if (DataTypeEnum.OIL.getCode().equals(dataType) || DataTypeEnum.LIJIUOIL.getCode().equals(dataType) ||
                    DataTypeEnum.LIJIUJUN.getCode().equals(dataType) || DataTypeEnum.NIGDETUIYOU.getCode().equals(dataType)) {
                List<ReceiveOilInfo> receiveOilInfos = receiveOilInfoService.list(new LambdaQueryWrapper<ReceiveOilInfo>() {{
                    or().eq(ReceiveOilInfo::getDeviceName, deviceName);
                }});
                for (ReceiveOilInfo r : receiveOilInfos
                ) {
                    if (StringUtils.isNotEmpty(r.getIp())) {
                        dpEquipment.setIp(r.getIp());
                    }
                    if (r.getPort() != null) {
                        dpEquipment.setPort(r.getPort());
                    }
                    if (r.getDeviceAddress() != null) {
                        dpEquipment.setDeviceAddress(r.getDeviceAddress());
                    }
                }
            }
            return dpEquipment;
        }
    }

    @Override
    public Map<String, Object> getYdkfmStatus(String deviceName) throws Exception {
        List<ReceiveModuleInfo> infos = list(new LambdaQueryWrapper<ReceiveModuleInfo>() {{
            or().eq(ReceiveModuleInfo::getDeviceName, deviceName);
        }});
        if (null == infos || infos.isEmpty()) throw new Exception("找不到油电控阀门");

        ReceiveModuleInfo rmi = infos.get(0);
        Map<String, Object> map = new HashMap<>();

        Boolean status;
        try {
            //status = RtuMasterUtils.getYdkfmStatus(rmi);
            status = Modbus4jUtils.getYdkfmStatus(rmi);
        } catch (Exception ex) {
            map.put("error", ex.getMessage());
            status = null;
        }
        map.put("status", status);

        return map;
    }

    @Override
    public Map<String, Object> ctrlYdkfm(String deviceName, Boolean flag) throws Exception {
        List<ReceiveModuleInfo> infos = list(new LambdaQueryWrapper<ReceiveModuleInfo>() {{
            or().eq(ReceiveModuleInfo::getDeviceName, deviceName);
        }});
        if (null == infos || infos.isEmpty()) throw new Exception("找不到油电控阀门");

        ReceiveModuleInfo rmi = infos.get(0);
        Map<String, Object> map = new HashMap<>();

        Boolean status;
        try {
            //status = RtuMasterUtils.ctrlYdkfm(rmi, flag);
            status = Modbus4jUtils.ctrlYdkfm(rmi, flag);
        } catch (Exception ex) {
            map.put("error", ex.getMessage());
            status = null;
        }
        map.put("status", status);

        return map;
    }
}