package com.iamberry.rst.service.pts;

import com.iamberry.rst.core.pts.ProcessNode;
import com.iamberry.rst.core.pts.Produce;
import com.iamberry.rst.core.pts.ProduceProcess;
import com.iamberry.rst.faces.pts.ProduceService;
import com.iamberry.rst.service.pts.mapper.ProduceMapper;
import com.iamberry.rst.util.ProduceNoUtil;
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;


/**
 * 生产产品管理
 * Created by wangxiaoming on 2017/8/28.
 */
@Service
public class ProduceServiceImpl implements ProduceService {

    @Autowired
    public ProduceMapper produceMapper;

    //获取生产产品列表
    public List<Produce> getProduceList() {
        Produce produce = new Produce();
        return produceMapper.getProduceList(produce);
    }

    @Override
    public List<Produce> getAllProduceListToRam() {
        return produceMapper.getAllProduceListToRam();
    }

    //获取生产产品列表
    public List<Produce> getProduceList(Produce produce) {
        return produceMapper.getProduceList(produce);
    }

    //获取生产产品，产品工序，工序节点
    public List<Produce> getAllProduceList(Integer employeeId) {
        return produceMapper.getAllProduceList(employeeId);
    }

    @Override
    public Produce getProduce(String produceNo) {
        return produceMapper.getProduce(produceNo);
    }

    //获取单个产品
    public Produce getProduce(Produce produce) {
        return produceMapper.getProduceByPro(produce);
    }

    @Override
    public ProduceProcess getProduceProcess(Integer produceId, String processNo) {
        ProduceProcess produceProcess = new ProduceProcess();
        produceProcess.setProduceId(produceId);
        produceProcess.setProcessNo(processNo);
        return produceMapper.getProduceProcess(produceProcess);
    }

    @Override
    public ProcessNode getprocessNode(Integer ProcessId, String nodeNo) {
        ProcessNode processNode = new ProcessNode();
        processNode.setProcessId(ProcessId);
        processNode.setNodeNo(nodeNo);
        return produceMapper.getprocessNode(processNode);
    }

    @Override
    public List<ProduceProcess> listProduceProcess(ProduceProcess produceProcess) {
        return produceMapper.selectProcessList(produceProcess);
    }

    //获取所有的节点操作
    public List<ProcessNode> listProcessNode(ProcessNode processNode) {
        return produceMapper.listProcessNode(processNode);
    }

    //添加产品
    @Transactional
    public Integer saveProduce(Produce produce) {
        if (0 == produce.getProduceStatus()) {
            produce.setProduceNo(ProduceNoUtil.NO_NUMBER);
        } else {
            produce.setProduceNo(ProduceNoUtil.getProduceNo(produceMapper));
        }
        int flag = produceMapper.saveProduce(produce);
        Integer produceId = produce.getProduceId(); // 获取产品主键

        int sort = 1;   //专用排序字段
        for (int i = 0; i < produce.getProcess().size(); i++) {
            produce.getProcess().get(i).setProduceId(produceId);    //产品id
            produce.getProcess().get(i).setProcessNo(ProduceNoUtil.getProcessNo(i));  //工序编号
            produce.getProcess().get(i).setProcessStatus(1);    //状态

            if (produce.getProcess().get(i).getProcessType() == 2) {      //修理工序的排序字段为99
                produce.getProcess().get(i).setProcessSort(99);  //排序字段
            } else {
                produce.getProcess().get(i).setProcessSort(sort);  //排序字段
                sort++;
            }

            ProduceProcess produceProcess = produce.getProcess().get(i);
            this.saveProduceProcess(produceProcess);
            Integer processId = produceProcess.getProcessId();  //获取工序主键
            for (int j = 0; j < produceProcess.getNodes().size(); j++) {
                produceProcess.getNodes().get(j).setProduceId(produceId);
                produceProcess.getNodes().get(j).setProcessId(processId);
                produceProcess.getNodes().get(j).setNodeNo(ProduceNoUtil.getNodeNo(j)); //节点编号
            }
            this.saveProcessNodeList(produceProcess.getNodes());
        }
        return flag;
    }

    //添加产品工序
    public Integer saveProduceProcess(ProduceProcess produceProcesses) {
        int flag = produceMapper.saveProduceProcess(produceProcesses);
        return flag;
    }

    //添加产品工序操作
    public Integer saveProcessNodeList(List<ProcessNode> processNodeList) {
        int flag = 0;
        if (processNodeList.size() > 0)
            flag = produceMapper.saveProcessNodeList(processNodeList);
        return flag;
    }

    /**
     * 修改产品
     *
     * @param produce
     * @return
     */
    @Transactional
    public Integer updateProduce(Produce produce, String delProcessIds, String delNodeIds) {
        if (0 == produce.getProduceStatus()) {
            produce.setProduceNo(ProduceNoUtil.NO_NUMBER);
        } else {
            produce.setProduceNo(ProduceNoUtil.getProduceNo(produceMapper));
        }
        //修改产品
        int flag = produceMapper.updateProduce(produce);

        //删除的工序
        if (delProcessIds != null && !"".equals(delProcessIds)) {
            String delProcessId[] = delProcessIds.split(",");
            this.delProcess(delProcessId);
        }
        //删除节点操作
        if (delNodeIds != null && !"".equals(delNodeIds)) {
            String delNodeId[] = delNodeIds.split(",");
            this.delNode(delNodeId);
        }

        Integer produceId = produce.getProduceId();

        int sort = 1;   //专用排序字段

        List<ProduceProcess> updateProcessList = new ArrayList<ProduceProcess>();
        List<ProcessNode> updateNodeList = new ArrayList<ProcessNode>();
        List<ProcessNode> addNodeList = new ArrayList<ProcessNode>();
        for (int i = 0; i < produce.getProcess().size(); i++) {

            ProduceProcess produceProcess = produce.getProcess().get(i);
            produceProcess.setProcessNo(ProduceNoUtil.getProcessNo(i));  //工序编号
            if (produce.getProcess().get(i).getProcessType() == 2) {      //修理工序的排序字段为99
                produce.getProcess().get(i).setProcessSort(99);  //排序字段
            } else {
                produce.getProcess().get(i).setProcessSort(sort);  //排序字段
                sort++;
            }

            // 新增的工序/操作的id值都为 0 ；
            if (0 == produceProcess.getProcessId()) {     //新增的节点
                produce.getProcess().get(i).setProduceId(produceId);    //产品id
                produce.getProcess().get(i).setProcessStatus(1);    //状态
                this.saveProduceProcess(produceProcess);
                Integer processId = produceProcess.getProcessId();  //获取工序主键
                for (int j = 0; j < produceProcess.getNodes().size(); j++) {
                    produceProcess.getNodes().get(j).setProduceId(produceId);
                    produceProcess.getNodes().get(j).setProcessId(processId);
                    produceProcess.getNodes().get(j).setNodeNo(ProduceNoUtil.getNodeNo(j)); //节点编号
                    addNodeList.add(produceProcess.getNodes().get(j));
                }
            } else {      //修改节点
                Integer processId = produceProcess.getProcessId();
                updateProcessList.add(produceProcess);
                for (int j = 0; j < produceProcess.getNodes().size(); j++) {
                    ProcessNode processNode = produceProcess.getNodes().get(j);
                    if (0 == processNode.getNodeId()) {       //新增节点操作1
                        processNode.setProduceId(produceId);
                        processNode.setProcessId(processId);
                        processNode.setNodeNo(ProduceNoUtil.getNodeNo(j));
                        addNodeList.add(processNode);
                    } else {                              //修改节点操作1
                        processNode.setNodeNo(ProduceNoUtil.getNodeNo(j));
                        updateNodeList.add(processNode);
                    }
                }
            }
        }
        this.saveProcessNodeList(addNodeList);      //添加节点操作
        this.updateProcessNodeList(updateNodeList);     //修改节点操作
        this.updateProcessList(updateProcessList);    //修改工序
        return flag;
    }

    /**
     * 删除工序
     *
     * @return
     */
    public Integer delProcess(String delProcess[]) {
        List<ProduceProcess> produceProcessesList = new ArrayList<ProduceProcess>();
        for (String processId : delProcess) {
            ProduceProcess produceProcess = new ProduceProcess();
            produceProcess.setProcessId(Integer.valueOf(processId));
            produceProcess.setProcessNo("#");       //删除的工序  编号为#
            produceProcess.setProcessStatus(0);
            produceProcessesList.add(produceProcess);
        }
        Integer flag = this.updateProcessList(produceProcessesList);
        return flag;
    }

    /**
     * 删除节点操作
     *
     * @param delNodeId
     * @return
     */
    public Integer delNode(String delNodeId[]) {
        Integer flag = produceMapper.delNode(delNodeId);
        return flag;
    }

    /**
     * 修改工序
     *
     * @return
     */
    public Integer updateProcessList(List<ProduceProcess> produceProcessesList) {
        Integer flag = 0;
        if (produceProcessesList.size() > 0)
            flag = produceMapper.updateProcessList(produceProcessesList);
        return flag;
    }

    /**
     * 修改节点操作
     *
     * @return
     */
    public Integer updateProcessNodeList(List<ProcessNode> updateNodeList) {
        Integer flag = 0;
        if (updateNodeList.size() > 0)
            flag = produceMapper.updateProcessNodeList(updateNodeList);
        return flag;
    }


    @Override
    public List<Produce> listSelectProduct(Produce produce) {
        return produceMapper.listSelectProduct(produce);
    }

    @Override
    public Produce getProduceByOne() {
        return produceMapper.getProduceByOne();
    }

    @Override
    public ProduceProcess getProduceProcessAndNode(Integer produceId, String processNo) {
        return produceMapper.getProduceProcessAndNode(produceId,processNo);
    }
}