package com.huaheng.pc.shipment.wave.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.shipment.wave.domain.Wave;
import com.huaheng.pc.shipment.wave.mapper.WaveMapper;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
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.Arrays;
import java.util.HashSet;
import java.util.List;

@Service
public class WaveService extends ServiceImpl<WaveMapper, Wave> {


    @Autowired
    private ShipmentDetailService shipmentDetailService;
    @Autowired
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Autowired
    private TaskDetailService taskDetailService;
    @Autowired
    private TaskHeaderService taskHeaderService;
    @Autowired
    private ShipmentHeaderService shipmentHeaderService;

    /**
     * 开始波次，对带有此波次号的单据进行后续的后台操作
     * 1、查看波次是否符合开始波次的条件
     * 2、整合波次的所有子单单据
     * 3、对每个单据自动组盘，失败则回退
     * 4、生成任务
     * 5、修改波次的状态
     */

    @Transactional
    public AjaxResult startWave(String ids) {
        List<Wave> waves = new ArrayList<>();
        List<ShipmentDetail> list = new ArrayList<>();
        for (Integer id : Convert.toIntArray(ids)) {

            //1、查看此波次的状态,状态不为o时，无法开始波次
            Wave wave = this.getById(id);
            if(wave == null || (wave.getStatus()> QuantityConstant.WAVE_STATUS_BUILD &&
                    wave.getStatus() < QuantityConstant.WAVE_STATUS_FAILED)){
                return AjaxResult.error("id为"+id+"的波次找不到，或者状态不能做开始操作");
            }
            waves.add(wave);

            //2、找到此波次的单据
            LambdaQueryWrapper<ShipmentDetail> lam = Wrappers.lambdaQuery();
            lam.eq(ShipmentDetail::getWaveId,id)
                .eq(ShipmentDetail::getWarehouseCode, ShiroUtils.getWarehouseCode());
            List<ShipmentDetail> shipmentDetails=shipmentDetailService.list(lam);

            //整合所有加入波次的单据
            if(shipmentDetails != null){
                list.addAll(shipmentDetails);
            }
        }

        //3、自动组盘
        AjaxResult ajaxResult=shipmentContainerHeaderService.autoCombination(list);
        if(ajaxResult.getData() != null){
            //4、生成任务
            shipmentContainerHeaderService.createTask(Arrays.asList(Convert.toIntArray(ajaxResult.getData().toString())));
        }

        //5、修改波次的状态
        for(Wave wave : waves){
            wave.setStatus(QuantityConstant.WAVE_STATUS_END);
            wave.setCurrentWaveStep("生成任务");
        }
        Boolean flag = this.updateBatchById(waves);
        if(flag == false){
            throw new ServiceException("波次运行失败，修改波次状态时报错");
        }
        return AjaxResult.success("波次运行成功");
    }


    /**
     * 释放波次，执行任务
     * 1、查看此波次的状态，是否可以释放波次
     * 2、查看波次的状态，是成功释放还是失败释放
     * 成功释放：1、找到此波次的所有子任务
     *          2、根据子任务选出主任务
     *          3、将这些主任务执行
     *  失败释放：1.找到次波次的所有子单据
     *             2.修改子单据的波次为0
     *             3.修改主子单的状态
     * @param ids
     * @return
     */
    @Transactional
    public AjaxResult freed(String ids) {
        Boolean flag = false;
        List<TaskDetail> taskDetailList = new ArrayList<>();
        for (Integer id : Convert.toIntArray(ids)) {

            //1、查看此波次是否可以释放
            Wave wave = this.getById(id);
            if(wave == null || (wave.getStatus()!=QuantityConstant.WAVE_STATUS_END && wave.getStatus()!=QuantityConstant.WAVE_STATUS_FAILED)){
                return AjaxResult.error(id+"波次不可释放");
            }

            //2、查看此波次的状态,看是成功释放还是失败释放
            if(wave.getStatus() == QuantityConstant.WAVE_STATUS_END) {
                //成功释放——找到此波次的未执行的子任务列表
                LambdaQueryWrapper<TaskDetail> lam = Wrappers.lambdaQuery();
                lam.eq(TaskDetail::getWarehouseCode, ShiroUtils.getWarehouseCode())
                        .eq(TaskDetail::getStatus, QuantityConstant.TASK_STATUS_BUILD)
                        .eq(TaskDetail::getWaveId, id);
                List<TaskDetail> taskDetails = taskDetailService.list(lam);
                if (taskDetails != null) {
                    taskDetailList.addAll(taskDetails);
                }
            }else {
                //失败释放——找到次波次的所有子单据
                LambdaQueryWrapper<ShipmentDetail> detailLam = Wrappers.lambdaQuery();
                detailLam.eq(ShipmentDetail::getWarehouseCode,ShiroUtils.getWarehouseCode())
                        .eq(ShipmentDetail::getWaveId,wave.getId());
                List<ShipmentDetail> shipmentDetails =shipmentDetailService.list(detailLam);

                //2.修改子单据的波次为0
                //3.修改主子单的状态
                HashSet<Integer> set = new HashSet<>();
                for(ShipmentDetail item : shipmentDetails){
                    if(item.getShipQty().compareTo(item.getRequestQty())!=0) {
                        item.setStatus(QuantityConstant.SHIPMENT_HEADER_POOL);
                    }
                    item.setWaveId(0);
                    set.add(item.getShipmentId());
                }
                flag = shipmentDetailService.updateBatchById(shipmentDetails);
                if(flag == false){
                    throw new ServiceException("修改出库子单状态失败");
                }
                for(Integer shipmentId :set){
                    ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentId);
                    if(shipmentHeader == null){
                        throw  new ServiceException("没有对应的出库主单");
                    }
                    if(shipmentHeader.getFirstStatus()<= QuantityConstant.SHIPMENT_HEADER_WAVE) {
                        shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_POOL);
                        flag = shipmentHeaderService.updateById(shipmentHeader);
                        if (flag == false) {
                            throw new ServiceException("修改出库主单失败");
                        }
                    }
                }
            }
        }

        HashSet<Integer> idSet = new HashSet();
        //成功释放——遍历子任务列表，找出主单（distinct）id
        for(TaskDetail item : taskDetailList){
            idSet.add(item.getTaskId());
        }
        //成功释放——将这些主任务执行
        taskHeaderService.sendTaskToWcs(idSet.toArray(new Integer[idSet.size()]));

        return AjaxResult.success("波次释放成功");
    }
}