package com.example.erp.service.sd;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.example.erp.common.Constants;
import com.example.erp.entity.sd.*;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.exception.ServiceException;
import com.example.erp.mapper.sd.*;
import com.example.erp.service.userInfo.SysErrorService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

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

@Service
@DS("sd")
@Transactional(rollbackFor = Exception.class)
public class OrderService {
    private final OrderMapper orderMapper;
    private final OrderDetailMapper orderDetailMapper;
    private final OrderGlassDetailMapper orderGlassDetailMapper;
    private final SysErrorService sysErrorService;
    private final OrderOtherMoneyMapper orderOtherMoneyMapper;

    private final OrderProcessDetailMapper orderProcessDetailMapper;
    public OrderService(OrderMapper orderMapper, OrderDetailMapper orderDetailMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, SysErrorService sysErrorService, OrderOtherMoneyMapper orderOtherMoneyMapper) {
        this.orderMapper = orderMapper;
        this.orderDetailMapper = orderDetailMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
        this.orderProcessDetailMapper = orderProcessDetailMapper;
        this.sysErrorService = sysErrorService;
        this.orderOtherMoneyMapper = orderOtherMoneyMapper;
    }

    public boolean saveOrder(Map<String,Object> orderMap) throws Exception {
        JSONObject orderJson = new JSONObject(orderMap);
        Order order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("title")), Order.class);
        List<OrderDetail> OrderDetails = JSONArray.parseArray(JSONObject.toJSONString(orderJson.get("detail")), OrderDetail.class);
        List<OrderOtherMoney> orderOtherMoneyList = JSONArray.parseArray(JSONObject.toJSONString(orderJson.get("otherMoney")), OrderOtherMoney.class);
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        //判断传入id参数是否为空，未传入id为空插入订单表，传入更新表
        try{
            if(order.getOrderId() == null || order.getOrderId().isEmpty()){
                insertOrder(order,OrderDetails,orderOtherMoneyList);
            }else {
                updateOrder(order,OrderDetails,orderOtherMoneyList);
            }
        }catch (Exception e){
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

            //throw new Exception();
        }
        return saveState;
    }
    //生成订单数据
    public void insertOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
        Integer maxOrderId = orderMapper.selectMaxOrderId();
        //查询订单id，并且自增
        String formattedNumber = String.format("%02d", maxOrderId+1);
        //格式化当前日期
        Date currentDate = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
        String formattedDate = dateFormat.format(currentDate);
        String orderId =  "NG"+formattedDate+formattedNumber;
        //往主表插数据
        order.setOrderId(orderId);
        order.setCreateOrder(2);
        orderMapper.insert(order);
        insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);

    }
    //修改订单数据，并且重新生成多个副表数据
    public void updateOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
        LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(Order::getOrderId, order.getOrderId());
        orderMapper.update(order,updateWrapper);
        //删除订单明细表
        orderDetailMapper.delete(new LambdaQueryWrapper<OrderDetail>().eq(OrderDetail::getOrderId, order.getOrderId()));
        //删除订单小片表
        orderGlassDetailMapper.delete(new LambdaQueryWrapper<OrderGlassDetail>().eq(OrderGlassDetail::getOrderId, order.getOrderId()));
        //删除其他金额明细表
        orderOtherMoneyMapper.delete(new LambdaQueryWrapper<OrderOtherMoney>().eq(OrderOtherMoney::getOrderId, order.getOrderId()));

        //删除订单工艺表
       // orderProcessDetailMapper.delete(new LambdaQueryWrapper<OrderProcessDetail>().eq(OrderProcessDetail::getOrderId, order.getOrderId()));
        insertOtherDetail(order.getOrderId(),OrderDetails,orderOtherMoneyList);
    }


    //插入其他副表数据，被其他方法引用
    public void insertOtherDetail(String orderId,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
        //循环给订单明细表字段添加序号和周长
        for (int i = 0; i < OrderDetails.size(); i++) {
            OrderDetails.get(i).setOrderNumber(i+1);
            OrderDetails.get(i).setOrderId(orderId);
            OrderDetails.get(i).setPerimeter(OrderDetails.get(i).getWidth()*OrderDetails.get(i).getHeight()*2/1000);
            OrderDetails.get(i).setWeight(1.0);
            Map<String,Double> otherColumns = JSON.parseObject(OrderDetails.get(i).getOtherColumns(), new TypeReference<Map<String, Double>>(){});
            int finalI = i;
            if(otherColumns!=null){
                otherColumns.forEach((key, value) ->{
                    orderOtherMoneyList.forEach(orderOtherMoney ->{
                        if(orderOtherMoney.getColumn().equals(key)){
                            orderOtherMoney.setQuantity (orderOtherMoney.getQuantity()==null?0:orderOtherMoney.getQuantity());
                            orderOtherMoney.setQuantity(((value==null?0:value)*OrderDetails.get(finalI).getQuantity()));
                        }
                    });

                });
            }
        }




        //往明细表插数据
        orderDetailMapper.insertBatch(OrderDetails);
        //往小片表传入产品数据
        orderGlassDetailMapper.insertOrderGlassDetail(orderId);
        //往订单其他金额副表传入数据
        orderOtherMoneyList.forEach(orderOtherMoney ->{
            orderOtherMoney.setId(null);
            orderOtherMoney.setOrderId(orderId);
            if(orderOtherMoney.getQuantity()!=null && orderOtherMoney.getPrice()!=null){
                orderOtherMoney.setMoney((orderOtherMoney.getQuantity()*orderOtherMoney.getPrice()));
            }
            orderOtherMoneyMapper.insert(orderOtherMoney);
        });
        //修改订单主表面积与周长以及重量
        orderMapper.updateOrderParameter(orderId);

        //查询订单小片表获取工艺传入小片工艺表
        //List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetail(orderId);
        /*List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetails);
        //赋值订单工艺表
        orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);*/
    }

    public static List<OrderProcessDetail> getOrderProcessDetails(List<OrderGlassDetail> orderGlassDetails) {
        List<OrderProcessDetail> orderProcessDetailList = new ArrayList<>();
        for (OrderGlassDetail orderGlassDetail : orderGlassDetails) {
            String[] processList = orderGlassDetail.getProcess().split("->");
            for (String process : processList) {
                OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
                orderProcessDetail.setOrderId(orderGlassDetail.getOrderId());
                orderProcessDetail.setOrderNumber(orderGlassDetail.getOrderNumber());
                orderProcessDetail.setTechnologyNumber(orderGlassDetail.getTechnologyNumber());
                orderProcessDetail.setProcess(process);
                orderProcessDetailList.add(orderProcessDetail);
            }
        }
        return orderProcessDetailList;
    }

    //查询获取列表
    public Map<String,Object> getOrderList(Integer pageNum, Integer pageSize, List<String> selectDate, Order order,Integer orderType) {
        Integer offset = (pageNum-1)*pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
            }
            if(!selectDate.get(1).isEmpty()){
                endDate = selectDate.get(1);
            }
        }

        Map<String,Object> map = new HashMap<>();
        map.put("data",orderMapper.getOrderList(offset, pageSize, startDate, endDate, order,orderType));
        map.put("total",orderMapper.getPageTotal(offset, pageSize, startDate, endDate, order,orderType));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }
    //删除订单
    public Integer deleteOrder(String id) {
        return  orderMapper.delete(
                new QueryWrapper<Order>().eq("order_id",id)
        );
    }


    //查询订单主表与副表信息
    public Map<String,Object> getOrderById(String id) {
        Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
        List<OrderDetail> orderDetails = orderDetailMapper.selectList(new QueryWrapper<OrderDetail>().eq("order_id",id));
        List<OrderOtherMoney> orderOtherMoneyList = orderOtherMoneyMapper.findById(id);
        Map<String,Object> map = new HashMap<>();
        map.put("order",order);
        map.put("orderDetails",orderDetails);
        map.put("orderOtherMoneyList",orderOtherMoneyList);
        return map;
    }
    //订单审核
    public boolean reviewOrderById(String id,Integer status) {
        Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
        if(order.getProcessReview()!=2){
            throw  new ServiceException(Constants.Code_600,"该订单还未审核");
        }
        return orderMapper.reviewOrderById(id,status);
    }
    //工艺审核界面审核更新数据
    public boolean reviewProcessById(String id, Integer status,List<OrderGlassDetail> orderGlassDetails) {
        if(!orderGlassDetails.isEmpty() && status==2){
            orderGlassDetails.forEach(orderGlassDetail ->{
                double area = Math.round((orderGlassDetail.getChildWidth()*orderGlassDetail.getChildHeight()/1000000) * 100) * 0.01d;
                orderGlassDetail.setArea(area);
            });

            orderGlassDetailMapper.updateSizeAndProcess(orderGlassDetails);
            orderProcessDetailMapper.delete(new QueryWrapper<OrderProcessDetail>().eq("order_id",id));
            //查询订单小片表获取工艺传入小片工艺表
            //List<OrderGlassDetail> orderGlassDetailList = orderGlassDetailMapper.selectOrderGlassDetail(id);
//            List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetailList);
//            //赋值订单工艺表
//            orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);
        }

        return orderMapper.reviewProcessById(id,status);
    }
    //工艺审核界面数据查询
    public Map<String,Object> getOrderCraftById(String id) {
        Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
        List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetailByOrderId(id);
        Map<String,Object> map = new HashMap<>();
        map.put("order",order);
        map.put("orderGlassDetails",orderGlassDetails);
        return map;
    }

    public boolean updateOrderMoney(Map<String, Object> map) {
        JSONObject jsonObject = new JSONObject(map);
        Order order = JSONObject.parseObject(JSONObject.toJSONString(jsonObject.get("order")), Order.class);
        List<OrderDetail> OrderDetails = JSONArray.parseArray(JSONObject.toJSONString(jsonObject.get("detail")), OrderDetail.class);
        double money = 0;
        for (OrderDetail orderDetail : OrderDetails) {
            orderDetail =  updateOrderMoneyComputed(orderDetail,order.getCalculateType());
            money+= orderDetail.getGrossAmount();
        }
        order.setMoney(money);
        orderMapper.updateMoney(order);
        orderDetailMapper.updateOrderMoney(OrderDetails);
        return false;
    }

    private OrderDetail updateOrderMoneyComputed(OrderDetail orderDetail, Integer calculateType) {
        if (calculateType == 3) {
            orderDetail.setGrossAmount(orderDetail.getPrice() * orderDetail.getQuantity());
        } else {
            orderDetail.setGrossAmount(orderDetail.getComputeGrossArea() * orderDetail.getPrice());
        }
        return orderDetail;
    }


    public Integer cancelOrder(String id) {
        return orderMapper.cancelOrder(id);
    }


    public Map<String,Object> getOrderReport(Integer pageNum, Integer pageSize, List<String> selectDate, OrderDetail orderDetail) {
        Integer offset = (pageNum-1)*pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
            }
            if(!selectDate.get(1).isEmpty()){
                endDate = selectDate.get(1);
            }
        }

        Map<String,Object> map = new HashMap<>();
        map.put("data",orderDetailMapper.getOrderReport(offset, pageSize, startDate, endDate, orderDetail));
        map.put("total",orderDetailMapper.getOrderReportTotal(offset, pageSize, startDate, endDate, orderDetail));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
//        map.put("total",orderMapper.getPageTotal(offset, pageSize, startDate, endDate, orderDetail));
        return map;
    }

    public List<Order> exportOrderReport() {
        return orderDetailMapper.exportOrderReport();
    }
}