package com.hk.NumericalCollection.service.impl;


import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.hk.NumericalCollection.config.DataAcquisitionConfiguration;
import com.hk.NumericalCollection.dto.*;
import com.hk.NumericalCollection.entity.*;
import com.hk.NumericalCollection.service.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.function.Function;
import java.util.stream.Collectors;

@Service
@Transactional(rollbackFor = Exception.class)
@RequiredArgsConstructor
public class NumericalServiceImpl implements INumericalService {

    private final ApiService apiService;

    private final DeviceService deviceService;

    private final DevMachineService devMachineService;
    private final DevMacByclService devMacByclService;

    private final MesOrderStaService mesOrderStaService;
    private final DeviceStatusService deviceStatusService;
    private final DeviceStatusByclService deviceStatusByclService;
    private final MesOrderSelectService orderSelectService;
    private final MesNumericalService mesNumericalServicen;
    private final MesNumericalByclService mesNumericalByclService;

    private final VOrderService vOrderService;

    @Override
    public boolean SoDeviceList() throws Exception {
        ApiResponse<?> sig = apiService.getSig(DataAcquisitionConfiguration.PUBLIC_KEY, DataAcquisitionConfiguration.APP_ID);

        // Check if the response code indicates success
        ApiResponseCode apiResponseCode = ApiResponseCode.fromCode(sig.getCode());
        if (!apiResponseCode.getFlag()) {
            return false; // Exit if the response is not successful
        }

        // Prepare the request body
        ApiRequestBody requestBody = new ApiRequestBody();
        requestBody.setExt("");
        requestBody.setVistApi("soDeviceList");
        requestBody.setSig(sig.getData()); // Convert data to String if needed
        requestBody.setAppId(DataAcquisitionConfiguration.APP_ID);
        requestBody.setTime("1683531129071");

        // Set parameters for the request
        Params params = new Params();
        params.setPageNo(1);
        params.setPageSize(999);
        params.setStatus(-99);
        requestBody.setParams(params);

        // Send the data request and receive response
        ApiResponse<Device> response = apiService.sendListRequest(requestBody, Device.class);

        ApiResponseCode isTrue = ApiResponseCode.fromCode(response.getCode());

        if (!isTrue.getFlag()) {
            throw new Exception("在请求数采接口时出现：" + isTrue.getDescription());
        }

        List<Device> deviceList = response.getList();

        // 清空id，让数据库自动生成
        deviceList.forEach(d -> d.setId(null));

        List<String> uidList = deviceList.stream().map(Device::getDevNo).collect(Collectors.toList());

        LambdaUpdateWrapper<Device> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(Device::getDevNo, uidList);
        deviceService.remove(wrapper);
        
        // SQL Server 批量插入兼容性问题，改用逐条插入
        for (Device device : deviceList) {
            deviceService.save(device);
        }
        return true;
    }

    //为我复制一份这个方法出来，把用到的DEVICE_STATUS实体类改为DEVICE_STATUS_BYCL，MES_NUMERICAL实体改为MES_NUMERICAL_BYCL，其他的逻辑不变并给我注释
    @Override
    public void getDeviceRealTimeData(String uid) throws Exception {

        ApiDataResult<DeviceRealTimeData> response = getDeviceRealTimeDataApiDataResult(uid);
        if (response == null) return; // Exit if the response is not successful

        DeviceRealTimeData data = response.getData();

        setMesOrderSta(data);

        //工艺参数
        //deviceMetricsService.saveDeviceMetrics(data, orderSta.getOrderNo());
    }

    @Override
    public void getDeviceRealTimeDataBycl(String uid) throws Exception {
        ApiDataResult<DeviceRealTimeData> response = getDeviceRealTimeDataApiDataResult(uid);
        if (response == null) {
            return;
        }

        DeviceRealTimeData data = response.getData();
        setMesOrderStaBycl(data);
    }

    @Override
    public void getDeviceDayCount(String uid, String date) throws IOException {

        ApiResponse<?> sig = apiService.getSig(DataAcquisitionConfiguration.PUBLIC_KEY, DataAcquisitionConfiguration.APP_ID);

        ApiResponseCode apiResponseCode = ApiResponseCode.fromCode(sig.getCode());
        if (apiResponseCode != null && !apiResponseCode.getFlag()) {
            return; // 如果响应不成功则退出
        }

        ApiRequestBody requestBody = new ApiRequestBody();
        requestBody.setExt("");
        requestBody.setVistApi("getDeviceDayCount");
        requestBody.setSig(sig.getData()); // Ensure data is in string format
        requestBody.setAppId(DataAcquisitionConfiguration.APP_ID);
        requestBody.setTime("1683531129071");

        Params params = new Params();
        params.setUid(uid);
        params.setDate(date);
        requestBody.setParams(params);

        ApiDataResult<DeviceDayCount> response = apiService.sendDataRequest(requestBody, DeviceDayCount.class);

        apiResponseCode = ApiResponseCode.fromCode(response.getCode());
        if (apiResponseCode == null || !apiResponseCode.getFlag()) {
            return;
        }
        DeviceDayCount data = response.getData();

        if (data.getFaultTime() == null && data.getWaitTime() == null) {
            return;
        }

        LambdaQueryWrapper<DevMachine> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DevMachine::getDevNo, uid);
        DevMachine devMachine = devMachineService.getOne(wrapper);
        if (devMachine == null) {
            return;
        }

        double v = (data.getFaultTime() + data.getWaitTime()) * 60;

        if (v <= 0) {
            return;
        }

        LambdaQueryWrapper<MesOrderSelect> lambdaUpdateWrapper1 = new LambdaQueryWrapper<>();

        lambdaUpdateWrapper1.eq(MesOrderSelect::getEditDate, date)
                .eq(MesOrderSelect::getMachineNo, devMachine.getMachineNo());

        long count = orderSelectService.count(lambdaUpdateWrapper1);

        if (count <= 0) {
            return;
        }

        LambdaUpdateWrapper<MesOrderSelect> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();

        v = (double) Math.round(v / count * 100) / 100;

        lambdaUpdateWrapper
                .set(MesOrderSelect::getTjCount, 1)
                .set(MesOrderSelect::getTjTime, v)
                .eq(MesOrderSelect::getEditDate, date)
                .eq(MesOrderSelect::getMachineNo, devMachine.getMachineNo());

        orderSelectService.update(lambdaUpdateWrapper);
    }

    @Override
    public ApiDataResult<DeviceRealTimeData> getDeviceRealTimeDataApiDataResult(String uid) throws Exception {
        // 获取sig
        ApiResponse<?> sig = apiService.getSig(DataAcquisitionConfiguration.PUBLIC_KEY, DataAcquisitionConfiguration.APP_ID);

        // 检查响应代码是否成功
        ApiResponseCode apiResponseCode = ApiResponseCode.fromCode(sig.getCode());
        if (apiResponseCode == null || !apiResponseCode.getFlag()) {
            return null;
        }

        // 准备请求正文
        ApiRequestBody requestBody = new ApiRequestBody();
        requestBody.setExt("");
        requestBody.setVistApi("getDeviceRealTimeData");
        requestBody.setSig(sig.getData()); // Ensure data is in string format
        requestBody.setAppId(DataAcquisitionConfiguration.APP_ID);
        requestBody.setTime("1683531129071");

        // 设置请求的参数
        Params params = new Params();
        params.setUid(uid);
        requestBody.setParams(params);

        // 发送数据请求并接收响应
        ApiDataResult<DeviceRealTimeData> response = apiService.sendDataRequest(requestBody, DeviceRealTimeData.class);

        ApiResponseCode isTrue = ApiResponseCode.fromCode(response.getCode());

        if (isTrue != null && !isTrue.getFlag()) {
            throw new Exception("在请求数采接口时出现：" + isTrue.getDescription());
        }
        return response;
    }

    @Override
    public boolean RefreshDev(NumbericalDto barcode) {

        if (StrUtil.isNullOrUndefined(barcode.getMachineNo())) {
            return false;
        }

        try {
            LambdaQueryWrapper<DevMachine> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(DevMachine::getMachineNo, barcode.getMachineNo());
            DevMachine one = devMachineService.getOne(queryWrapper, false);

            if (one == null) {
                return false;
            }

            getDeviceRealTimeData(one.getDevNo());

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @Override
    public boolean RefreshDevBycl(NumbericalDto barcode) {
        if (StrUtil.isNullOrUndefined(barcode.getMachineNo())) {
            return false;
        }

        try {
            LambdaQueryWrapper<DevMacBycl> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(DevMacBycl::getMachineNo, barcode.getMachineNo());
            DevMacBycl one = devMacByclService.getOne(queryWrapper, false);

            if (one == null) {
                return false;
            }

            getDeviceRealTimeDataBycl(one.getDevNo());

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private void setMesOrderSta(DeviceRealTimeData data) {
        LambdaQueryWrapper<DevMachine> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DevMachine::getDevNo, data.getDevNo());

        DevMachine one = devMachineService.getOne(wrapper, false);

        if (one == null) {
            System.out.println("异常1：当前机器没有绑定机台");
            return;
        }

        //mesOrderStaService
//        LambdaQueryWrapper<MesOrderSta> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(MesOrderSta::getMachineNo, one.getMachineNo())
//                .eq(MesOrderSta::getIsShow, 1);
//
//        MesOrderSta orderSta = mesOrderStaService.getOne(queryWrapper, false);
//
//        if (orderSta == null) {
//            System.out.println("异常2：当前产线没有可以绑定的工单");
//            return;
//        }

        //数采记录
        String formattedDate = data.getLastEditDate().substring(0, 10);


//        LambdaQueryWrapper<MesOrderSelect> queryWrapper1 = new LambdaQueryWrapper<>();
//        queryWrapper1.eq(MesOrderSelect::getIsShow, 0)
//                .eq(MesOrderSelect::getMachineNo, orderSta.getMachineNo());
//
//        List<MesOrderSelect> list = orderSelectService.list(queryWrapper1);
//
//        list.forEach(s -> {
//            setOrder(data, s.getOrderNo(), formattedDate);
//        });
        setOrder(data, formattedDate, one);
    }

    private void setMesOrderStaBycl(DeviceRealTimeData data) {
        LambdaQueryWrapper<DevMacBycl> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DevMacBycl::getDevNo, data.getDevNo());

        DevMacBycl one = devMacByclService.getOne(wrapper, false);

        if (one == null) {
            System.out.println("WARN: current device is not bound to a machine");
            return;
        }

        String formattedDate = data.getLastEditDate().substring(0, 10);
        setOrderBycl(data, formattedDate, one);
    }

    private void setOrder(DeviceRealTimeData data, String formattedDate, DevMachine one) {

        LambdaQueryWrapper<MesOrderSta> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MesOrderSta::getMachineNo, one.getMachineNo())
                .eq(MesOrderSta::getIsShow, 1);

        MesOrderSta orderSta = mesOrderStaService.getOne(queryWrapper, false);

        if (orderSta == null) {
            queryWrapper.clear();
            queryWrapper.eq(MesOrderSta::getMachineNo, one.getMachineNo())
                    .orderByDesc(MesOrderSta::getId);

            orderSta = mesOrderStaService.getOne(queryWrapper, false);
        }

        String orderNo = "";
        Long orderId = null;

        if (orderSta != null) {
            orderNo = orderSta.getOrderNo();
            orderId = orderSta.getOrderId();
        }

        LambdaQueryWrapper<VOrder> queryWrapper2 = new LambdaQueryWrapper<>();
        queryWrapper2.eq(VOrder::getId, orderId);
        VOrder one1 = vOrderService.getOne(queryWrapper2, false);

        int outItemNum = 1;

        if (one1 != null) {

            try {
                outItemNum = Integer.parseInt(one1.getOutItemNum());
            } catch (Exception e) {
                outItemNum = 1;
            }
        }

        DeviceStatus status = new DeviceStatus();
        status.setDevNo(data.getDevNo());
        status.setStatus(data.getStatus());
        status.setOutput(data.getOutput());
        status.setOnlineTime(data.getOnlineTime());
        status.setTodayOnlineTime(data.getTodayOnlineTime());
        status.setPower(data.getTodayPower());
        status.setTodayPower(data.getTodayPower());
        status.setFaultNum(data.getFaultNum());
        status.setTodayFaultNum(data.getTodayFaultNum());
        status.setOrderNo(orderNo);
        status.setEditDate(formattedDate);
//            status.setTodayOutput(data.getTodayOutput());
        String d15 = data.getD15();

        if (StrUtil.isEmpty(d15)) {
            d15 = "0";
        }

        status.setTodayOutput(Double.parseDouble(d15) * outItemNum);

        status.setWorkStartDate(data.getWorkstartDate());
        status.setWorkEndDate(data.getWorkendDate());
        status.setDeviceTypeClassItemId(data.getDeviceTypeClassItemId());
//            status.setDeviceTypeClassItemName(data.getDeviceTypeClassItemName());
        status.setWorkOutput(Double.parseDouble(data.getWorkOutPut()));
        status.setHourOutput(Double.parseDouble(data.getHourOutPut()));
        status.setBadoutput(Double.parseDouble(data.getBadoutput()));
        status.setTodayBadoutput(Double.parseDouble(data.getTodayBadoutput()));
        status.setWorkBadoutput(Double.parseDouble(data.getWorkBadoutput()));
        status.setHourBadoutput(Double.parseDouble(data.getHourBadoutput()));


        boolean nullOrUndefined = StrUtil.isNullOrUndefined(data.getTodayRuntime());
        if (!nullOrUndefined) {
            status.setTodayRunTime(Double.parseDouble(data.getTodayRuntime()));
        }

        deviceStatusService.save(status);

        MesNumerical numerical = new MesNumerical();
        numerical.setOrderId(orderId);
        numerical.setOrderNo(orderNo);
        numerical.setEditDate(formattedDate);
        numerical.setMachineNo(one.getMachineNo());
//        numerical.setCjNum((int) data.getTodayOutput());
        numerical.setCjNum(Integer.parseInt(d15) * outItemNum);
        numerical.setCjTiem(data.getLastEditDate());
        mesNumericalServicen.save(numerical);
    }

    private void setNumericalBycl(DeviceRealTimeData data, String formattedDate, MesOrderSta orderSta) {
        MesNumericalBycl numerical = new MesNumericalBycl();
        numerical.setOrderId(orderSta.getOrderId());
        numerical.setOrderNo(orderSta.getOrderNo());
        numerical.setEditDate(formattedDate);
        numerical.setMachineNo(orderSta.getMachineNo());
        numerical.setCjNum(parseBigDecimal(resolveByclProductionValue(data)).intValue());
        numerical.setCjTiem(data.getLastEditDate());
        mesNumericalByclService.save(numerical);
    }

    /**
     * BYCL表同步逻辑：复制setOrder写入DEVICE_STATUS_BYCL和MES_NUMERICAL_BYCL。
     */
    private void setOrderBycl(DeviceRealTimeData data, String formattedDate, DevMacBycl one) {

        LambdaQueryWrapper<MesOrderSta> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MesOrderSta::getMachineNo, one.getMachineNo())
                .eq(MesOrderSta::getIsShow, 1);

        MesOrderSta orderSta = mesOrderStaService.getOne(queryWrapper, false);

        if (orderSta == null) {
            queryWrapper.clear();
            queryWrapper.eq(MesOrderSta::getMachineNo, one.getMachineNo())
                    .orderByDesc(MesOrderSta::getId);

            orderSta = mesOrderStaService.getOne(queryWrapper, false);
        }

        String orderNo = "";
        Long orderId = null;

        if (orderSta != null) {
            orderNo = orderSta.getOrderNo();
            orderId = orderSta.getOrderId();
        }

        LambdaQueryWrapper<VOrder> queryWrapper2 = new LambdaQueryWrapper<>();
        queryWrapper2.eq(VOrder::getId, orderId);
        VOrder one1 = vOrderService.getOne(queryWrapper2, false);

        int outItemNum = 1;

        if (one1 != null) {

            try {
                outItemNum = Integer.parseInt(one1.getOutItemNum());
            } catch (Exception e) {
                outItemNum = 1;
            }
        }

        DeviceStatusBycl status = new DeviceStatusBycl();
        status.setDevNo(data.getDevNo());
        status.setStatus(data.getStatus());
        status.setOutput(data.getOutput());
        status.setOnlineTime(data.getOnlineTime());
        status.setTodayOnlineTime(data.getTodayOnlineTime());
        status.setPower(data.getTodayPower());
        status.setTodayPower(data.getTodayPower());
        status.setFaultNum(data.getFaultNum());
        status.setTodayFaultNum(data.getTodayFaultNum());
        status.setOrderNo(orderNo);
        status.setEditDate(formattedDate);

        // Determine production count (d15 variable name must stay the same)
        String d15 = resolveByclProductionValue(data);
        BigDecimal production = parseBigDecimal(d15);
        BigDecimal todayOutput = production.multiply(BigDecimal.valueOf(outItemNum));
        status.setTodayOutput(todayOutput.doubleValue());

        status.setWorkStartDate(data.getWorkstartDate());
        status.setWorkEndDate(data.getWorkendDate());
        status.setDeviceTypeClassItemId(data.getDeviceTypeClassItemId());
        status.setWorkOutput(Double.parseDouble(data.getWorkOutPut()));
        status.setHourOutput(Double.parseDouble(data.getHourOutPut()));
        status.setBadoutput(Double.parseDouble(data.getBadoutput()));
        status.setTodayBadoutput(Double.parseDouble(data.getTodayBadoutput()));
        status.setWorkBadoutput(Double.parseDouble(data.getWorkBadoutput()));
        status.setHourBadoutput(Double.parseDouble(data.getHourBadoutput()));

        boolean nullOrUndefined = StrUtil.isNullOrUndefined(data.getTodayRuntime());
        if (!nullOrUndefined) {
            status.setTodayRunTime(Double.parseDouble(data.getTodayRuntime()));
        }

        deviceStatusByclService.save(status);

        MesNumericalBycl numerical = new MesNumericalBycl();
        numerical.setOrderId(orderId);
        numerical.setOrderNo(orderNo);
        numerical.setEditDate(formattedDate);
        numerical.setMachineNo(one.getMachineNo());
        numerical.setCjNum(todayOutput.intValue());
        numerical.setCjTiem(data.getLastEditDate());
        mesNumericalByclService.save(numerical);
    }

    private void setOrder(DeviceRealTimeData data, String orderNo, String formattedDate) {

        LambdaQueryWrapper<MesOrderSta> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MesOrderSta::getOrderNo, orderNo);

        MesOrderSta orderSta = mesOrderStaService.getOne(queryWrapper, false);

        LambdaQueryWrapper<DeviceStatus> queryWrapper2 = new LambdaQueryWrapper<>();
        queryWrapper2.eq(DeviceStatus::getOrderNo, orderSta.getOrderNo())
                .eq(DeviceStatus::getEditDate, formattedDate);

        long count = deviceStatusService.count(queryWrapper2);

        if (count == 0) {

            //写入数采记录
            DeviceStatus status = new DeviceStatus();
            status.setDevNo(data.getDevNo());
            status.setStatus(data.getStatus());
            status.setOutput(data.getOutput());
            status.setOnlineTime(data.getOnlineTime());
            status.setTodayOnlineTime(data.getTodayOnlineTime());
            status.setPower(data.getTodayPower());
            status.setTodayPower(data.getTodayPower());
            status.setFaultNum(data.getFaultNum());
            status.setTodayFaultNum(data.getTodayFaultNum());
            status.setOrderNo(orderSta.getOrderNo());
            status.setEditDate(formattedDate);
//            status.setTodayOutput(data.getTodayOutput());
            status.setTodayOutput(Double.parseDouble(data.getD15()));

            status.setWorkStartDate(data.getWorkstartDate());
            status.setWorkEndDate(data.getWorkendDate());
            status.setDeviceTypeClassItemId(data.getDeviceTypeClassItemId());
//            status.setDeviceTypeClassItemName(data.getDeviceTypeClassItemName());
            status.setWorkOutput(Double.parseDouble(data.getWorkOutPut()));
            status.setHourOutput(Double.parseDouble(data.getHourOutPut()));
            status.setBadoutput(Double.parseDouble(data.getBadoutput()));
            status.setTodayBadoutput(Double.parseDouble(data.getTodayBadoutput()));
            status.setWorkBadoutput(Double.parseDouble(data.getWorkBadoutput()));
            status.setHourBadoutput(Double.parseDouble(data.getHourBadoutput()));
            status.setTodayRunTime(Double.parseDouble(data.getTodayRuntime()));

            deviceStatusService.save(status);

            //写入MesOrderSelect  停机记录数
            MesOrderSelect select = new MesOrderSelect();
            select.setOrderId(orderSta.getOrderId());
            select.setOrderNo(orderSta.getOrderNo());
            select.setEditDate(formattedDate);
            select.setMachineNo(orderSta.getMachineNo());
            select.setTjCount(0);
            select.setTjTime(0.0);
            orderSelectService.save(select);

            //写入MesNumerical  数采记录
            setNumerical(data, formattedDate, orderSta);

        } else if (count > 0) {

            LambdaUpdateWrapper<DeviceStatus> wrapper1 = new LambdaUpdateWrapper<>();

            wrapper1.set(DeviceStatus::getWorkOutput, data.getWorkOutPut())
                    .set(DeviceStatus::getHourOutput, data.getHourOutPut())
//                    .set(DeviceStatus::getTodayOutput, data.getTodayOutput())
                    .set(DeviceStatus::getTodayOutput, Double.parseDouble(data.getD15()))
                    .set(DeviceStatus::getBadoutput, data.getBadoutput())
                    .set(DeviceStatus::getTodayBadoutput, data.getTodayBadoutput())
                    .set(DeviceStatus::getWorkBadoutput, data.getWorkBadoutput())
                    .set(DeviceStatus::getHourBadoutput, data.getHourBadoutput())
                    .eq(DeviceStatus::getOrderNo, orderSta.getOrderNo())
                    .eq(DeviceStatus::getEditDate, formattedDate);

            deviceStatusService.update(wrapper1);

            LambdaUpdateWrapper<MesNumerical> wrapper2 = new LambdaUpdateWrapper<>();
            wrapper2.eq(MesNumerical::getOrderNo, orderSta.getOrderNo())
                    .eq(MesNumerical::getEditDate, formattedDate)
                    .orderByDesc(MesNumerical::getCjTiem);

//            MesNumerical numerical = mesNumericalServicen.getOne(wrapper2, false);
            List<MesNumerical> list = mesNumericalServicen.list(wrapper2);

            if (list.isEmpty()) {
                setNumerical(data, formattedDate, orderSta);
            } else if (list.size() == 1) {
                MesNumerical numerical = list.get(0);
//                if (numerical.getCjNum() == (int) data.getTodayOutput()) {
                if (numerical.getCjNum() == (int) Double.parseDouble(data.getD15())) {
                    //setOrderSelect(data, formattedDate, numerical, orderSta);

                    //写入MesNumerical  数采记录
                    setNumerical(data, formattedDate, orderSta);
                } else {
                    mesNumericalServicen.removeById(numerical.getId());
                    //如果数采数据与最新的一条数据不相等,表示没有停机,替换
                    setNumerical(data, formattedDate, orderSta);
                }
            } else {
                MesNumerical numerical = list.get(0);
                MesNumerical numerical1 = list.get(1);

                //如果数采数据与最新的一条数据相等就继续比较倒数第二条
//                if (numerical.getCjNum() == (int) data.getTodayOutput()) {
                if (numerical.getCjNum() == (int) Double.parseDouble(data.getD15())) {
                    //如果数采数据与最新的两次记录相等,就表示还是处于停机状态,继续记录
//                    if (numerical1.getCjNum() == (int) data.getTodayOutput()) {
                    if (numerical1.getCjNum() == (int) Double.parseDouble(data.getD15())) {
                        setNumerical(data, formattedDate, orderSta);

                        //setOrderSelect(data, formattedDate, numerical, orderSta);
                    }
                } else {
                    mesNumericalServicen.removeById(numerical.getId());
                    //如果数采数据与最新的一条数据不相等,表示没有停机,替换
                    setNumerical(data, formattedDate, orderSta);
                }
            }

            setOrderSelect(data, formattedDate, orderSta);
        }
    }

    /**
     * BYCL表版本的setOrder，保持逻辑一致仅替换持久化实体。
     */
    private void setOrderBycl(DeviceRealTimeData data, String orderNo, String formattedDate) {

        LambdaQueryWrapper<MesOrderSta> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MesOrderSta::getOrderNo, orderNo);

        MesOrderSta orderSta = mesOrderStaService.getOne(queryWrapper, false);

        LambdaQueryWrapper<DeviceStatusBycl> queryWrapper2 = new LambdaQueryWrapper<>();
        queryWrapper2.eq(DeviceStatusBycl::getOrderNo, orderSta.getOrderNo())
                .eq(DeviceStatusBycl::getEditDate, formattedDate);

        long count = deviceStatusByclService.count(queryWrapper2);
        String d15 = resolveByclProductionValue(data);
        BigDecimal production = parseBigDecimal(d15);
        int productionInt = production.intValue();
        double productionDouble = production.doubleValue();

        if (count == 0) {

            DeviceStatusBycl status = new DeviceStatusBycl();
            status.setDevNo(data.getDevNo());
            status.setStatus(data.getStatus());
            status.setOutput(data.getOutput());
            status.setOnlineTime(data.getOnlineTime());
            status.setTodayOnlineTime(data.getTodayOnlineTime());
            status.setPower(data.getTodayPower());
            status.setTodayPower(data.getTodayPower());
            status.setFaultNum(data.getFaultNum());
            status.setTodayFaultNum(data.getTodayFaultNum());
            status.setOrderNo(orderSta.getOrderNo());
            status.setEditDate(formattedDate);
            status.setTodayOutput(productionDouble);

            status.setWorkStartDate(data.getWorkstartDate());
            status.setWorkEndDate(data.getWorkendDate());
            status.setDeviceTypeClassItemId(data.getDeviceTypeClassItemId());
            status.setWorkOutput(Double.parseDouble(data.getWorkOutPut()));
            status.setHourOutput(Double.parseDouble(data.getHourOutPut()));
            status.setBadoutput(Double.parseDouble(data.getBadoutput()));
            status.setTodayBadoutput(Double.parseDouble(data.getTodayBadoutput()));
            status.setWorkBadoutput(Double.parseDouble(data.getWorkBadoutput()));
            status.setHourBadoutput(Double.parseDouble(data.getHourBadoutput()));
            status.setTodayRunTime(Double.parseDouble(data.getTodayRuntime()));

            deviceStatusByclService.save(status);

            MesOrderSelect select = new MesOrderSelect();
            select.setOrderId(orderSta.getOrderId());
            select.setOrderNo(orderSta.getOrderNo());
            select.setEditDate(formattedDate);
            select.setMachineNo(orderSta.getMachineNo());
            select.setTjCount(0);
            select.setTjTime(0.0);
            orderSelectService.save(select);

            setNumericalBycl(data, formattedDate, orderSta);

        } else if (count > 0) {

            LambdaUpdateWrapper<DeviceStatusBycl> wrapper1 = new LambdaUpdateWrapper<>();

            wrapper1.set(DeviceStatusBycl::getWorkOutput, data.getWorkOutPut())
                    .set(DeviceStatusBycl::getHourOutput, data.getHourOutPut())
                    .set(DeviceStatusBycl::getTodayOutput, productionDouble)
                    .set(DeviceStatusBycl::getBadoutput, data.getBadoutput())
                    .set(DeviceStatusBycl::getTodayBadoutput, data.getTodayBadoutput())
                    .set(DeviceStatusBycl::getWorkBadoutput, data.getWorkBadoutput())
                    .set(DeviceStatusBycl::getHourBadoutput, data.getHourBadoutput())
                    .eq(DeviceStatusBycl::getOrderNo, orderSta.getOrderNo())
                    .eq(DeviceStatusBycl::getEditDate, formattedDate);

            deviceStatusByclService.update(wrapper1);

            LambdaUpdateWrapper<MesNumericalBycl> wrapper2 = new LambdaUpdateWrapper<>();
            wrapper2.eq(MesNumericalBycl::getOrderNo, orderSta.getOrderNo())
                    .eq(MesNumericalBycl::getEditDate, formattedDate)
                    .orderByDesc(MesNumericalBycl::getCjTiem);

            List<MesNumericalBycl> list = mesNumericalByclService.list(wrapper2);

            if (list.isEmpty()) {
                setNumericalBycl(data, formattedDate, orderSta);
            } else if (list.size() == 1) {
                MesNumericalBycl numerical = list.get(0);
                if (numerical.getCjNum() == productionInt) {
                    setNumericalBycl(data, formattedDate, orderSta);
                } else {
                    mesNumericalByclService.removeById(numerical.getId());
                    setNumericalBycl(data, formattedDate, orderSta);
                }
            } else {
                MesNumericalBycl numerical = list.get(0);
                MesNumericalBycl numerical1 = list.get(1);

                if (numerical.getCjNum() == productionInt) {
                    if (numerical1.getCjNum() == productionInt) {
                        setNumericalBycl(data, formattedDate, orderSta);
                    }
                } else {
                    mesNumericalByclService.removeById(numerical.getId());
                    setNumericalBycl(data, formattedDate, orderSta);
                }
            }

            setOrderSelectBycl(data, formattedDate, orderSta);
        }
    }

    private void setNumerical(DeviceRealTimeData data, String formattedDate, MesOrderSta orderSta) {
        MesNumerical numerical = new MesNumerical();
        numerical.setOrderId(orderSta.getOrderId());
        numerical.setOrderNo(orderSta.getOrderNo());
        numerical.setEditDate(formattedDate);
        numerical.setMachineNo(orderSta.getMachineNo());
//        numerical.setCjNum((int) data.getTodayOutput());
        numerical.setCjNum(Integer.parseInt(data.getD15()));
        numerical.setCjTiem(data.getLastEditDate());
        mesNumericalServicen.save(numerical);
    }

    private void setOrderSelect(DeviceRealTimeData data, String formattedDate, MesOrderSta orderSta) {

        LambdaQueryWrapper<MesNumerical> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(MesNumerical::getEditDate, formattedDate);

        List<MesNumerical> orders = mesNumericalServicen.list(wrapper);

        List<MesNumerical> mesNumericals = new ArrayList<>(orders.stream()
                .collect(Collectors.toMap(
                        order -> order.getOrderId() + "_" + order.getCjTiem(),  // 用ORDER_ID+ORDER_NO进行唯一标识
                        Function.identity(),  // 保留Order对象本身
                        (existing, replacement) -> existing)) // 如果有重复的，保留第一个
                .values());

        // 时间解析器
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        Map<String, List<MesNumerical>> groupedOrders = mesNumericals.stream()
                .collect(Collectors.groupingBy(order -> order.getOrderId() + "-" + order.getCjNum()));

        // 计算每组的时间差
        groupedOrders.forEach((key, orderList) -> {
            if (orderList.size() > 1) {
                // 获取最早的和最晚的时间
                LocalDateTime minTime = orderList.stream()
                        .map(order -> LocalDateTime.parse(order.getCjTiem(), formatter))
                        .min(LocalDateTime::compareTo)
                        .orElseThrow(() -> new NoSuchElementException("No min time found in group " + key));  // 如果没有记录会抛出异常，这里假设至少有一个时间

                LocalDateTime maxTime = orderList.stream()
                        .map(order -> LocalDateTime.parse(order.getCjTiem(), formatter))
                        .max(LocalDateTime::compareTo)
                        .orElseThrow(() -> new NoSuchElementException("No min time found in group " + key));  // 同理

                // 计算时间差（单位为秒）
                long timeDifferenceInSeconds = Duration.between(minTime, maxTime).getSeconds();


                long time = timeDifferenceInSeconds / 60;
                //更新MesOrderSelect  停机记录数
                LambdaUpdateWrapper<MesOrderSelect> wrapper3 = new LambdaUpdateWrapper<>();
                wrapper3
                        .set(MesOrderSelect::getTjCount, orderList.size() - 1)
                        .set(MesOrderSelect::getTjTime, time)
                        .eq(MesOrderSelect::getMachineNo, orderSta.getMachineNo())
                        .eq(MesOrderSelect::getEditDate, formattedDate)
                        .eq(MesOrderSelect::getIsShow, 0)
                        .eq(MesOrderSelect::getOrderNo, orderSta.getOrderNo());
                orderSelectService.update(wrapper3);

            }
        });
    }

    private void setOrderSelectBycl(DeviceRealTimeData data, String formattedDate, MesOrderSta orderSta) {

        LambdaQueryWrapper<MesNumericalBycl> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(MesNumericalBycl::getEditDate, formattedDate);

        List<MesNumericalBycl> orders = mesNumericalByclService.list(wrapper);

        List<MesNumericalBycl> mesNumericals = new ArrayList<>(orders.stream()
                .collect(Collectors.toMap(
                        order -> order.getOrderId() + "_" + order.getCjTiem(),
                        Function.identity(),
                        (existing, replacement) -> existing))
                .values());

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        Map<String, List<MesNumericalBycl>> groupedOrders = mesNumericals.stream()
                .collect(Collectors.groupingBy(order -> order.getOrderId() + "-" + order.getCjNum()));

        groupedOrders.forEach((key, orderList) -> {
            if (orderList.size() > 1) {
                LocalDateTime minTime = orderList.stream()
                        .map(order -> LocalDateTime.parse(order.getCjTiem(), formatter))
                        .min(LocalDateTime::compareTo)
                        .orElseThrow(() -> new NoSuchElementException("No min time found in group " + key));

                LocalDateTime maxTime = orderList.stream()
                        .map(order -> LocalDateTime.parse(order.getCjTiem(), formatter))
                        .max(LocalDateTime::compareTo)
                        .orElseThrow(() -> new NoSuchElementException("No min time found in group " + key));

                long timeDifferenceInSeconds = Duration.between(minTime, maxTime).getSeconds();

                long time = timeDifferenceInSeconds / 60;
                LambdaUpdateWrapper<MesOrderSelect> wrapper3 = new LambdaUpdateWrapper<>();
                wrapper3
                        .set(MesOrderSelect::getTjCount, orderList.size() - 1)
                        .set(MesOrderSelect::getTjTime, time)
                        .eq(MesOrderSelect::getMachineNo, orderSta.getMachineNo())
                        .eq(MesOrderSelect::getEditDate, formattedDate)
                        .eq(MesOrderSelect::getIsShow, 0)
                        .eq(MesOrderSelect::getOrderNo, orderSta.getOrderNo());
                orderSelectService.update(wrapper3);

            }
        });
    }

    private String resolveByclProductionValue(DeviceRealTimeData data) {
        String d15 = normalizeNumeric(data.getD1());
        if (d15 != null) {
            return d15;
        }

        String latheCount = normalizeNumeric(data.getD29());
        if (latheCount != null) {
            return latheCount;
        }

//        String hobbingCount = normalizeNumeric(data.getD45());
//        if (hobbingCount != null) {
//            return hobbingCount;
//        }

//        double todayOutput = data.getTodayOutput();
//        if (todayOutput > 0) {
//            return BigDecimal.valueOf(todayOutput).stripTrailingZeros().toPlainString();
//        }

        return "0";
    }

    private String normalizeNumeric(String raw) {
        if (StrUtil.isBlank(raw)) {
            return null;
        }
        String trimmed = raw.trim();
        return NumberUtil.isNumber(trimmed) ? trimmed : null;
    }

    private BigDecimal parseBigDecimal(String value) {
        try {
            return new BigDecimal(value);
        } catch (NumberFormatException e) {
            return BigDecimal.ZERO;
        }
    }
}