package com.mes.base.engineering.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.base.engineering.entity.request.EngineerImportRequest;
import com.mes.base.engineering.entity.request.EngineerRequest;
import com.mes.base.engineering.entity.vo.CutDrawingInfoVO;
import com.mes.base.engineering.mapper.EngineeringMapper;
import com.mes.base.engineering.service.EngineeringService;
import com.mes.base.flowcard.service.FlowCardInfoService;
import com.mes.base.formula.service.HollowFormulaDetailsService;
import com.mes.base.glassinfo.mapper.GlassInfoMapper;
import com.mes.base.glassinfo.service.GlassInfoService;
import com.mes.base.rawqueue.service.EngineeringRawQueueService;
import com.mes.base.tempparameter.service.TemperingParameterService;
import com.mes.engineering.Engineering;
import com.mes.flowcard.FlowCardInfo;
import com.mes.glassinfo.GlassInfo;
import com.mes.hollow.formula.HollowFormulaDetails;
import com.mes.rawqueue.EngineeringRawQueue;
import com.mes.sysconst.Const;
import com.mes.tempering.param.TemperingParameter;
import com.mes.tools.EntityTool;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.groupingBy;

/**
 * (Engineering)表服务实现类
 *
 * @author makejava
 * @since 2025-06-02 17:48:38
 */
@Service
@Slf4j
@ConditionalOnProperty(name = "engineering.mode", havingValue = "shuttle", matchIfMissing = false)
public class EngineeringServiceImpl extends ServiceImpl<EngineeringMapper, Engineering> implements EngineeringService {

    @Resource
    GlassInfoService glassInfoService;

    @Resource
    GlassInfoMapper glassInfoMapper;

    @Resource
    EngineeringRawQueueService engineeringRawQueueService;

    @Resource
    FlowCardInfoService flowCardInfoService;

    @Resource
    TemperingParameterService temperingParameterService;

    @Resource
    HollowFormulaDetailsService hollowFormulaDetailsService;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean importEngineerList(EngineerImportRequest request) {
        Engineering engineering = EntityTool.convertSingle(request, Engineering.class);
        List<GlassInfo> glassInfoList = EntityTool.batchConvert(request.getGlassInfolList(), GlassInfo.class);
        List<EngineeringRawQueue> engineeringRawQueueList = EntityTool.batchConvert(request.getEngineeringRawQueueList(), EngineeringRawQueue.class);
        List<FlowCardInfo> flowCardInfoList = EntityTool.batchConvert(request.getFlowCardInfoList(), FlowCardInfo.class);
        List<HollowFormulaDetails> hollowFormulaDetails = EntityTool.batchConvert(request.getHollowFormulaDetailsList(), HollowFormulaDetails.class);
        List<TemperingParameter> temperingParameter = EntityTool.batchConvert(request.getTemperingParameterList(), TemperingParameter.class);
        //起码保证玻璃小片数据不为null
        if (glassInfoList != null && !glassInfoList.isEmpty()) {
            this.save(engineering);
            glassInfoService.saveBatch(glassInfoList);
            engineeringRawQueueService.saveBatch(engineeringRawQueueList);
            flowCardInfoService.saveBatch(flowCardInfoList);
            hollowFormulaDetailsService.saveBatch(hollowFormulaDetails);
            temperingParameterService.saveBatch(temperingParameter);
            return true;
        } else {
            return false;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<String> queryEngineerIdList(EngineerRequest request) {
        return this.listObjs(new LambdaQueryWrapper<Engineering>()
                .select(Engineering::getEngineerId)
                .eq(request.getEngineerId() != null, Engineering::getEngineerId, request.getEngineerId())
                .eq(request.getState() != 0, Engineering::getState, request.getState())
                .eq(request.getWorkLine() != 0, Engineering::getWorkLine, request.getWorkLine())).stream()
                .map(Object::toString)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<String> queryNotFinishEngineerIdList() {
        return this.listObjs(new LambdaQueryWrapper<Engineering>()
                .select(Engineering::getEngineerId)
                .ne(Engineering::getState, Const.TASK_STATE_SUCCESS)).stream()
                .map(Object::toString)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<EngineeringRawQueue> queryEngineeringRawQueueList(EngineerRequest request) {
        //满足条件的的工程号ID  数组
        List<String> listId = queryEngineerIdList(request);
        return engineeringRawQueueService.queryEngineeringRawQueueList(listId);
    }

    @Override
    public List<EngineeringRawQueue> queryNotFinishEngineeringRawQueueList(Integer workLine) {
        List<String> listId = this.listObjs(new LambdaQueryWrapper<Engineering>()
                .select(Engineering::getEngineerId)
                .eq(Engineering::getState, Const.TASK_STATE_START)
                .eq(Engineering::getWorkLine, workLine)).stream()
                .map(Object::toString)
                .collect(Collectors.toList());
        return engineeringRawQueueService.queryNotFinishEngineeringRawQueueList(listId);
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean startTask(EngineerRequest request) {

        return this.update(new LambdaUpdateWrapper<Engineering>()
                .set(Engineering::getState, Const.TASK_STATE_START)
                .set(Engineering::getWorkLine, request.getWorkLine())
                .eq(Engineering::getEngineerId, request.getEngineerId())
                .ne(Engineering::getState, Const.TASK_STATE_START)
        );
    }

    @Override
    public Boolean pauseTask(EngineerRequest request) {
        return this.update(new LambdaUpdateWrapper<Engineering>()
                .set(Engineering::getState, Const.TASK_STATE_PAUSE)
                .eq(Engineering::getEngineerId, request.getEngineerId())
                .eq(Engineering::getWorkLine, request.getWorkLine())
        );
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean finishTask(EngineerRequest request) {
        return this.update(new LambdaUpdateWrapper<Engineering>()
                .set(Engineering::getState, Const.TASK_STATE_SUCCESS)
                .eq(Engineering::getEngineerId, request.getEngineerId())
                .eq(Engineering::getWorkLine, request.getWorkLine())
        );
    }

    @Override
    public List<CutDrawingInfoVO> findCutPatten(EngineerRequest request) {
        List<CutDrawingInfoVO> list = new ArrayList<>();
        //根据前段参数找到 需要查询的工程号信息
        Engineering engineering = this.getOne(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getEngineerId, request.getEngineerId())
                .eq(Engineering::getState, request.getState())
                .eq(Engineering::getWorkLine, request.getWorkLine()));
        //根据工程号信息查询版图信息
        if (engineering == null) {
            return list;
        }
        List<EngineeringRawQueue> upPattenUsageList = engineeringRawQueueService.queryEngineeringRawQueueList(Arrays.asList(engineering.getEngineerId()));

        // 根据工程号信息查询小片玻璃信息
        Map<Integer, List<GlassInfo>> glassInfoMap = glassInfoMapper.selectList(new QueryWrapper<GlassInfo>().lambda()
                .eq(GlassInfo::getEngineerId, engineering.getEngineerId()))
                .stream()
                .filter(e -> e.getRawSequence() != null)
                .collect(groupingBy(GlassInfo::getRawSequence));
        for (EngineeringRawQueue item : upPattenUsageList) {
            CutDrawingInfoVO cutDrawingInfoVO = new CutDrawingInfoVO();
            BeanUtils.copyProperties(item, cutDrawingInfoVO);
            cutDrawingInfoVO.setGlassInfoList(glassInfoMap.get(item.getRawSequence()));
            list.add(cutDrawingInfoVO);
        }
        return list;
    }

    @Override
    public boolean checkEngineering(EngineerRequest request) {
        //避免任务重复发生
        int runningCount = this.count(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getState, Const.TASK_STATE_START)
                .eq(Engineering::getWorkLine, request.getWorkLine()));
        if (runningCount > 0) {
            log.info("有正在执行的工程，请确保无正在执行的任务后进行操作");
            return Boolean.FALSE;
        }
        int anotherLineCount = this.count(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getEngineerId, request.getEngineerId())
                .ne(Engineering::getWorkLine, request.getWorkLine()));
        if (anotherLineCount > 0) {
            log.info("其他线路已领取有正在执行的工程，无法领取该工程");
            return Boolean.FALSE;
        }
        return Boolean.TRUE;
    }

    @Override
    public EngineerImportRequest mesImportEngineer(EngineerRequest request) {
        return null;
    }
}