package com.matrix.system.shopXcx.mqTask;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.matrix.biz.bean.BizUser;
import com.matrix.biz.service.BizUserService;
import com.matrix.core.constance.MatrixConstance;
import com.matrix.core.tools.LogUtil;
import com.matrix.core.tools.StringUtils;
import com.matrix.system.common.dao.BusParameterSettingsDao;
import com.matrix.system.fenxiao.dao.ShopSalesmanGradeDao;
import com.matrix.system.fenxiao.dao.ShopSalesmanOrderDao;
import com.matrix.system.fenxiao.entity.ShopSalesmanGrade;
import com.matrix.system.fenxiao.entity.ShopSalesmanOrder;
import com.matrix.system.hive.dao.SysOrderDao;
import com.matrix.system.hive.dao.SysOrderItemDao;
import com.matrix.system.hive.dao.SysVipInfoDao;
import com.matrix.system.hive.service.CodeService;
import com.matrix.system.hive.service.ShoppingGoodsService;
import com.matrix.system.hive.service.SysOrderService;
import com.matrix.system.shopXcx.bean.ShopOrder;
import com.matrix.system.shopXcx.bean.ShopOrderDetails;
import com.matrix.system.shopXcx.dao.ShopOrderDao;
import com.matrix.system.shopXcx.dao.ShopOrderDetailsDao;
import com.matrix.system.shopXcx.dao.ShopSkuDao;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.util.Date;
import java.util.List;

/**
 * 分销订单创建
 */
@Component
public class SalesOrderTask implements DeliverCallback {


    @Autowired
    ShopOrderDao shopOrderDao;
    @Autowired
    ShopOrderDetailsDao shopOrderDetailsDao;

    @Autowired
    BizUserService bizUserService;


    @Autowired
    private SysVipInfoDao vipDap;

    @Autowired
    SysVipInfoDao vipDao;

    @Autowired
    CodeService codeService;

    @Autowired
    SysOrderDao sysOrderDao;

    @Autowired
    ShoppingGoodsService shoppingGoodsService;

    @Autowired
    SysOrderItemDao orderItemDao;

    @Autowired
    SysOrderService orderService;

    @Autowired
    ShopSkuDao shopSkuDao;

    @Autowired
    BusParameterSettingsDao parameterSettingsDao;


    @Autowired
    private ShopSalesmanOrderDao shopSalesmanOrderDao;

    @Autowired
    private ShopSalesmanGradeDao shopSalesmanGradeDao;



    @Override
    public void handle(String consumerTag, Delivery message) throws IOException {

        String orderId = new String(message.getBody(), "UTF-8");
        LogUtil.debug("收到分销订单任务orderId={}", orderId);
        //获取订单信息
        ShopOrder order = shopOrderDao.selectById(Integer.valueOf(orderId));
        //获取订单详情
        List<ShopOrderDetails> orderDetails = shopOrderDetailsDao.selectByOrderId(Integer.valueOf(orderId));
        order.setDetails(orderDetails);
        //处理分销订单
        handleExtensionOrder(order);

    }

    /**
     * 处理分销订单
     * @param order
     */
    @Transactional
    void handleExtensionOrder(ShopOrder order) {
        //判读客户是否存在上级，存在则产生上级的收益
        BizUser bizUser = bizUserService.findByOpenId(order.getUserId());
        if(StringUtils.isNotBlank(bizUser.getParentOpenId())){//存在上级

            LogUtil.debug("处理分销订单userOpid={}",bizUser.getOpenId());
            //判断是否重复生成
            QueryWrapper queryWrapper=new QueryWrapper();
            queryWrapper.eq("order_id",order.getId());
            Integer orderCount = shopSalesmanOrderDao.selectCount(queryWrapper);
            if(orderCount==0){
                ShopSalesmanOrder salesmanOrder=new ShopSalesmanOrder();
                salesmanOrder.setCompanyId(order.getCompanyId());
                salesmanOrder.setCreateBy(MatrixConstance.SYSTEM_USER);
                salesmanOrder.setUpdateBy(MatrixConstance.SYSTEM_USER);
                salesmanOrder.setCreateTime(new Date());
                salesmanOrder.setUpdateTime(new Date());
                salesmanOrder.setOrderId(Long.parseLong(order.getId()+""));
                salesmanOrder.setUserId(order.getUserId());
                salesmanOrder.setSalesUserId(bizUser.getParentOpenId());
                salesmanOrder.setRevenueType(ShopSalesmanOrder.REVENUE_TYPE_SALES);
                salesmanOrder.setOrderStatus(ShopSalesmanOrder.STATUS_DJS);
                Double salesAmount=0D;
                Double invitationAmount=0D;
                Double orderTotal=0D;
                Double zk=1D;

                BizUser salesMan=bizUserService.findByOpenId(bizUser.getParentOpenId());
                BizUser invitationMan=null;
                ShopSalesmanOrder invitationOrder=null;
                boolean hasInvitationMan=StringUtils.isNotBlank(salesMan.getParentOpenId());

                //判断推广员是否还存在上级,存在则计算邀请收益
                if(hasInvitationMan){
                    invitationMan=bizUserService.findByOpenId(salesMan.getParentOpenId());
                    invitationOrder=new ShopSalesmanOrder();
                    BeanUtils.copyProperties(salesmanOrder,invitationOrder);
                    invitationOrder.setSalesUserId(invitationMan.getOpenId());
                    invitationOrder.setRevenueType(ShopSalesmanOrder.REVENUE_TYPE_INVITATION);
                }

                //收益计算
                for (ShopOrderDetails item:order.getDetails() ){
                    if(StringUtils.isNotBlank(item.getShopProduct().getAttrValues())
                            && item.getShopProduct().getAttrValues().contains("分销商城")){
                        if(item.getShopSku().getSealesPrice()==null
                                ||item.getShopSku().getSealesPrice().doubleValue()==0){
                            //按分销等级计算
                            ShopSalesmanGrade shopSalesmanGrade = shopSalesmanGradeDao.selectById(salesMan.getSalesmanGrade());
                            salesAmount+=item.getTotalPrice().doubleValue()*(shopSalesmanGrade.getSealesCommission()/100);

                            if(hasInvitationMan){
                                ShopSalesmanGrade invitationManGrade = shopSalesmanGradeDao.selectById(invitationMan.getSalesmanGrade());
                                invitationAmount+=item.getTotalPrice().doubleValue()*(invitationManGrade.getInvitationCommission()/100);
                            }

                        }else{
                            //按产品设置的推广金额计算
                            salesAmount+=item.getShopSku().getSealesPrice().doubleValue()*item.getCount();
                            if(hasInvitationMan){
                                invitationAmount+=item.getShopSku().getInvitationPrice().doubleValue()*item.getCount();
                            }
                        }
                        orderTotal+=item.getTotalPrice().doubleValue();
                    }
                }
                if(salesAmount>0){
                    //整体的优惠金额折算成折扣，* 佣金
                    zk=order.getOrderMoney().doubleValue()/orderTotal;
                    salesAmount=salesAmount*zk;
                    salesmanOrder.setAmount(salesAmount);
                    shopSalesmanOrderDao.insert(salesmanOrder);
                    if(hasInvitationMan){
                        invitationAmount=invitationAmount*zk;
                        invitationOrder.setAmount(invitationAmount);
                        shopSalesmanOrderDao.insert(invitationOrder);
                    }
                }
            }else{
                LogUtil.debug("重复订单id={}",order.getId());
            }
        }else{
            LogUtil.debug("不存在父级userOpid={}",bizUser.getOpenId());
        }


    }
}