package com.kmall.admin.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.kmall.admin.dao.*;
import com.kmall.admin.entity.*;
import com.kmall.admin.service.OrderService;
import com.kmall.api.contants.Dict;
import com.kmall.api.entity.MallOrderRefund;
import com.kmall.common.utils.DateUtils;
import com.kmall.common.utils.RRException;
import com.kmall.common.utils.ShiroUtils;
import com.kmall.common.utils.StringUtils;
import com.kmall.common.utils.express.kdn.KdniaoUtil;
import com.kmall.common.utils.printer.FeiGeUtils;
import com.kmall.common.utils.wechat.WechatRefundApiResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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


@Service("orderService")
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderDao orderDao;
    @Autowired
    private ShippingDao shippingDao;
    @Autowired
    private OrderGoodsDao orderGoodsDao;
    @Autowired
    private SysPrinterDao printerDao;
    @Autowired
    private UserDao userDao;
    @Autowired
    private OrderRefundDao orderRefundDao;
    @Autowired
    private UserCouponDao userCouponDao;
    @Autowired
    private ProductStoreRelaDao productStoreRelaDao;
    @Autowired
    private OrderProcessRecordDao orderProcessRecordDao;

    @Autowired
    private MallOrderRefundDao mallOrderRefundDao;


    @Override
    public OrderEntity queryObject(Long id) {
        return orderDao.queryObject(id);
    }

    @Override
    public List<OrderEntity> queryList(Map<String, Object> map) {
        return orderDao.queryList(map);
    }

    @Override
    public int queryTotal(Map<String, Object> map) {
        return orderDao.queryTotal(map);
    }

    @Override
    public int save(OrderEntity order) {
        return orderDao.save(order);
    }

    @Override
    public int update(OrderEntity order) {
        return orderDao.update(order);
    }


    @Override
    public void cancelOrder(OrderEntity order,WechatRefundApiResult result) {
        boolean needUpdateStock = true;
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
        }
        order.setPayStatus(Integer.parseInt(Dict.payStatus.item_4.getItem()));

        // 判断是否有优惠券
        UserCouponEntity couponVo = userCouponDao.queryByOrderId(order.getId());
        if (null != couponVo) {
            userCouponDao.cancelOrder(couponVo);
        }
        orderDao.update(order);

        MallOrderRefundEntity mallOrderRefund = mallOrderRefundDao.queryObjectByOrderId(order.getId()+"");

        MallOrderRefundEntity orderRefund = new MallOrderRefundEntity();
        orderRefund.setRefundId(result.getRefund_id());
        orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
        orderRefund.setOutRefundNo(result.getOut_refund_no());
        orderRefund.setRefundMoney(BigDecimal.valueOf(Long.valueOf(result.getRefund_fee())));
        orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_2.getItem()));
        orderRefund.setModTime(new Date());

        if(mallOrderRefund !=null){
            orderRefund.setId(mallOrderRefund.getId());
            mallOrderRefundDao.update(orderRefund);
        }else{
            orderRefund.setOrderId(Integer.parseInt(order.getId()+""));
            orderRefund.setUserId(Integer.parseInt(order.getUserId()+""));
            orderRefund.setCreateTime(new Date());
            mallOrderRefundDao.save(orderRefund);//退款记录
        }

        if (!needUpdateStock) {
            return;
        }
        // 更新库存
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("orderId", order.getId());
        List<OrderGoodsEntity> orderGoodsVoList = orderGoodsDao.queryList(map);
        for (OrderGoodsEntity orderGoodsEntity : orderGoodsVoList) {
            ProductStoreRelaEntity storeRelaEntity = productStoreRelaDao.queryByStoreIdProductId(Long.valueOf(order.getStoreId()), Long.valueOf(orderGoodsEntity.getProductId()));
            if (null == storeRelaEntity || null == storeRelaEntity.getSellVolume()) {
                storeRelaEntity.setSellVolume(new BigDecimal(0));
            }
            BigDecimal sellVolume = storeRelaEntity.getSellVolume().subtract(new BigDecimal(orderGoodsEntity.getNumber()));//销售量
            if (sellVolume.compareTo(new BigDecimal(0)) < 0) {
                sellVolume = new BigDecimal(0);
            }
            storeRelaEntity.setSellVolume(sellVolume);
            if (null == storeRelaEntity.getStockNum()) {
                storeRelaEntity.setStockNum(0);
            }
            storeRelaEntity.setStockNum(storeRelaEntity.getStockNum() + orderGoodsEntity.getNumber());//库存数量
            productStoreRelaDao.update(storeRelaEntity);
        }
    }

    @Override
    public int delete(Long id) {
        return orderDao.delete(id);
    }

    @Override
    public int deleteBatch(Long[] ids) {
        return orderDao.deleteBatch(ids);
    }

    @Override
    public int confirm(Long id) {
        OrderEntity orderEntity = queryObject(id);
        Integer shippingStatus = orderEntity.getShippingStatus();//发货状态
        Integer payStatus = orderEntity.getPayStatus();//付款状态
        if (2 != payStatus) {
            throw new RRException("此订单未付款，不能确认收货！");
        }
        if (4 == shippingStatus) {
            throw new RRException("此订单处于退货状态，不能确认收货！");
        }
        if (0 == shippingStatus) {
            throw new RRException("此订单未发货，不能确认收货！");
        }
        orderEntity.setShippingStatus(2);
        orderEntity.setOrderStatus(301);
        orderEntity.setConfirmTime(new Date());
        orderDao.update(orderEntity);
        return 0;
    }

    @Override
    public int sendGoods(OrderEntity order) {
        Integer payStatus = order.getPayStatus();//付款状态
        if (2 != payStatus) {
            throw new RRException("此订单未付款！");
        }

        ShippingEntity shippingEntity = shippingDao.queryObject(order.getShippingId());
        if (null != shippingEntity) {
            order.setShippingName(shippingEntity.getName());
        }
        order.setOrderStatus(300);//订单已发货
        order.setShippingStatus(1);//已发货
        return orderDao.update(order);
    }

    @Override
    public String printMsg(Long id) {
        OrderEntity orderEntity = queryObject(id);
        Map<String, Object> map = new HashMap<String, Object>();

        map.put("orderId", orderEntity.getId());
        List<OrderGoodsEntity> orderGoodsEntities = orderGoodsDao.queryList(map);

        String content = "<CB>小程序商城</CB><BR>";
        content += "名称/商品编码       单价   数量   金额<BR>";
        for (OrderGoodsEntity orderGoodsEntity : orderGoodsEntities) {
            content += "--------------------------------<BR>";
            content += orderGoodsEntity.getGoodsName() + "<BR>" + orderGoodsEntity.getGoodsSn() + "             " + orderGoodsEntity.getRetailPrice() + "    " + orderGoodsEntity.getNumber()
                    + "   " + orderGoodsEntity.getRetailPrice().multiply(new BigDecimal(orderGoodsEntity.getNumber())) + "<BR>";
        }
        content += "--------------------------------<BR>";
        content += "备注：" + orderEntity.getPostscript() + "<BR>";
        content += "--------------------------------<BR>";
        content += "订单编号：" + orderEntity.getOrderSn() + "<BR>";
        content += "配送配用：" + orderEntity.getFreightPrice() + "元<BR>";
        content += "优惠价格：" + orderEntity.getCouponPrice() + "元<BR>";
        content += "合计：" + orderEntity.getOrderPrice() + "元<BR>";
        content += "实付：" + orderEntity.getActualPrice() + "元<BR>";
        content += "姓名：" + orderEntity.getUserName() + "<BR>";
        content += "送货地点：" + orderEntity.getProvince() + orderEntity.getCity() + orderEntity.getDistrict() + orderEntity.getAddress() + "<BR>";
        content += "联系电话：" + orderEntity.getMobile() + "<BR>";
        content += "付款时间：" + DateUtils.format(orderEntity.getPayTime(), DateUtils.DATE_TIME_PATTERN) + "<BR>";
        content += "<QR>https://www.二维码.com</QR>";
        if ("2".equals(orderEntity.getOrderType())) {
            content += "<RIGHT><BOLD>【团购】</BOLD></RIGHT>";
        }

        //所属门店
        Integer storeId = orderEntity.getStoreId();

        //获取门店的打印机编号，每个门店只有一个打票机
        Map<String, Object> printParams = new HashMap<String, Object>();
        List<SysPrinterEntity> printerEntities = printerDao.queryList(printParams);
        printParams.put("storeId", storeId);
        String sn = "";
        if (printerEntities != null && printerEntities.size() != 0) {
            sn = printerEntities.get(0).getSn();
        }
        return FeiGeUtils.printMsg(sn, content, "1");
    }

    /**
     * 部分退款
     *
     * @param orderInfo
     * @param refundMoney
     */
    @Transactional
    public void refund(OrderEntity orderInfo, BigDecimal refundMoney) {
        if (orderInfo.getOrderStatus() == 201) {
            orderInfo.setOrderStatus(401);
        } else if (orderInfo.getOrderStatus() == 300) {
            orderInfo.setOrderStatus(402);
        }
        // 退款记录
        OrderRefundEntity orderRefundEntity = new OrderRefundEntity();
        orderRefundEntity.setOrderId(orderInfo.getId());
        orderRefundEntity.setRefundTime(new Date());
        orderRefundEntity.setUserId(Long.valueOf(orderInfo.getUserId()));
        orderRefundEntity.setRefundType(2);
        orderRefundEntity.setRefundStatus(2);
        orderRefundEntity.setApprovalTime(new Date());
        orderRefundEntity.setApprover(ShiroUtils.getUserId() + "");
        orderRefundEntity.setCreator(ShiroUtils.getUserId() + "");
        orderRefundEntity.setRefundMoney(refundMoney);
        orderRefundDao.save(orderRefundEntity);
        orderDao.update(orderInfo);
    }

    /**
     * 处理用户退款申请
     *
     * @param orderInfo
     */
    @Transactional
    public void applyRefundDeal(OrderEntity orderInfo, OrderRefundEntity refundEntity) {
        refundEntity.setApprovalTime(new Date());
//        refundEntity.setApprover(ShiroUtils.getUserId());
        //  退积分
        try {
            Integer integral = 1;
            if (orderInfo.getActualPrice().intValue() > 0) {
                integral = orderInfo.getActualPrice().intValue();
            }
            if (refundEntity.getRefundStatus() == 2) {
                orderInfo.setOrderStatus(401);
                UserEntity entity = userDao.queryObject(orderInfo.getUserId());
            } else {
                orderInfo.setOrderStatus(201);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        orderRefundDao.update(refundEntity);
        orderDao.update(orderInfo);
    }

    @Override
    public OrderRefundEntity queryRefundObject(Long refundId) {
        return orderRefundDao.queryObject(refundId);
    }

    @Override
    public List<OrderRefundEntity> queryRefundList(Map<String, Object> map) {
        return orderRefundDao.queryList(map);
    }

    @Override
    public int queryRefundTotal(Map<String, Object> map) {
        return orderRefundDao.queryTotal(map);
    }

    @Override
    public int getUserOrderInfo(Map<String, Object> params) {
        int result = 0;
        String type = (String) params.get("type");
        if ("yfkOrderUserSum".equals(type)) {
            result = orderDao.getYfkOrderUserSum();
        } else if ("oderUserSum".equals(type)) {
            result = orderDao.getOderUserSum();
        } else if ("todayUserOrder".equals(type)) {
            result = orderDao.getTodayUserOrder();
        } else if ("todayUserSales".equals(type)) {
            result = orderDao.getTodayUserSales();
        } else if("incomeSum".equals(type)){
            result = orderDao.getIncomeSum();
        } else if("payedOrderCount".equals(type)){
            result = orderDao.getPayedOrderCount();
        }
        return result;
    }

    @Override
    public Map getLogistics(Long id) {
        OrderEntity orderEntity = queryObject(id);
        if (orderEntity == null) {
            throw new RRException("此订单不存在！");
        } else if (orderEntity.getShippingStatus() == 0 || StringUtils.isNullOrEmpty(orderEntity.getShippingNo())) {
            throw new RRException("此订单还未发货！");
        }

        Map logisticsInfo = new HashMap();
        List<WuliuEntity> wuliuEntityList = new ArrayList<>();
        if (StringUtils.isNotEmpty(orderEntity.getShippingCode())
                && StringUtils.isNotEmpty(orderEntity.getShippingNo())) {
            JSONObject traces = KdniaoUtil.getOrderTracesByJson(orderEntity.getShippingCode(), orderEntity.getShippingNo());
            List<Map> mapList = (List<Map>) traces.get("Traces");
            for (Map map : mapList) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptTime(map.get("AcceptTime").toString());
                wuliuEntity.setAcceptStation(map.get("AcceptStation").toString());
                wuliuEntityList.add(wuliuEntity);
            }

            String state = traces.get("State").toString();
            if (Dict.logisticsStatus.item_0.getItem().equals(state) && traces.getBoolean("Success")) {
                String reason = traces.get("Reason").toString();
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation(reason);
                wuliuEntityList.add(wuliuEntity);
            }
        }

        OrderProcessRecordEntity orderProcessRecordEntity = orderProcessRecordDao.queryObjectByOrderSn(orderEntity.getOrderSn());
        if (orderProcessRecordEntity != null) {
            if (Dict.isSend.item_1.getItem().equals(orderProcessRecordEntity.getIsCustomsSend())) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单清关完成，等待仓库发货");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(orderProcessRecordEntity.getCustomsSuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }
            if(Dict.isSend.item_1.getItem().equals(orderProcessRecordEntity.getIsPaymentSend())){
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单支付成功，等待海关清关");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(orderProcessRecordEntity.getPaySuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }
            if(Dict.isSend.item_1.getItem().equalsIgnoreCase(orderProcessRecordEntity.getIsAddOrderSend())){
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单提交成功");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(orderProcessRecordEntity.getAddOrderSuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }
        }
        logisticsInfo.put("tracesList", wuliuEntityList);
        logisticsInfo.put("logisticCode", orderEntity.getShippingNo());
        logisticsInfo.put("shipperCode", orderEntity.getShippingCode());
        return logisticsInfo;
    }
}