package com.zy.asrs.common.wms.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.common.domain.dto.DetlDto;
import com.zy.asrs.common.domain.dto.LocTypeDto;
import com.zy.asrs.common.domain.dto.StartupDto;
import com.zy.asrs.common.domain.entity.StaDesc;
import com.zy.asrs.common.domain.param.FullStoreParam;
import com.zy.asrs.common.sys.service.StaDescService;
import com.zy.asrs.common.wms.entity.*;
import com.zy.asrs.common.wms.service.*;
import com.zy.asrs.framework.common.BaseRes;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.exception.CoolException;
import lombok.extern.slf4j.Slf4j;
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.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Created by vincent on 2020/6/11
 */
@Slf4j
@Service
public class WorkServiceImpl implements WorkService {

    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private MatService matService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private WrkMastLogService wrkMastLogService;
    @Autowired
    private WrkDetlLogService wrkDetlLogService;
    @Autowired
    private StaDescService staDescService;

    @Override
    @Transactional
    public String startupFullPutStore(FullStoreParam param, Long userId, Long hostId) {
        // 参数非空判断
        if (Cools.isEmpty(param.getDevpNo(), param.getList())) {
            throw new CoolException(BaseRes.PARAM);
        }
        Date now = new Date();
        LocTypeDto locTypeDto = new LocTypeDto();
        StartupDto dto = commonService.getLocNo(1, param.getDevpNo(), hostId, locTypeDto, 0);
        // 生成工作号
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(1L); // 工作状态：生成入库
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setBarcode(param.getBarcode()); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setAppeUser(String.valueOf(userId));
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(String.valueOf(userId));
        wrkMast.setModiTime(now);
        wrkMast.setHostId(hostId);
        if (!wrkMastService.save(wrkMast)) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        List<DetlDto> detlDtos = new ArrayList<>();
        param.getList().forEach(elem -> {
            DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getAnfme());
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch());
                assert detlDto1 != null;
                detlDto1.setAnfme(detlDto1.getAnfme() + detlDto.getAnfme());
            } else {
                detlDtos.add(detlDto);
            }
        });

        for (DetlDto detlDto : detlDtos) {
            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, detlDto.getMatnr()).eq(Mat::getHostId, hostId));
            if (Cools.isEmpty(mat)){
                throw new CoolException(detlDto.getMatnr() + "商品维护失败");
            }
            // 保持工作档明细
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(mat);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setIoTime(now);
            wrkDetl.setBatch(detlDto.getBatch());
            wrkDetl.setAnfme(detlDto.getAnfme()); // 数量
            wrkDetl.setZpallet(param.getBarcode()); // 托盘条码
            wrkDetl.setAppeUser(userId);
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setWrkMastId(wrkMast.getId());
            if (!wrkDetlService.save(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        }

        // 更新目标库位状态
        LocMast locMast = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, dto.getLocNo()).eq(LocMast::getHostId, hostId));
        if (locMast.getLocSts().equals("O")){
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
        }
        return dto.getLocNo();
    }

    @Override
    @Transactional
    public void completeWrkMast(String workNo, Long userId, Long hostId) {
        WrkMast wrkMast = wrkMastService.getOne(new LambdaQueryWrapper<WrkMast>().eq(WrkMast::getWrkNo, workNo).eq(WrkMast::getHostId, hostId));
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }
        if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 14) {
            throw new CoolException("当前工作档已完成");
        }
        // 入库 + 库位转移
        if (wrkMast.getWrkSts() < 99 || (wrkMast.getWrkSts() > 100 && wrkMast.getIoType()==11)) {
            wrkMast.setWrkSts(99L);//99.入库完成
            // 出库
        } else if (wrkMast.getWrkSts() > 100) {
            wrkMast.setWrkSts(199L);//199.出库完成
        }
        Date now = new Date();
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(String.valueOf(userId));
        // 完成操作人员记录
        wrkMast.setManuType("手动完成");
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("修改工作档失败");
        }
    }

    @Override
    @Transactional
    public void cancelWrkMast(String workNo, Long userId, Long hostId) {
        WrkMast wrkMast = wrkMastService.getOne(new LambdaQueryWrapper<WrkMast>().eq(WrkMast::getWrkNo, workNo).eq(WrkMast::getHostId, hostId));
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException(workNo + "工作档不存在");
        }
        String locNo = ""; // 待修改目标库位
        String locSts = ""; // 待修改目标库位状态
        // 入库取消（修改目标库位）
        if (wrkMast.getWrkSts() < 99) {
            locNo = wrkMast.getLocNo();
            locSts = "O";

            // 库位转移
            if (wrkMast.getIoType() == 11) {
                // 库位转移：源库位
                LocMast locMast = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, wrkMast.getSourceLocNo()).eq(LocMast::getHostId, hostId));
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，源库位不存在:" + wrkMast.getSourceLocNo());
                }
                locMast.setLocSts("F");
                locMast.setModiTime(new Date());
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
            }
            // 出库取消（修改源库位）
        } else if (wrkMast.getWrkSts() > 100 && wrkMast.getWrkSts() != 199) {
            locNo = wrkMast.getSourceLocNo();
            // 出库 ===>> F.在库
            if (wrkMast.getIoType() > 100 && wrkMast.getIoType() != 110) {
                locSts = "F";
                // 空板出库 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 110) {
                locSts = "D";
                // 库位转移 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 11) {
                locSts = wrkMast.getFullPlt().equalsIgnoreCase("N") ? "D" : "F";
                // 库位转移：目标库位
                LocMast locMast = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, wrkMast.getLocNo()).eq(LocMast::getHostId, hostId));
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，目标库位不存在:" + wrkMast.getSourceLocNo());
                }
                locMast.setLocSts("O");
                locMast.setModiTime(new Date());
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
            }
        } else {
            throw new CoolException("当前工作状态无法取消");
        }
        // 订单关联
        List<WrkDetl> wrkDetls = wrkDetlService.list(new LambdaQueryWrapper<WrkDetl>().eq(WrkDetl::getWrkNo, wrkMast.getWrkNo()).eq(WrkDetl::getHostId, hostId));
        for (WrkDetl wrkDetl : wrkDetls) {
            if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                if (!orderDetlService.decrease(wrkDetl.getOrderNo(), hostId, wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme())) {
                    throw new CoolException("订单数据回滚失败");
                }
            }
        }
        // 取消操作人员记录
        wrkMast.setManuType("手动取消");
        wrkMast.setModiUser(String.valueOf(userId));
        wrkMast.setModiTime(new Date());
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("取消工作档失败");
        }
        // 保存工作主档历史档
        if (!wrkMastLogService.saveToHistory(wrkMast.getId())) {
            throw new CoolException("保存工作历史档失败, workNo = " + wrkMast.getWrkNo());
        }
        // 删除工作主档
        boolean wrkMastRes = wrkMastService.removeById(wrkMast);

        if (wrkMast.getIoType() != 10 && wrkMast.getIoType() != 110) {
            // 保存工作明细档历史档
            if (!wrkDetlLogService.saveToHistory(wrkMast.getWrkNo(), hostId)) {
                throw new CoolException("保存工作明细历史档失败, workNo = " + wrkMast.getWrkNo());
            }
            // 删除工作档明细
            boolean wrkDetlRes = wrkDetlService.remove(new LambdaQueryWrapper<WrkDetl>().eq(WrkDetl::getWrkNo, workNo).eq(WrkDetl::getHostId, hostId));
        }

        // 修改库位状态
        LocMast locMast = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, locNo).eq(LocMast::getHostId, hostId));
        if (Cools.isEmpty(locMast)) {
            throw new CoolException("取消工作档失败，库位不存在:" + locNo);
        }
        locMast.setLocSts(locSts);
        locMast.setModiTime(new Date());
        locMast.setModiUser(userId);
        boolean locMastRes = locMastService.updateById(locMast);
        if (!wrkMastRes || !locMastRes) {
            throw new CoolException("保存数据失败");
        }
    }

    @Override
    @Transactional
    public void pickWrkMast(String workNo, Long userId, Long hostId) {
        WrkMast wrkMast = wrkMastService.getOne(new LambdaQueryWrapper<WrkMast>().eq(WrkMast::getWrkNo, workNo).eq(WrkMast::getHostId, hostId));
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException(workNo + "工作档不存在");
        }
        // 入出库类型判断
        if (wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) {
            throw new CoolException("当前入出库类型无法进行操作");
        }
        // 工作状态判断
        if (wrkMast.getWrkSts() < 101 || wrkMast.getWrkSts() == 200) {
            throw new CoolException("当前工作状态无法进行操作");
        }
        // 保存工作明细档历史档
//        if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
//            throw new CoolException("保存工作明细档历史档失败");
//        }
        // 保存工作主档历史档
        if (!wrkMastLogService.saveToHistory(wrkMast.getId())) {
            throw new CoolException("保存工作主档历史档失败");
        }
        // 获取目标站
        LambdaQueryWrapper<StaDesc> wrapper = new LambdaQueryWrapper<StaDesc>()
                .eq(StaDesc::getTypeNo, wrkMast.getIoType() - 50)
                .eq(StaDesc::getStnNo, wrkMast.getStaNo()); // 作业站点 = 拣料出库的目标站
        StaDesc staDesc = staDescService.getOne(wrapper);
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("入库路径不存在");
        }
        // 堆垛机站点(目标站)
        Integer staNo = staDesc.getDeviceStn();
        Date now = new Date();
        // 更新工作档数据状态
        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
        wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
        wrkMast.setStaNo(staNo); // 目标站
        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
        wrkMast.setSourceLocNo(""); // 源库位清空
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(String.valueOf(userId));
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("更新工作档数据状态失败");
        }
        // 修改库位状态 Q.拣料/盘点/并板再入库
        LocMast locMast = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, wrkMast.getLocNo()).eq(LocMast::getHostId, hostId));
        locMast.setLocSts("Q");
        locMast.setModiTime(now);
        locMast.setModiUser(userId);
        if (!locMastService.updateById(locMast)) {
            throw new CoolException("修改库位状态失败");
        }
    }

}