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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.*;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

@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;

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

        Order order = new Order();
        order.setOrderNo(param.getOrderNo());
        order.setOrderType(param.getOrderType());
        order.setOrderSettle(param.getOrderSettle());
        order.setOrderTime(format.format(new Date()));
        order.setCreateTime(new Date());
        order.setCreateBy(9527L);
        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 = 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 = 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(9527L);
            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("订单明细扩展字段创建失败");
                    }
                }
            }

        }

        return true;
    }

    @Override
    public boolean updateOrder(UpdateOrderParam param) {
        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getId, param.getOrderId()));
        order.setOrderNo(param.getOrderNo());
        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("订单明细扩展字段修改失败");
                    }
                }
            }

        }

        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) {
        //删除订单
        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;
    }
}