package com.glxp.api.controller.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.github.pagehelper.PageInfo;
import com.glxp.api.annotation.AuthRuleAnnotation;
import com.glxp.api.common.enums.ResultEnum;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
import com.glxp.api.entity.inout.IoOrderDetailCodeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.req.inout.FilterOrderDetailResultRequest;
import com.glxp.api.req.inout.ReviewFinishRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.inout.AcceptOrderResponse;
import com.glxp.api.res.inout.IoOrderDetailResultResponse;
import com.glxp.api.service.inout.*;
import com.glxp.api.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Locale;

//单据验收
@Slf4j
@RestController
public class IoOrderReviewController extends BaseController {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private IoOrderDetailResultService orderDetailResultService;
    @Resource
    IoOrderService orderService;
    @Resource
    IoCheckInoutService ioCheckInoutService;

    //获取验收单据业务详情
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/stock/order/accept/getOrder")
    public BaseResponse getAcceptOrder(String billNo) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        AcceptOrderResponse acceptOrderEntity = new AcceptOrderResponse();
        acceptOrderEntity.setBillNo(billNo);
        List<IoOrderDetailResultResponse> datas = (List<IoOrderDetailResultResponse>) redisUtil.get(ConstantStatus.REDIS_BILLNO + billNo);
        if (CollUtil.isNotEmpty(datas)) {
            acceptOrderEntity.setOrderDetailEntities(datas);
            acceptOrderEntity.setExitAccept(true);
        } else {
            FilterOrderDetailResultRequest filterOrderDetailResultRequest = new FilterOrderDetailResultRequest();
            filterOrderDetailResultRequest.setOrderIdFk(billNo);
            List<IoOrderDetailResultResponse> orderDetailResultResponses = orderDetailResultService.filterList(filterOrderDetailResultRequest);
            acceptOrderEntity.setOrderDetailEntities(orderDetailResultResponses);
            acceptOrderEntity.setExitAccept(false);
        }
        return ResultVOUtils.success(acceptOrderEntity);

    }


    //前端直接验收完成
    @AuthRuleAnnotation("")
    @PostMapping("/spms/inout/order/web/updateStatus")
    public BaseResponse webUpdateStatus(@RequestBody ReviewFinishRequest updateExportStatusRequest,
                                        BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        IoOrderEntity orderEntity = orderService.findByBillNo(updateExportStatusRequest.getOrderId());
        if (orderEntity == null) {
            return ResultVOUtils.error(500, "未找到该业务单据");
        }
        return updateReview(orderEntity);
    }

    @Resource
    IoCodeService codeService;

    //前端扫码验收
    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/stock/order/accept/addCode")
    public BaseResponse acceptAddCode(@RequestBody AcceptOrderResponse acceptOrderEntity) {

        IoOrderEntity stockOrderEntity = orderService.findByBillNo(acceptOrderEntity.getBillNo());

        List<IoCodeEntity> codeList;
        List<IoCodeEntity> codeEntityList = (List<IoCodeEntity>) redisUtil.get(ConstantStatus.REDIS_BILLNO_CODES + acceptOrderEntity.getBillNo());
        if (CollUtil.isEmpty(codeEntityList)) {
            codeList = codeService.findByOrderId(stockOrderEntity.getBillNo());
        } else {
            codeList = codeEntityList;
        }
        IoCodeEntity codeEntity = isExit(codeList, acceptOrderEntity.getCode());
        if (codeEntity == null) {
            return ResultVOUtils.error(500, "非此单UDI码！");
        }

        int status = checkCodeExit(codeEntity.getCode(), codeList);
        if (status == Constant.CHECK_REPEAT) {
            return ResultVOUtils.error(500, "重复扫码!");
        } else if (status == Constant.CHECK_NULL) {
            return ResultVOUtils.error(500, "非此单UDI码！");
        }

        List<IoOrderDetailResultResponse> orderDetailResultResponses = acceptOrderEntity.getOrderDetailEntities();
        if (StrUtil.isNotEmpty(acceptOrderEntity.getCode()) && CollUtil.isNotEmpty(orderDetailResultResponses)) {

            boolean isExit = false;
            for (IoOrderDetailResultResponse orderDetailResultResponse : orderDetailResultResponses) {
                if (orderDetailResultResponse.getBindRlFk().longValue() == codeEntity.getRelId().longValue() &&
                        StrUtil.trimToEmpty(orderDetailResultResponse.getBatchNo()).equals(StrUtil.trimToEmpty(codeEntity.getBatchNo()))) {
                    orderDetailResultResponse.setAcceptCount(orderDetailResultResponse.getAcceptCount() + codeEntity.getReCount());
                    if (orderDetailResultResponse.getAcceptCount() > orderDetailResultResponse.getCount()) {
                        return ResultVOUtils.error(500, "数量溢出！");
                    }
                    isExit = true;
                    break;
                }
            }
            if (isExit) {
                redisUtil.set(ConstantStatus.REDIS_BILLNO + acceptOrderEntity.getBillNo(), orderDetailResultResponses);
                redisUtil.set(ConstantStatus.REDIS_BILLNO_CODES + acceptOrderEntity.getBillNo(), codeList);
                acceptOrderEntity.setOrderDetailEntities(orderDetailResultResponses);
                if (vailFinish(orderDetailResultResponses)) {
                    acceptOrderEntity.setFinishAccept(true);
                    return ResultVOUtils.success(acceptOrderEntity);
                }

                return ResultVOUtils.success(acceptOrderEntity);
            }

        }
        return ResultVOUtils.error(500, "非此单条码！");
    }


    public int checkCodeExit(String code, List<IoCodeEntity> codesList) {
        if (StrUtil.isNotEmpty(code)) {
            code = code.replace("\r\n", "");
        }

        if (code.endsWith("\u001D")) {
            code = code.replace("\u001D", "");
        }

        for (IoCodeEntity checkOrderCodesBean : codesList) {
            if (checkOrderCodesBean.getCode().toUpperCase(Locale.ROOT).equals(code.toUpperCase(Locale.ROOT))) {
                if (checkOrderCodesBean.getStatus() == Constant.DB_CHECK_ED
                        && checkOrderCodesBean.getCount() == checkOrderCodesBean.getScanCount()) {
                    return Constant.CHECK_REPEAT;
                }
                int curCount = checkOrderCodesBean.getScanCount() + checkOrderCodesBean.getCount();
                if (curCount == checkOrderCodesBean.getCount()) {
                    checkOrderCodesBean.setStatus(Constant.DB_CHECK_ED);
                }
                checkOrderCodesBean.setScanCount(curCount);
                return Constant.CHECK_EXIT;
            }
        }
        return Constant.CHECK_NULL;
    }

    public IoCodeEntity isExit(List<IoCodeEntity> codeList, String code) {
        if (CollUtil.isNotEmpty(codeList)) {
            for (IoCodeEntity codeEntity : codeList) {
                if (codeEntity.getCode().equals(code)) {
                    return codeEntity;
                }
            }
        }
        return null;
    }


    public boolean vailFinish(List<IoOrderDetailResultResponse> orderDetailResultResponses) {
        if (CollUtil.isNotEmpty(orderDetailResultResponses)) {
            for (IoOrderDetailResultResponse stockOrderDetailEntity : orderDetailResultResponses) {
                if (stockOrderDetailEntity.getCount() != stockOrderDetailEntity.getAcceptCount()) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/stock/order/acceptClear")
    public BaseResponse acceptClear(@RequestBody AcceptOrderResponse acceptOrderEntity) {
        String billNo = acceptOrderEntity.getBillNo();
        redisUtil.del(ConstantStatus.REDIS_BILLNO + billNo);
        redisUtil.del(ConstantStatus.REDIS_BILLNO_CODES + billNo);
        FilterOrderDetailResultRequest filterOrderDetailResultRequest = new FilterOrderDetailResultRequest();
        filterOrderDetailResultRequest.setOrderIdFk(billNo);
        List<IoOrderDetailResultResponse> orderDetailResultResponses = orderDetailResultService.filterList(filterOrderDetailResultRequest);
        acceptOrderEntity.setOrderDetailEntities(orderDetailResultResponses);
        return ResultVOUtils.success(acceptOrderEntity);
    }


    public BaseResponse updateReview(IoOrderEntity orderEntity) {
        AuthAdmin authAdmin = getUser();
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
        orderEntity.setReviewUser(authAdmin.getId() + "");
        orderEntity.setUpdateTime(new Date());
        orderEntity.setAuditTime(new Date());
        orderService.update(orderEntity);
        redisUtil.del(ConstantStatus.REDIS_BILLNO + orderEntity.getBillNo());
        redisUtil.del(ConstantStatus.REDIS_BILLNO_CODES + orderEntity.getBillNo());
        //验收完成->进入流程
        ioCheckInoutService.checkSecond(orderEntity);
        return ResultVOUtils.success("更新成功");
    }



}