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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.dto.OrderInfoDto;
import com.zy.asrs.wms.asrs.entity.enums.OrderSettleType;
import com.zy.asrs.wms.asrs.entity.enums.OrderType;
import com.zy.asrs.wms.asrs.entity.param.CreateOrderParam;
import com.zy.asrs.wms.asrs.entity.param.UpdateOrderParam;
import com.zy.asrs.wms.asrs.mapper.OrderMapper;
import com.zy.asrs.wms.asrs.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zy.asrs.wms.utils.OrderUtils;
import com.zy.asrs.wms.utils.Utils;
import io.netty.util.internal.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.*;

@Service("orderService")
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

    @Autowired
    private MatService matService;
    @Autowired
    private MatFieldService matFieldService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private OrderDetlFieldService orderDetlFieldService;
    @Autowired
    private OrderNoRuleService orderNoRuleService;
    @Autowired
    private OrderUtils orderUtils;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private LocDetlService locDetlService;

    @Override
    @Transactional
    public boolean createOrder(List<CreateOrderParam> list, Long userId) {
        for (CreateOrderParam orderParam : list) {
            createOrder(orderParam, userId);
        }
        return true;
    }

    @Override
    @Transactional
    public boolean createOrder(CreateOrderParam param, Long userId) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        List<Order> orderList = this.list(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, param.getOrderNo()));
        if (!orderList.isEmpty()) {
            throw new CoolException("订单已存在");
        }

        String orderNo = param.getOrderNo();
        if (Cools.isEmpty(param.getOrderNo())) {
            orderNo = orderNoRuleService.getOrderNo(param.getOrderType().intValue());
        }

        Order order = new Order();
        order.setOrderNo(orderNo);
        order.setOrderType(param.getOrderType());
        order.setCustomer(param.getCustomer());
        order.setPhone(param.getPhone());
        order.setAddress(param.getAddress());
        order.setOrderSettle(OrderSettleType.INIT.val());
        order.setIoPri(orderUtils.getIoPri());
        order.setOrderTime(format.format(new Date()));
        order.setCreateTime(new Date());
        order.setCreateBy(userId);
        order.setUpdateBy(userId);
        boolean result = this.save(order);
        if (!result) {
            throw new CoolException("生成订单失败");
        }

        for (HashMap<String, Object> map : param.getList()) {
            Double anfme = Double.parseDouble(map.get("anfme").toString());
            String batch = map.get("batch").toString();
            String matnr = map.get("matnr").toString();
            Double qty = 0D;
            Double workQty = 0D;
            if (map.containsKey("qty")) {
                qty = Double.parseDouble(map.get("qty").toString());
            }
            if (map.containsKey("workQty")) {
                workQty = Double.parseDouble(map.get("workQty").toString());
            }

            if (param.getOrderType() == 2) {
                List<LocDetl> detls = locDetlService.list(new LambdaQueryWrapper<LocDetl>()
                        .eq(StringUtils.isNotBlank(batch), LocDetl::getBatch, batch)
                        .eq(StringUtils.isNotBlank(matnr), LocDetl::getMatnr, matnr));
                if (detls.isEmpty()) {
                    throw new CoolException("物料：" + matnr + "剩余库存余下：0" +  "，无法生成出库单!!");
                }
                Double sum = detls.stream().mapToDouble(LocDetl::getAnfme).sum();
                if (anfme.compareTo(sum) > 0) {
                    throw new CoolException("物料：" + matnr + "剩余库存余下：" + sum + "，无法生成出库单!!");
                }
            }

            String memo = map.getOrDefault("memo", "").toString();
            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, matnr));
            if (mat == null) {
                throw new CoolException(matnr + "物料不存在");
            }

            OrderDetl orderDetl = new OrderDetl();
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setAnfme(anfme);
            orderDetl.setQty(qty);
            orderDetl.setWorkQty(workQty);
            orderDetl.setBatch(batch);
            orderDetl.setMatId(mat.getId());
            orderDetl.setMemo(memo);
            orderDetl.setCreateTime(new Date());
            orderDetl.setCreateBy(userId);
            orderDetl.setUpdateBy(userId);
            boolean save = orderDetlService.save(orderDetl);
            if (!save) {
                throw new CoolException("订单明细创建失败");
            }

            //获取扩展字段
            List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getFieldType, 1));
            for (MatField matField : matFields) {
                if (map.containsKey(matField.getName())) {
                    OrderDetlField fieldValue = new OrderDetlField();
                    fieldValue.setDetlId(orderDetl.getId());
                    fieldValue.setFieldId(matField.getId());
                    fieldValue.setName(matField.getName());
                    fieldValue.setValue(map.get(matField.getName()).toString());
                    boolean save1 = orderDetlFieldService.save(fieldValue);
                    if (!save1) {
                        throw new CoolException("订单明细扩展字段创建失败");
                    }
                }
            }

            orderDetl.setStockIndex(Utils.getMatUniqueKey(matnr, batch, orderDetl.getUniqueField()));
            if (!orderDetlService.updateById(orderDetl)) {
                throw new CoolException("更新明细索引失败");
            }

            mat.setUtiliz(Objects.isNull(mat.getUtiliz()) ? 0 : mat.getUtiliz() + 1);

            if (!matService.updateById(mat)) {
                throw new CoolException("物料使用率修改失败！！");
            }
        }

        return true;
    }

    @Override
    public boolean updateOrder(UpdateOrderParam param) {
        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getId, param.getOrderId()));
        if (order == null) {
            throw new CoolException("订单不存在");
        }

        if (order.getHasWave() == 1) {
            throw new CoolException("订单已经生成波次，无法修改");
        }

        order.setOrderType(param.getOrderType());
        order.setOrderSettle(param.getOrderSettle());
        order.setUpdateTime(new Date());
        order.setUpdateBy(9527L);
        boolean result = this.updateById(order);
        if (!result) {
            throw new CoolException("修改订单失败");
        }

        for (HashMap<String, Object> map : param.getList()) {
            double anfme = Double.parseDouble(map.get("anfme").toString());
            String batch = map.get("batch").toString();
            String matnr = map.get("matnr").toString();
            Double qty = Double.parseDouble(map.get("qty").toString());
            Double workQty = Double.parseDouble(map.get("workQty").toString());
            String memo = map.getOrDefault("memo", "").toString();
            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, matnr));
            if (mat == null) {
                throw new CoolException(matnr + "物料不存在");
            }

            OrderDetl orderDetl = null;
            if (map.containsKey("detlId")) {
                orderDetl = orderDetlService.getById(map.get("detlId").toString());
            }

            if(orderDetl == null) {
                orderDetl = new OrderDetl();
                orderDetl.setOrderId(order.getId());
                orderDetl.setOrderNo(order.getOrderNo());
                orderDetl.setAnfme(anfme);
                orderDetl.setQty(0D);
                orderDetl.setWorkQty(0D);
                orderDetl.setBatch(batch);
                orderDetl.setMatId(mat.getId());
                orderDetl.setMemo(memo);
                orderDetl.setCreateTime(new Date());
                orderDetl.setCreateBy(9527L);
            }else {
                orderDetl.setOrderNo(order.getOrderNo());
                orderDetl.setAnfme(anfme);
                orderDetl.setQty(qty);
                orderDetl.setWorkQty(workQty);
                orderDetl.setBatch(batch);
                orderDetl.setMemo(memo);
                orderDetl.setUpdateTime(new Date());
                orderDetl.setUpdateBy(9527L);
            }
            boolean save = orderDetlService.saveOrUpdate(orderDetl);
            if (!save) {
                throw new CoolException("订单明细修改失败");
            }

            //获取扩展字段
            List<MatField> matFields = matFieldService.list(new LambdaQueryWrapper<MatField>().eq(MatField::getFieldType, 1));
            for (MatField matField : matFields) {
                if (map.containsKey(matField.getName())) {
                    OrderDetlField fieldValue = orderDetlFieldService.getOne(new LambdaQueryWrapper<OrderDetlField>()
                            .eq(OrderDetlField::getDetlId, orderDetl.getId())
                            .eq(OrderDetlField::getFieldId, matField.getId()));
                    if (fieldValue == null) {
                        fieldValue = new OrderDetlField();
                        fieldValue.setDetlId(orderDetl.getId());
                        fieldValue.setFieldId(matField.getId());
                        fieldValue.setName(matField.getName());
                        fieldValue.setValue(map.get(matField.getName()).toString());
                    }else {
                        fieldValue.setValue(map.get(matField.getName()).toString());
                    }

                    boolean save1 = orderDetlFieldService.saveOrUpdate(fieldValue);
                    if (!save1) {
                        throw new CoolException("订单明细扩展字段修改失败");
                    }
                }
            }

            orderDetl.setStockIndex(Utils.getMatUniqueKey(matnr, batch, orderDetl.getUniqueField()));
            if (!orderDetlService.updateById(orderDetl)) {
                throw new CoolException("更新明细索引失败");
            }

        }

        List<Long> deleteDetlId = param.getDeleteDetlId();
        if (!deleteDetlId.isEmpty()) {
            for (Long detlId : deleteDetlId) {
                //删除明细
                orderDetlService.removeById(detlId);
                //删除明细对应的扩展字段
                orderDetlFieldService.remove(new LambdaQueryWrapper<OrderDetlField>().eq(OrderDetlField::getDetlId, detlId));
            }
        }

        return true;
    }

    @Override
    public boolean deleteOrder(Long orderId) {
        Order order = this.getById(orderId);
        if (order.getHasWave() == 1) {
            throw new CoolException("订单已经生成波次，删除失败");
        }

        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getOrderId, orderId));
        if (!waitPakins.isEmpty()) {
            throw new CoolException("单据已生成组托，不可执行删除操作！！");
        }
        //删除订单
        this.removeById(orderId);
        //删除明细
        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, orderId));
        for (OrderDetl orderDetl : orderDetls) {
            orderDetlService.removeById(orderDetl.getId());//删除明细
            //删除明细对应的扩展字段
            orderDetlFieldService.remove(new LambdaQueryWrapper<OrderDetlField>().eq(OrderDetlField::getDetlId, orderDetl.getId()));
        }
        return true;
    }

    @Override
    public boolean checkOrderComplete(Long orderId) {
        Order order = this.getById(orderId);
        if (order == null) {
            return false;
        }

        boolean complete = true;
        List<OrderDetl> orderDetls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, orderId));
        if(orderDetls.isEmpty()) {
            complete = false;
        }

        for (OrderDetl orderDetl : orderDetls) {
            if (!orderDetl.getAnfme().equals(orderDetl.getQty())) {
                complete = false;
            }
        }

        return complete;
    }

    @Override
    public Order selectByBarcode(String barcode) {
        return this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, barcode), false);
    }

    @Override
    public List<OrderInfoDto> getDetlForOrderId(Long id, String matnr) {
        if (!Objects.isNull(matnr)) {
            if (Objects.isNull(matnr)) {
                return this.baseMapper.getDetlForOrderId(id, null);
            } else {
                return this.baseMapper.getDetlForOrderId(id, matnr);
            }
        } else {
            return this.baseMapper.getDetlForOrderId(id, null);
        }
    }

    /**
     * 提交完结订单
     * @param id
     * @return
     */
    @Override
    public Order doneOrder(Long id) {
        return null;
    }
}