package com.lxzn.mes.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lxzn.activiti.service.IAssignFileStreamService;
import com.lxzn.base.service.IDncLogService;
import com.lxzn.framework.domain.base.DncLog;
import com.lxzn.framework.domain.mes.MesDispatchTask;
import com.lxzn.framework.domain.mes.ext.MesDispatchTaskReceive;
import com.lxzn.framework.domain.mes.request.MesDispatchTaskRequest;
import com.lxzn.framework.exception.ExceptionCast;
import com.lxzn.framework.model.response.CommonCode;
import com.lxzn.framework.model.response.QueryPageResponseResult;
import com.lxzn.framework.utils.BeanMapper;
import com.lxzn.framework.utils.ValidateUtil;
import com.lxzn.framework.utils.date.DateUtil;
import com.lxzn.mes.dao.MesDispatchTaskMapper;
import com.lxzn.mes.ext.MesResultModel;
import com.lxzn.mes.service.IMesDispatchTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * @author clown
 * * @date 2022/10/29
 */
@Service
public class MesDispatchTaskServiceImpl extends ServiceImpl<MesDispatchTaskMapper,MesDispatchTask> implements IMesDispatchTaskService {

    @Autowired
    private IAssignFileStreamService assignFileStreamService;
    @Autowired
    private IDncLogService dncLogService;

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public MesResultModel saveOrUpdateDis(MesDispatchTaskReceive mesReceives) {
        if (mesReceives == null ) {
            return null;
        }
        MesDispatchTask task = new MesDispatchTask();
        MesResultModel model =new MesResultModel();
        model.setSuccFlag("成功");
        if (mesReceives.getDispatchDateLong() != null) {
            mesReceives.setDispatchDate(DateUtil.longdate(mesReceives.getDispatchDateLong()));
        }
        MesDispatchTask mes = getDispatchTask(mesReceives.getMesId());
        boolean b = false;
        if (mes == null) {
            BeanMapper.copy(mesReceives,task);
            b = this.saveOrUpdate(task);
            mes = new MesDispatchTask();
            BeanMapper.copy(task,mes);
        } else {
            if (StringUtils.isNotEmpty(mesReceives.getTaskType()) && !mesReceives.getTaskType().equals("1")) {
                mes.setTaskType(mesReceives.getTaskType());
                b = this.saveOrUpdate(mes);
            } else {
                BeanMapper.copy(mesReceives,mes);
                b = this.saveOrUpdate(mes);
            }

        }
        if (b) {
            try {
                boolean ncBool = disPatchTaskNc(mes);
                if (ncBool) {
                    mes.setNcIssued(2);
                } else {
                    mes.setNcIssued(1);
                }
                this.saveOrUpdate(mes);
            } catch (Exception e) {
                mes.setNcIssued(1);
                this.saveOrUpdate(mes);
                return model;
            }
        }
        return model;
    }

    @Override
    public MesDispatchTask getDispatchTask(String mesId) {
        List<MesDispatchTask> tasks = super.lambdaQuery().eq(MesDispatchTask::getMesId, mesId).list();
        if (tasks == null || tasks.isEmpty()) {
            return null;
        }
        return tasks.get(0);
    }


    /*   * @param equipmentId 设备编号
     * @param workshop 车间
     * @param partsCode 零件号
     * @param processCode 工艺
     * @param description 工艺规程版本*/
    @Override
    public boolean disPatchTaskNc(MesDispatchTask task) {
        String processCode = task.getOpreationSeqNo() + "_" + task.getMdsEquipmentId();
        return assignFileStreamService.disPatchTaskNc(task.getMdsEquipmentId(),
                task.getMdsWorkcenterId(),task.getMdsItemCode(),processCode,task.getRevisionNo(),task.getId());
    }

    @Override
    public QueryPageResponseResult<MesDispatchTask> findPageList(int page, int size,
                                                                 MesDispatchTaskRequest requestParams) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<MesDispatchTask> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<MesDispatchTask> lambdaQuery = super.lambdaQuery();
        if(requestParams != null) {
            if(ValidateUtil.validateString(requestParams.getMdsItemCode())) {
                lambdaQuery.eq(MesDispatchTask::getMdsItemCode, requestParams.getMdsItemCode());
            }
            if(ValidateUtil.validateString(requestParams.getMdsEquipmentId())) {
                lambdaQuery.eq(MesDispatchTask::getMdsEquipmentId, requestParams.getMdsEquipmentId());
            }
            if(ValidateUtil.validateString(requestParams.getMdsWorkcenterId())) {
                lambdaQuery.like(MesDispatchTask::getMdsWorkcenterId, requestParams.getMdsWorkcenterId());
            }
            if(ValidateUtil.validateString(requestParams.getRouteId())) {
                lambdaQuery.like(MesDispatchTask::getRouteId, requestParams.getRouteId());
            }
            if(ValidateUtil.validateString(requestParams.getEndTime())) {
                String date = DateUtil.format(DateUtil.plusTime(DateUtil.toDate(requestParams.getEndTime(),DateUtil.STR_DATE),1),DateUtil.STR_DATE);
                lambdaQuery.lt(MesDispatchTask::getDispatchDate,date);
            }
            if(ValidateUtil.validateString(requestParams.getStartTime())) {
                lambdaQuery.ge(MesDispatchTask::getDispatchDate,requestParams.getStartTime());
            }
            if(ValidateUtil.validateString(requestParams.getCreateTime())) {
                if (requestParams.getCreateTime().equals("asc")) {
                    lambdaQuery.orderByAsc(true,MesDispatchTask::getDispatchDate);
                } else  if (requestParams.getCreateTime().equals("desc")) {
                    lambdaQuery.orderByDesc(true,MesDispatchTask::getDispatchDate);
                }
            } else {
                lambdaQuery.orderByDesc(true,MesDispatchTask::getDispatchDate);
            }

        }
        IPage<MesDispatchTask> userIPage = lambdaQuery.page(pageData);
        if (userIPage.getRecords() != null) {
            for (MesDispatchTask t : userIPage.getRecords() ) {
                DncLog dncLog = dncLogService.findOneDncMesTask(t.getId());
                if (dncLog!= null) {
                    t.setContentName(dncLog.getContentName());
                    t.setIsSuccess(dncLog.getIsSuccess());
                    t.setRemarks(dncLog.getRemarks());
                }
            }
        }
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, userIPage);
    }


}