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.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
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.shippingCombination.service.ShippingCombinationService;
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.domain.TaskHeader;
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.*;

@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;
    @Autowired
    private ShippingCombinationService shippingCombinationService;

    /**
     * 开始波次，对带有此波次号的单据进行后续的后台操作
     * 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.getCurrentWaveStep()> QuantityConstant.WAVE_STEP_BUILD &&
                    wave.getCurrentWaveStep() < QuantityConstant.WAVE_STEP_ERROR)){
                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.getCode() != 200){
            for(Wave wave : waves) {
                wave.setStatus(QuantityConstant.WAVE_STATUS_ERROR);
                wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_ERROR);
                wave.setLastWaveStep(QuantityConstant.WAVE_STEP_BUILD);
                this.updateById(wave);
            }
            throw new ServiceException("波次执行失败,组盘失败");
        }


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


    /**
     * 剔除单据，剔除无法组盘的单据
     * 1、找到无法组盘的单据
     * 2、剔除单据
     * 3、修改波次的状态
     */

    @Transactional
    public AjaxResult cullWave(String ids) {
        //判断波次是否可以完成
        for (Integer id : Convert.toIntArray(ids)) {
            Wave wave =this.getById(id);
            if(wave == null){
                return AjaxResult.error("id为"+id+"的波次不存在");
            }

            if(!wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STEP_BUILD) &&
                    !wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STEP_ERROR)){
                return AjaxResult.error("id为"+id+"的波次已执行，无法剔除单据");
            }

            LambdaQueryWrapper<ShipmentDetail> detailLamb = Wrappers.lambdaQuery();
            detailLamb.eq(ShipmentDetail::getWaveId,id)
                    .eq(ShipmentDetail::getWarehouseCode,ShiroUtils.getWarehouseCode());
            List<ShipmentDetail> shipmentDetailList =shipmentDetailService.list(detailLamb);
            for(ShipmentDetail item :shipmentDetailList){
                List<InventoryDetail> list =shippingCombinationService.getInventorys(item);
                if(list.isEmpty()){
                    item.setWaveId(0);
                    shipmentDetailService.updateById(item);
                }
            }

            //修改波次状态
            wave.setStatus(QuantityConstant.WAVE_STATUS_BUILD);
            wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_CULL);
            wave.setLastWaveStep(QuantityConstant.WAVE_STEP_START);
            wave.setLastUpdatedBy(ShiroUtils.getLoginName());
            wave.setLastUpdated(new Date());
            this.updateById(wave);
        }
        return AjaxResult.success("波次运行成功");
    }



    /**
     * 完成波次，对带有此波次号的组盘进行后续的后台操作
     * 1、查看波次是否符合完成波次的条件
     * 2、生成任务
     * 3、修改波次的状态
     */

    @Transactional
    public AjaxResult endWave(String ids) {
        //判断波次是否可以完成
        for (Integer id : Convert.toIntArray(ids)) {
            Wave wave =this.getById(id);
            if(wave == null){
                return AjaxResult.error("id为"+id+"的波次不存在");
            }

            if(!wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STEP_START)){
                return AjaxResult.error("id为"+id+"的波次未执行，无法完成");
            }

            //2、找到此波次的所有阻盘头，生成任务
            LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLamb = Wrappers.lambdaQuery();
            shipmentContainerHeaderLamb.eq(ShipmentContainerHeader::getWarehouseCode,ShiroUtils.getWarehouseCode())
                    .eq(ShipmentContainerHeader::getWaveId,id);
            List<ShipmentContainerHeader> shipmentContainerHeaders =shipmentContainerHeaderService.list(shipmentContainerHeaderLamb);

            if(shipmentContainerHeaders.isEmpty()){
                return AjaxResult.error("id为"+id+"的波次的出库组盘头未找到");
            }

            //找到未生成出库任务的组盘头
            List<Integer> idList =new ArrayList<>();
            for(ShipmentContainerHeader item : shipmentContainerHeaders){
                if(item.getStatus().equals(QuantityConstant.SHIPMENT_CONTAINER_BUILD)){
                    idList.add(item.getId());
                }
            }
            if(idList.isEmpty()){
                return AjaxResult.error("id为"+id+"的波次的出库组盘头都已生成任务");
            }

            AjaxResult ajaxResult =shipmentContainerHeaderService.createTask(idList);
            if(ajaxResult.hasErr()){
                throw new ServiceException("id为"+id+"的波次的出库组盘头生成任务失败");
            }

            //修改波次状态
            wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_END);
            wave.setLastWaveStep(QuantityConstant.WAVE_STEP_START);
            wave.setLastUpdatedBy(ShiroUtils.getLoginName());
            wave.setLastUpdated(new Date());
            this.updateById(wave);
        }
        return AjaxResult.success("波次运行成功");
    }



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

                //1、查看此波次是否可以释放
                Wave wave = this.getById(id);
                 if(wave == null || wave.getStatus().equals(QuantityConstant.WAVE_STATUS_START)){
                    return AjaxResult.error(id+"波次不可释放,正在执行中");
                }

            //2、查看此波次的状态,看是成功释放还是失败释放
                //失败释放——找到次波次的所有子单据和主单
                LambdaQueryWrapper<ShipmentDetail> detailLam = Wrappers.lambdaQuery();
                detailLam.eq(ShipmentDetail::getWarehouseCode,ShiroUtils.getWarehouseCode())
                        .eq(ShipmentDetail::getWaveId,wave.getId());
                List<ShipmentDetail> shipmentDetails =shipmentDetailService.list(detailLam);

                LambdaQueryWrapper<ShipmentHeader> headerLam =Wrappers.lambdaQuery();
                headerLam.eq(ShipmentHeader::getWarehouseCode,ShiroUtils.getWarehouseCode())
                        .eq(ShipmentHeader::getWaveId,wave.getId());
                List<ShipmentHeader> shipmentHeaders = shipmentHeaderService.list(headerLam);

                if(shipmentDetails.isEmpty()) {
                    throw new ServiceException("该波次"+id+"的子单未查到");
                }

                if(shipmentHeaders.isEmpty()) {
                    throw new ServiceException("该波次"+id+"的主单未查到");
                }

                //2.修改主子单据的波次为0
                //3.修改主子单的状态
                HashSet<Integer> set = new HashSet<>();
                for(ShipmentDetail item : shipmentDetails){
                    if(item.getShipQty().compareTo(item.getRequestQty())==0) {
                        item.setStatus(QuantityConstant.SHIPMENT_HEADER_GROUPDISK);
                    }else {
                        item.setStatus(QuantityConstant.SHIPMENT_HEADER_POOL);
                    }
                    item.setWaveId(0);
                    set.add(item.getShipmentId());
                }
                flag = shipmentDetailService.updateBatchById(shipmentDetails);
                if(flag == false){
                    throw new ServiceException("修改出库子单状态失败");
                }

                for(ShipmentHeader shipmentHeader : shipmentHeaders) {
                    if (shipmentHeader.getFirstStatus() <= QuantityConstant.SHIPMENT_HEADER_WAVE) {
                        shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_POOL);
                    }
                    if (shipmentHeader.getLastStatus() <= QuantityConstant.SHIPMENT_HEADER_WAVE) {
                        shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_POOL);
                    }
                    flag = shipmentHeaderService.updateById(shipmentHeader);
                    if (flag == false) {
                        throw new ServiceException("修改出库主单失败");
                    }
                }

                if(wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STEP_END)) {
                    //成功释放——找到此波次的未执行的子任务列表
                    LambdaQueryWrapper<TaskHeader> lam = Wrappers.lambdaQuery();
                    lam.eq(TaskHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())
                            .eq(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_BUILD)
                            .eq(TaskHeader::getWaveId, id);
                    List<TaskHeader> taskHeaders = taskHeaderService.list(lam);
                    if (taskHeaders == null) {
                        throw new ServiceException("该波次的主任务找不到");
                    }
                    List<Integer> taskIds =new ArrayList<>();
                    for(TaskHeader item :taskHeaders){
                        taskIds.add(item.getId());
                    }
                    taskHeaderService.sendTaskToWcs(taskIds.toArray(new Integer[taskIds.size()]));
                }

                //修改波次状态
                if(wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STEP_END)) {
                    wave.setStatus(QuantityConstant.WAVE_STATUS_END);
                    wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_FREED);
                    wave.setLastWaveStep(QuantityConstant.WAVE_STEP_END);
                }
                if(wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STATUS_BUILD)){
                    wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_FREED);
                    wave.setLastWaveStep(QuantityConstant.WAVE_STEP_BUILD);
                }
                if(wave.getCurrentWaveStep().equals(QuantityConstant.WAVE_STATUS_ERROR)){
                    wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_FREED);
                    wave.setLastWaveStep(QuantityConstant.WAVE_STEP_ERROR);
                }
                wave.setLastUpdatedBy(ShiroUtils.getLoginName());
                wave.setLastUpdated(new Date());
                this.updateById(wave);
        }
        return AjaxResult.success("波次释放成功");
    }
}