package com.dy.pmsStation.assemblyStep;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.dy.pmsGlobal.daoPr.PrAssemblyPlanMapper;
import com.dy.pmsGlobal.daoPr.PrProductionNodeMapper;
import com.dy.pmsGlobal.daoSta.*;
import com.dy.pmsGlobal.pojoPr.PrAssemblyPlan;
import com.dy.pmsGlobal.pojoPr.PrProductionNode;
import com.dy.pmsGlobal.pojoSta.*;
import com.dy.pmsGlobal.util.QrCodeConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Slf4j
@Service
public class AssemblyStepSv {
    private static final int STATUS_OK = 1;
    private static final int STATUS_COMPLETE = 2;
    private static final int STATUS_REPAIR = 3;
    private static final int STATUS_WASTE = 4;

    private StaDeviceLastMapper deviceLastDao;
    private StaDeviceLifeMapper deviceLifeDao;
    private StaWipSnExMapper wipSnExDao;
    private StaDeviceProductionLogMapper deviceProductionLogDao;
    private StaAssemblyWorkLastMapper assemblyWorkLastDao;
    private PrAssemblyPlanMapper assemblyPlanDao;
//    private PrProductionProcessMapper processDao;
    private PrProductionNodeMapper nodeDao;
    private StaRepairInfoMapper repairInfoDao;
    @Autowired
    public void setDeviceLastDao(StaDeviceLastMapper deviceLastDao) {
        this.deviceLastDao = deviceLastDao;
    }
    @Autowired
    public void setDeviceLifeDao(StaDeviceLifeMapper deviceLifeDao) {
        this.deviceLifeDao = deviceLifeDao;
    }
    @Autowired
    public void setWipSnExDao(StaWipSnExMapper wipSnExDao) {
        this.wipSnExDao = wipSnExDao;
    }
    @Autowired
    public void setDeviceProductionLogDao(StaDeviceProductionLogMapper deviceProductionLogDao) {
        this.deviceProductionLogDao = deviceProductionLogDao;
    }
    @Autowired
    public void setAssemblyWorkLastDao(StaAssemblyWorkLastMapper assemblyWorkLastDao) {
        this.assemblyWorkLastDao = assemblyWorkLastDao;
    }
    @Autowired
    public void setAssemblyPlanDao(PrAssemblyPlanMapper assemblyPlanDao) {
        this.assemblyPlanDao = assemblyPlanDao;
    }
    @Autowired
    public void setNodeDao(PrProductionNodeMapper nodeDao) {
        this.nodeDao = nodeDao;
    }
    @Autowired
    public void setRepairInfoDao(StaRepairInfoMapper repairInfoDao) {
        this.repairInfoDao = repairInfoDao;
    }

    public int save(QueryVo params) {
        long workId = Long.parseLong(params.workId);
        StaAssemblyWorkLast workLast = assemblyWorkLastDao.selectByPrimaryKey(workId);
        if (workLast == null) {
            throw new RuntimeException("工单不存在");
        }
        PrAssemblyPlan plan = assemblyPlanDao.selectByPrimaryKey(workLast.getPlanId());
        // 验证并处理设备号和物料号
        Set<String> deviceSet = new HashSet<>(Arrays.asList(params.deviceNo.split(",")));
        // 分类设备号和物料号
        List<String> deviceList = new ArrayList<>();
        List<String> materialList = new ArrayList<>();

        deviceSet.forEach(device -> {
            if (device.contains(plan.batchNo)) {
                deviceList.add(device);
            } else {
                materialList.add(device);
            }
        });

        if (deviceList.isEmpty()) {
            throw new RuntimeException("设备号不属于当前任务计划");
        }
        if (deviceList.size() > 1) {
            throw new RuntimeException("设备号有且只能有一个");
        }

        StaDeviceLast deviceLast = buildDeviceLast(params, workLast, deviceList.get(0));
        int count = deviceLast.id == null ? deviceLastDao.insertSelective(deviceLast) :
                deviceLastDao.updateByPrimaryKeySelective(deviceLast);

        saveDeviceProductionLog(deviceLast);

        PrProductionNode node = nodeDao.selectByPrimaryKey(workLast.nodeId);
        if (node.isRecord) {
            saveDeviceLife(deviceLast);
        }
        if (CollectionUtils.isNotEmpty(materialList)) {
            saveSnEx(workLast, deviceList, materialList, plan);
        }
        return count;
    }

    private void saveDeviceProductionLog(StaDeviceLast deviceLast) {
        StaDeviceProductionLog log = new StaDeviceProductionLog();
        BeanUtils.copyProperties(deviceLast, log);
        log.setId(null); // 设备生产日志ID设为null，表示新增
        deviceProductionLogDao.insertSelective(log);
    }

    private void saveDeviceLife(StaDeviceLast deviceLast) {
        StaDeviceLife life = new StaDeviceLife();
        BeanUtils.copyProperties(deviceLast, life);
        deviceLifeDao.insertSelective(life);
    }

    private StaDeviceLast buildDeviceLast(QueryVo params, StaAssemblyWorkLast workLast, String deviceNo){
        //组装数据
        StaDeviceLast record = new StaDeviceLast();

        StaDeviceLast preRecord = deviceLastDao.selectByDeviceNo(deviceNo);
        if(preRecord != null){
            record.id = preRecord.id;
            record.inTime = preRecord.outTime;
        }
        record.outTime = new Date();

        record.planId = workLast.planId;
        record.workId = Long.parseLong(params.workId);
        record.stationId = workLast.stationId;
        record.equipNo = deviceNo;
        record.currNode = workLast.nodeId;
//        record.setNextNode(getNextNode(params.status,workLast.nodeId));

        record.updatedBy = workLast.userId;
        record.assistants = params.assistants;

        PrProductionNode node = nodeDao.selectByPrimaryKey(workLast.nodeId);
        record.nodeContent = node.content;
        if(node.isRecord){
            record.equipCycleContent = node.equipCycleContent;
        }
        record.status = getStatus(params.status,node.isEnd);
        return record;
    }
    private int saveSnEx(StaAssemblyWorkLast workLast, List<String> deviceList,List<String> materialList, PrAssemblyPlan plan){
        StaWipSnEx snEx = new StaWipSnEx();
        snEx.deviceNo = deviceList.get(0);
        snEx.productNo = plan.batchNo;
        snEx.deviceNo = materialList.get(0);
        snEx.createTime = workLast.startTime;
        snEx.createBy = workLast.userId;
        snEx.productName = plan.proName;
        return wipSnExDao.insertSelective(snEx);
    }
    /**
     * 状态: 1:组装中,2:完成,3:维修,4:报废
     * @param status 状态
     * @param isEndNode 是否结束节点
     * @return 状态
     */
    private int getStatus(String status,boolean isEndNode){
        return switch (status) {
            case QrCodeConstant.MarkOk -> isEndNode? STATUS_COMPLETE:STATUS_OK;
            case QrCodeConstant.MarkUnqualified -> STATUS_REPAIR;
            case QrCodeConstant.MarkWaste -> STATUS_WASTE;
            default -> throw new RuntimeException("状态错误");
        };
    }

    public int repair(QueryVo vo) {
        long workId = Long.parseLong(vo.workId);
        StaAssemblyWorkLast workLast = assemblyWorkLastDao.selectByPrimaryKey(workId);
        if (workLast == null) {
            throw new RuntimeException("工单不存在");
        }
        StaDeviceLast preDeviceRecord = deviceLastDao.selectByDeviceNo(vo.deviceNo);
        StaRepairInfo repairInfo = new StaRepairInfo();
        repairInfo.workId = workId;
        repairInfo.equipNo = vo.deviceNo;
        repairInfo.repairTime = new Date();
        repairInfo.repairBy = workLast.userId;
        repairInfo.repairReason = vo.errorMsg;
        repairInfo.fromNode = preDeviceRecord.currNode;
        repairInfoDao.insertSelective(repairInfo);

        StaDeviceLast deviceLast = new StaDeviceLast();
        BeanUtils.copyProperties(preDeviceRecord, deviceLast);
        deviceLast.repairId = repairInfo.id;
        deviceLast.errorCode = vo.errorMsg;
        deviceLast.assistants = vo.assistants;
        //如果原节点是结束节点或之后的节点，是则更新为完成,否则更新为组装中(默认维修节点的状态只能为 确定或 报废)
        boolean isEndNode = nodeDao.isEndNode(preDeviceRecord.currNode);
        if(QrCodeConstant.MarkWaste.equals(vo.status)){
            deviceLast.status = STATUS_WASTE;
        }else{
            deviceLast.status = isEndNode? STATUS_COMPLETE:STATUS_OK;
        }
        int count = deviceLast.id == null ? deviceLastDao.insertSelective(deviceLast) :
                deviceLastDao.updateByPrimaryKeySelective(deviceLast);
        saveDeviceProductionLog(deviceLast);

        if (isEndNode) {
            saveDeviceLife(deviceLast);
        }
        return count;
    }
}