package com.dk.mdm.service.ivt;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.dk.common.exception.BaseBusinessException;
import com.dk.common.infrastructure.annotaiton.Pagination;
import com.dk.common.infrastructure.constant.Constant;
import com.dk.common.infrastructure.enums.ErrorCodeEnum;
import com.dk.common.model.pojo.PageList;
import com.dk.common.response.ResponseCodeEnum;
import com.dk.common.response.ResponseResultUtil;
import com.dk.common.response.ResponseResultVO;
import com.dk.mdm.infrastructure.convert.ivt.OutboundConvert;
import com.dk.mdm.infrastructure.convert.ivt.OutboundItemConvert;
import com.dk.mdm.mapper.ivt.OutboundItemMapper;
import com.dk.mdm.mapper.pur.PurchaseItemMapper;
import com.dk.mdm.mapper.sale.OrderItemMapper;
import com.dk.mdm.mapper.sale.OrderMapper;
import com.dk.mdm.model.pojo.ivt.Outbound;
import com.dk.mdm.mapper.ivt.OutboundMapper;
import com.dk.common.service.BaseService;
import com.dk.common.mapper.BaseMapper;
import com.dk.mdm.model.pojo.ivt.OutboundItem;
import com.dk.mdm.model.pojo.sale.Order;
import com.dk.mdm.model.pojo.sale.OrderItem;
import com.dk.mdm.model.query.ivt.OutboundItemQuery;
import com.dk.mdm.model.query.ivt.OutboundQuery;
import com.dk.mdm.model.response.ivt.OutboundItemResponse;
import com.dk.mdm.model.response.ivt.OutboundResponse;
import com.dk.mdm.model.vo.ivt.OutboundItemVO;
import com.dk.mdm.model.vo.ivt.OutboundVO;
import com.dk.mdm.service.common.CommonService;
import com.dk.mdm.service.sale.OrderItemService;
import com.dk.mdm.service.sale.OrderService;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
@Transactional
public class OutboundService extends BaseService<Outbound> {

    @Override
    public String getPrimaryKey() {
        return "out_id";
    }

    @Override
    public BaseMapper<Outbound> getRepository() {
        return outboundMapper;
    }

    @Autowired
    private OutboundMapper outboundMapper;

    @Autowired
    private OutboundItemService outboundItemService;

    @Autowired
    private OutboundItemMapper outboundItemMapper;

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderItemService orderItemService;

    @Autowired
    private OrderItemMapper orderItemMapper;

    @Autowired
    private CommonService commonService;

    @Autowired
    private OutboundConvert outboundConvert;

    @Autowired
    private OutboundItemConvert outboundItemConvert;

    @Autowired
    private PurchaseItemMapper purchaseItemMapper;

    /**
     * @desc : 条件查询
     * @author : 付斌
     * @date : 2023/1/9 10:40
     */
    @Pagination
    public ResponseResultVO<PageList<OutboundResponse>> selectByCond(OutboundQuery outboundQuery) {
        return super.mergeListWithCount(outboundQuery, outboundMapper.selectByCond(outboundQuery),
                outboundMapper.countByCond(outboundQuery));
    }

    /**
     * @desc : 查询订单明细（货物、收款、附件）
     * @author : 付斌
     * @date : 2024-02-28 13:25
     */
    @Pagination
    public ResponseResultVO<Map<String, Object>> selectOutboundInfoById(String id) {
        Map<String, Object> result = new HashMap<>();
        // 商品明细
        List<OutboundItemResponse> outboundItem = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(id));
        result.put("outboundItem", outboundItem);

        // 收款

        // 附件
        return ResponseResultUtil.success(result);
    }

    /**
     * @desc : 新建方法
     * @author : 付斌
     * @date : 2023/1/9 10:49
     */
    @Transactional(
            rollbackFor = {Exception.class}
    )
    public ResponseResultVO<?> insert(OutboundVO outboundVO) {

        // 获取单号
        Map<String, Object> codeMap = commonService.getUniqueNoteCode(Constant.docNameConstant.OUTBOUND.getName(), false);
        outboundVO.setOutId(codeMap.get("outId").toString()).setOutNo(codeMap.get("outNote").toString())
                .setOutType(Constant.OutType.SALE.getName());
        // 转化实体
        Outbound outbound = outboundConvert.convertToPo(outboundVO);
        // 总单保存
        super.insert(outbound);

        // 明细保存
        if (outboundVO.getItemList() != null && outboundVO.getItemList().size() > 0) {
            double sumOutingQty = 0;    // 合计出库中数量
            double sumOutingAmt = 0;    // 合计出库中金额
            OrderItem orderItemForUpdate;
            for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {
                OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                outboundItem.setOutId(outbound.getOutId()).setCpId(outbound.getCpId()).setOutStatus(Constant.OutStatus.CHUKUZHONG.getName())
                        .setOutType(Constant.OutType.SALE.getName());
                outboundItemMapper.insert(outboundItem);

                // 反写订单出库中数量、金额
                orderItemForUpdate = orderItemMapper.selectByIdForUpdate(outboundItem.getFromItemId());
                // 如果商品数量小于订单+本次出库单上的出库中数量
                if (orderItemForUpdate.getItemQty().compareTo(orderItemForUpdate.getOutingQty().add(outboundItem.getOutingQty())) == -1) {
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ITEMQTY_NO_LESS_OUTQTY.getMessage());
                }
                OrderItem orderItemUpdate = new OrderItem();
                orderItemUpdate.setOutingQty(orderItemForUpdate.getOutingQty().add(outboundItem.getOutingQty()))
                        .setOutingAmt(orderItemForUpdate.getOutingAmt().add(outboundItem.getOutingAmt()))
                        .setItemId(orderItemForUpdate.getItemId());
                orderItemService.updateByUuid(orderItemUpdate);
                // 累加出库中数量，金额
                sumOutingQty += outboundItem.getOutingQty().doubleValue();
                sumOutingAmt += outboundItem.getOutingAmt().doubleValue();

            }
            // 更新订单上的出库中数量，金额，状态
            Order orderForUpdate = orderMapper.selectByIdForUpdate(outboundVO.getFromId());
            Order orderUpdate = new Order();
            orderUpdate.setOutingQty(orderForUpdate.getOutingQty().add(new BigDecimal(sumOutingQty)))
                    .setOutingAmt(orderForUpdate.getOutingAmt().add(new BigDecimal(sumOutingAmt)))
                    .setOutStatus(Constant.OutStatus.CHUKUZHONG.getName())
                    .setOrderId(outboundVO.getFromId());
            orderService.updateByUuid(orderUpdate);
        }
        return ResponseResultUtil.success();
    }

    /**
     * @desc : 编辑方法
     * @author : 付斌
     * @date : 2023/1/9 10:49
     */
    @Transactional(
            rollbackFor = {Exception.class}
    )
    public ResponseResultVO<Boolean> update(OutboundVO outboundVO) {
        // 订单明细实体
        OrderItem orderItemForUpdate;
        // 订单明细实体
        OutboundItem outboundItemForUpdate;
        // 转化实体
        Outbound outbound = outboundConvert.convertToPo(outboundVO);

        // 编辑出库明细
        List<OutboundItemVO> editOutboundItemVOList = outboundVO.getItemList().stream().filter(it -> it.getItemId() != null).collect(Collectors.toList());
        for (OutboundItemVO outboundItemVO : editOutboundItemVOList) {
            // 出库中数量不能小于出库数量
            if (outboundItemVO.getOutingQty().compareTo(outboundItemVO.getOutQty()) == -1) {
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.OUTINGQTY_NO_LESS_OUTQTY.getMessage());
            }

            outboundItemForUpdate = outboundItemMapper.selectByIdForUpdate(outboundItemVO.getItemId());
            orderItemForUpdate = orderItemMapper.selectByIdForUpdate(outboundItemVO.getFromItemId());

            // 订单的商品数量不能小于（订单之前的出库中数量 - 出库明细之前的出库中数量 + 出库明细现在的出库中数量）
            if (orderItemForUpdate.getItemQty().compareTo(orderItemForUpdate.getOutingQty().subtract(outboundItemForUpdate.getOutingQty()).add(outboundItemVO.getOutingQty())) == -1) {
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ITEMQTY_NO_LESS_OUTQTY.getMessage());
            }
            // 更新订单明细出库中数量
            OrderItem orderItemUpdate = new OrderItem();
            orderItemUpdate.setOutingQty(orderItemForUpdate.getOutingQty().subtract(outboundItemForUpdate.getOutingQty()).add(outboundItemVO.getOutingQty()))
                    .setOutingAmt(orderItemForUpdate.getOutingAmt().subtract(outboundItemForUpdate.getOutingAmt()).add(outboundItemVO.getOutingAmt()))
                    .setItemId(orderItemForUpdate.getItemId());
            orderItemService.updateByUuid(orderItemUpdate);
            // 更新出库明细
            OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
            outboundItemService.updateByUuid(outboundItem);
        }

        Outbound outboundForUpdate = outboundMapper.selectByIdForUpdate(outboundVO.getOutId());

        // 更新订单上的退货数量，金额
        Order orderForUpdate = orderMapper.selectByIdForUpdate(outboundVO.getFromId());
        Order orderUpdate = new Order();
        orderUpdate.setOutingQty(orderForUpdate.getOutingQty().subtract(outboundForUpdate.getOutingQty()).add(outboundForUpdate.getOutingQty()))
                .setOutingAmt(orderForUpdate.getOutingAmt().subtract(outboundForUpdate.getOutingAmt()).add(outboundForUpdate.getOutingAmt()))
                .setOrderId(outboundVO.getFromId());
        orderService.updateByUuid(orderUpdate);

        return ResponseResultUtil.success(super.update(outbound, new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId,
                UUID.fromString(outbound.getOutId()))));
    }

    /**
     * @desc : 作废
     * @author : 付斌
     * @date : 2024-03-08 16:38
     */
    public ResponseResultVO<?> invalid(String id) {
        Outbound outbound = outboundMapper.selectByIdForUpdate(id);
        // 如果退货数量不是0，不能作废
        if (!outbound.getReturnQty().equals(new BigDecimal(0))) {
            throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ISEXISTS_AFTER_OPERATE.getMessage());
        }

        double sumOutingQty = 0;    // 合计出库中数量
        double sumOutingAmt = 0;    // 合计出库中金额
        List<OutboundItem> outboundItemList = outboundItemMapper.selectByZIdForUpdate(id);
        OrderItem orderItemForUpdate;
        for (OutboundItem outboundItemForUpdate : outboundItemList) {
            orderItemForUpdate = orderItemMapper.selectByIdForUpdate(outboundItemForUpdate.getFromItemId());
            // 更新订单明细出库中数量
            OrderItem orderItemUpdate = new OrderItem();
            orderItemUpdate.setOutingQty(orderItemForUpdate.getOutingQty().subtract(outboundItemForUpdate.getOutingQty()))
                    .setOutingAmt(orderItemForUpdate.getOutingAmt().subtract(outboundItemForUpdate.getOutingAmt()))
                    .setItemId(orderItemForUpdate.getItemId());
            orderItemService.updateByUuid(orderItemUpdate);

            // 累加出库中数量，金额
            sumOutingQty += outboundItemForUpdate.getOutingQty().doubleValue();
            sumOutingAmt += outboundItemForUpdate.getOutingAmt().doubleValue();
        }

        // 更新订单上的出库中数量，金额，状态
        Order orderForUpdate = orderMapper.selectByIdForUpdate(outbound.getFromId());
        Order orderUpdate = new Order();
        orderUpdate.setOutingQty(orderForUpdate.getOutingQty().subtract(new BigDecimal(sumOutingQty)))
                .setOutingAmt(orderForUpdate.getOutingAmt().subtract(new BigDecimal(sumOutingAmt)))
                .setOrderId(outbound.getFromId());
        // 如果出库中数量为0了，更新状态为待出库
        if(orderUpdate.getOutingQty().equals(new BigDecimal(0))){
            orderUpdate.setOutStatus(Constant.OutStatus.DAICHUKU.getName());
        }
        orderService.updateByUuid(orderUpdate);

        // 作废
        Outbound outboundUpdate = new Outbound();
        outboundUpdate.setFlgValid(false).setOutId(id);
        super.update(outboundUpdate, new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId,
                UUID.fromString(outboundUpdate.getOutId())));
        return ResponseResultUtil.success();
    }

    /**
     * @desc : 获取订单信息（编辑用）
     * @author : 付斌
     * @date : 2024-03-02 17:27
     */
    public ResponseResultVO<?> getOutboundForUpdate(String id) {
        Map<String, Object> outboundInfo = new HashMap<>();
        OutboundResponse outboundResponse = outboundMapper.selectById(id);
        outboundInfo.put("outbound", outboundResponse);

        // 商品明细
        List<OutboundItemResponse> outboundItemResponse = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(id));
        outboundInfo.put("outboundItem", outboundItemResponse);
        return ResponseResultUtil.success(outboundInfo);
    }

    /**
     * @desc : 采购退货出库
     * @author : 于继渤
     * @date : 2023/1/9 10:49
     */
    @Transactional(
            rollbackFor = {Exception.class}
    )
    public ResponseResultVO<?> insertOutBound(OutboundVO outboundVO) {

        // 获取单号
        Map<String, Object> codeMap = commonService.getUniqueNoteCode(Constant.docNameConstant.OUTBOUND.getName(), false);
        outboundVO.setOutId(codeMap.get("outId").toString()).setOutNo(codeMap.get("outNote").toString())
                .setOutType(Constant.OutType.PURRETURN.getName());
        // 转化实体
        Outbound outbound = outboundConvert.convertToPo(outboundVO);
        // 总单保存
        super.insert(outbound);

        // 明细保存
        if (outboundVO.getItemList() != null && outboundVO.getItemList().size() > 0) {
            double sumOutingQty = 0;    // 合计出库中数量
            double sumOutingAmt = 0;    // 合计出库中金额
            for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {
                OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                outboundItem.setOutId(outbound.getOutId()).setCpId(outbound.getCpId()).setOutStatus(Constant.OutStatus.CHUKUZHONG.getName())
                        .setOutType(Constant.OutType.PURRETURN.getName());
                outboundItemMapper.insert(outboundItem);

//				PurchaseItemResponse purchaseItemResponse = purchaseItemMapper.selectById(outboundItem.getFromItemId());

                // 如果商品数量小于订单+本次出库单上的出库中数量
//				if(orderItem.getItemQty().compareTo(orderItem.getOutingQty().add(outboundItem.getOutingQty())) == -1){
//					throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ITEMQTY_NO_LESS_OUTQTY.getMessage());
//				}else{
//					OrderItem orderItemUpdate = new OrderItem();
//					orderItemUpdate.setOutingQty(orderItem.getOutingQty().add(outboundItem.getOutingQty()))
//							.setOutingAmt(orderItem.getOutingAmt().add(outboundItem.getOutingAmt()))
//							.setItemId(orderItem.getItemId());
//					orderItemService.updateByUuid(orderItemUpdate);
//					// 累加出库中数量，金额
//					sumOutingQty += outboundItem.getOutingQty().doubleValue();
//					sumOutingAmt += outboundItem.getOutingAmt().doubleValue();
//				}
            }
//			// 更新订单上的出库中数量，金额，状态
//			OrderResponse orderResponse = orderMapper.selectById(outboundVO.getFromId());
//			Order orderUpdate = new Order();
//			orderUpdate.setOutingQty(orderResponse.getOutingQty().add(new BigDecimal(sumOutingQty)))
//					.setOutingAmt(orderResponse.getOutingAmt().add(new BigDecimal(sumOutingAmt)))
//					.setOutStatus(Constant.OutStatus.CHUKUZHONG.getName())
//					.setOrderId(outboundVO.getFromId());
//			orderService.updateByUuid(orderUpdate);
        }
        return ResponseResultUtil.success();
    }

}