package com.matrix.system.shopXcx.api.service.impl;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.matrix.biz.bean.BizUser;
import com.matrix.component.redis.RedisUserLoginUtils;
import com.matrix.component.tools.WxUtils;
import com.matrix.component.wechat.externalInterface.protocol.paramProtocol.BrandWCPayRequestData;
import com.matrix.core.exception.GlobleException;
import com.matrix.core.pojo.AjaxResult;
import com.matrix.core.tools.StringUtils;
import com.matrix.system.common.constance.AppConstance;
import com.matrix.system.constance.Dictionary;
import com.matrix.system.hive.bean.ShoppingGoods;
import com.matrix.system.hive.bean.SysVipInfo;
import com.matrix.system.hive.dao.ShoppingGoodsDao;
import com.matrix.system.hive.dao.SysVipInfoDao;
import com.matrix.system.shopXcx.api.service.WXShopOrderService;
import com.matrix.system.shopXcx.api.service.WxShopActivitiesGroupService;
import com.matrix.system.shopXcx.api.tools.WxShopOrderUtil;
import com.matrix.system.shopXcx.bean.*;
import com.matrix.system.shopXcx.dao.*;
import com.matrix.system.shopXcx.dto.CreateGroupBuyDTO;
import com.matrix.system.shopXcx.dto.DiscountExplain;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * @author wzy
 */
@Service
public class WxShopActivitiesGroupServiceImpl implements WxShopActivitiesGroupService {
    @Autowired
    private WxShopOrderUtil wxShopOrderUtil;

    @Autowired
    private ShopActivitiesGroupInfoDao shopActivitiesGroupInfoDao;

    @Autowired
    private RedisUserLoginUtils redisUserLoginUtils;

    @Autowired
    private ShopActivitiesGroupPriceDao shopActivitiesGroupPriceDao;

    @Autowired
    private ShopActivitiesGroupJoinDao shopActivitiesGroupJoinDao;

    @Autowired
    private ShopActivitiesGroupJoinUserDao shopActivitiesGroupJoinUserDao;

    @Autowired
    private ShopReceiveAddressDao shopReceiveAddressDao;

    @Autowired
    private ShopProductDao shopProductDao;

    @Autowired
    private ShopSkuDao shopSkuDao;

    @Autowired
    private ShoppingGoodsDao shoppingGoodsDao;

    @Autowired
    private ShopOrderDao shopOrderDao;

    @Autowired
    private ShopOrderDetailsDao shopOrderDetailsDao;

    @Autowired
    private WXShopOrderService wxShopOrderService;

    @Autowired
    private ShopActivitiesDao shopActivitiesDao;

    @Autowired
    private SysVipInfoDao sysVipInfoDao;

    @Value("${activities.groupBuy.limit}")
    private String groupBuyLimit;

    @Value("${groupBuy.pay.timeLimit}")
    private String payTimeLimit;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createGroupBuy(CreateGroupBuyDTO createGroupBuyDTO) throws Exception {
        BizUser bizUser = redisUserLoginUtils.getLoginUser(BizUser.class);

        ShopActivitiesGroupPrice groupPrice = shopActivitiesGroupPriceDao.selectById(createGroupBuyDTO.getGpId());
        ShopActivitiesGroupInfo groupInfo = shopActivitiesGroupInfoDao.selectGroupInfoByActId(groupPrice.getActId());
        ShopActivities shopActivities = shopActivitiesDao.selectById(groupPrice.getActId());
        // 判断拼团是否已经结束
        if (shopActivities.getActEndTime().getTime() < new Date().getTime() || shopActivities.getActStatus() == ShopActivities.ACTIVITIES_STATUS_CLOSE) {
            return new AjaxResult(AjaxResult.STATUS_FAIL, "该拼团已结束");
        }

        // 判断最大开团数量
        if (groupInfo.getGiHeadDiscount() != null && groupInfo.getGiHeadDiscount() != 0) {
            int createCnt = shopActivitiesGroupJoinDao.selectCreateGroupBuyCount(shopActivities.getId(), bizUser.getOpenId());
            if (createCnt > groupInfo.getGiHeadDiscount()) {
                return AjaxResult.buildFailInstance("达到最大开团数量");
            }
        }
        // 限制购买数量
        if (groupInfo.getGiLimitBuy() != null && groupInfo.getGiLimitBuy() != 0) {
            if (createGroupBuyDTO.getCount() > groupInfo.getGiLimitBuy()) {
                return AjaxResult.buildFailInstance("达到最大限购数量");
            }

            int count = shopActivitiesGroupJoinUserDao.selectCountHasBuy(groupInfo.getId(), bizUser.getOpenId());
            if (count + createGroupBuyDTO.getCount() > groupInfo.getGiLimitBuy()) {
                return AjaxResult.buildFailInstance("达到最大限购数量");
            }
        }

        // 判断该用户在这个活动中是否存在拼团，并判断该拼团订单是否已付款
        ShopActivitiesGroupJoin existGroupJoin = shopActivitiesGroupJoinDao.selectExistGroupingJoinByUser(groupPrice.getActId(), bizUser.getOpenId());
        if (existGroupJoin != null) {
            if (existGroupJoin.getGjStatus() == ShopActivitiesGroupJoin.ACTIVITIES_JOIN_WAIT_PAY) {
                return new AjaxResult(AjaxResult.STATUS_FAIL, "您该活动有个订单未付款");
            }
            return new AjaxResult(AjaxResult.STATUS_FAIL, "该活动已存在拼团");
        }

        boolean isOld = isOldUser(bizUser.getPhoneNumber());
        // 老用户和老带新的开团都必须是老用户
        if (ShopActivitiesGroupInfo.GROUP_TYPE_ALL_OLD == groupInfo.getGiType() || ShopActivitiesGroupInfo.GROUP_TYPE_OLD_AND_NEW == groupInfo.getGiType()) {
            if (!isOld) {
                return AjaxResult.buildFailInstance("该活动需由老用户开团");
            }
        }

        // 新用户 -- 开团必须是新用户
        if (ShopActivitiesGroupInfo.GROUP_TYPE_ALL_NEW == groupInfo.getGiType()) {
            if (isOld) {
                return AjaxResult.buildFailInstance("该活动仅新用户参与");
            }
        }

        createGroupBuyDTO.setPrice(groupPrice.getGpPrice());
        createGroupBuyDTO.setGoodsId(groupInfo.getGoodsId().intValue());
        createGroupBuyDTO.setOpenId(bizUser.getOpenId());
        ShopOrder shopOrder = createOrderByGroupBuy(createGroupBuyDTO);

        ShopActivitiesGroupJoin groupJoin = new ShopActivitiesGroupJoin();
        groupJoin.setGpId(createGroupBuyDTO.getGpId());
        groupJoin.setActId(groupPrice.getActId());
        groupJoin.setGjBeginTime(new Date());
        Calendar gjEndTime = Calendar.getInstance();
        gjEndTime.add(Calendar.HOUR_OF_DAY, Integer.parseInt(groupBuyLimit));
        groupJoin.setGjEndTime(gjEndTime.getTime());
        groupJoin.setGiId(groupInfo.getId());
        groupJoin.setGjStatus(ShopActivitiesGroupJoin.ACTIVITIES_JOIN_WAIT_PAY);
        groupJoin.setCreateBy(bizUser.getNickName() == null ? "游客" : bizUser.getNickName());
        groupJoin.setUpdateBy(bizUser.getNickName() == null ? "游客" : bizUser.getNickName());
        groupJoin.setGjHeadId(bizUser.getOpenId());
        groupJoin.setCompanyId(shopActivities.getCompanyId());
        shopActivitiesGroupJoinDao.insert(groupJoin);

        ShopActivitiesGroupJoinUser joinUser = new ShopActivitiesGroupJoinUser();
        joinUser.setGjId(groupJoin.getId());
        joinUser.setGiId(groupInfo.getId());
        joinUser.setUserId(bizUser.getOpenId());
        joinUser.setIsHead(ShopActivitiesGroupJoinUser.USER_IS_HEAD_Y);
        joinUser.setCreateBy(bizUser.getNickName() == null ? "游客" : bizUser.getNickName());
        joinUser.setUpdateBy(bizUser.getNickName() == null ? "游客" : bizUser.getNickName());
        joinUser.setIsHasPay(ShopActivitiesGroupJoinUser.IS_HAS_PAY_N);
        joinUser.setIsHasCancel(ShopActivitiesGroupJoinUser.IS_HAS_CANCEL_N);
        Calendar payEndTime = Calendar.getInstance();
        payEndTime.add(Calendar.MINUTE, Integer.parseInt(payTimeLimit));
        joinUser.setPayEndTime(payEndTime.getTime());
        joinUser.setOrderId(shopOrder.getId().longValue());
        joinUser.setIsNewUser(isOld ? 2 : 1);
        joinUser.setCompanyId(shopActivities.getCompanyId());
        int i = shopActivitiesGroupJoinUserDao.insert(joinUser);


        BrandWCPayRequestData payData = wxShopOrderService.startPayment(shopOrder);
        AjaxResult result = new AjaxResult(AjaxResult.STATUS_SUCCESS, Arrays.asList(payData));
        result.putInMap("orderId", shopOrder.getId());
        return result;

//        return new AjaxResult(AjaxResult.STATUS_SUCCESS, "拼团成功");
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public AjaxResult joinGroupBuy(CreateGroupBuyDTO createGroupBuyDTO) throws Exception {
        BizUser bizUser = redisUserLoginUtils.getLoginUser(BizUser.class);

        // TODO 需判断拼团结束时间以及当前拼团是否已满员

        ShopActivitiesGroupJoin groupJoin = shopActivitiesGroupJoinDao.selectById(createGroupBuyDTO.getGjId());
        if (groupJoin == null) {
            return AjaxResult.buildFailInstance("该拼团不存在");
        }

        if (groupJoin.getGjHeadId().equals(bizUser.getOpenId())) {
            return AjaxResult.buildFailInstance("您是拼团团长，无法加入拼团");
        }

        if (groupJoin.getGjEndTime().getTime() < new Date().getTime()) {
            return AjaxResult.buildFailInstance("该拼团时间已结束");
        }

        ShopActivitiesGroupJoinUser groupJoinUser = shopActivitiesGroupJoinUserDao.selectGroupJoinUserByUserIdAndGjId(bizUser.getOpenId(), groupJoin.getId());
        if (groupJoinUser != null) {
            return AjaxResult.buildFailInstance("您已加入了该拼团");
        }

        List<ShopActivitiesGroupJoinUser> isExsitNoPay = shopActivitiesGroupJoinUserDao.selectGroupJoinUserByPayingAndUnCancel(groupJoin.getId());
        if (CollectionUtils.isNotEmpty(isExsitNoPay)) {
            return AjaxResult.buildFailInstance("该拼团有未支付的用户，暂不能参加");
        }

        ShopActivitiesGroupInfo groupInfo = shopActivitiesGroupInfoDao.selectById(groupJoin.getGiId());

        // 限制购买数量
        if (groupInfo.getGiLimitBuy() != null && groupInfo.getGiLimitBuy() != 0) {
            if (createGroupBuyDTO.getCount() > groupInfo.getGiLimitBuy()) {
                return AjaxResult.buildFailInstance("达到最大限购数量");
            }

            int count = shopActivitiesGroupJoinUserDao.selectCountHasBuy(groupInfo.getId(), bizUser.getOpenId());
            if (count + createGroupBuyDTO.getCount() > groupInfo.getGiLimitBuy()) {
                return AjaxResult.buildFailInstance("达到最大限购数量");
            }
        }

        ShopActivitiesGroupPrice groupPrice = shopActivitiesGroupPriceDao.selectById(groupJoin.getGpId());
        groupJoinUser = new ShopActivitiesGroupJoinUser();
        groupJoinUser.setGjId(groupJoin.getId());
        groupJoinUser.setIsHasCancel(ShopActivitiesGroupJoinUser.IS_HAS_CANCEL_N);
        List<ShopActivitiesGroupJoinUser> groupJoinUsers = shopActivitiesGroupJoinUserDao.selectByModel(groupJoinUser);
        if (groupPrice.getGpCount() <= groupJoinUsers.size()) {
            return AjaxResult.buildFailInstance("该拼团已满员");
        }

        boolean isOld = isOldUser(bizUser.getPhoneNumber());
        // 老用户 -- 加入拼团的都必须是老用户
        if (ShopActivitiesGroupInfo.GROUP_TYPE_ALL_OLD == groupInfo.getGiType()) {
            if (!isOld) {
                return AjaxResult.buildFailInstance("该活动仅老用户参与");
            }
        }

        // 新用户 -- 加入拼团的都必须是新用户
        if (ShopActivitiesGroupInfo.GROUP_TYPE_ALL_NEW == groupInfo.getGiType()) {
            if (isOld) {
                return AjaxResult.buildFailInstance("该活动仅新用户参与");
            }
        }

        // 老带新 -- 成团的时候必须有一名新用户
        if (ShopActivitiesGroupInfo.GROUP_TYPE_OLD_AND_NEW == groupInfo.getGiType()) {
            if (isOld) {
                List<ShopActivitiesGroupJoinUser> hasNewUsers = shopActivitiesGroupJoinUserDao.selectNewUserRecordByGjId(groupJoin.getId());
                if (CollectionUtils.isEmpty(hasNewUsers)) {
                    if (groupPrice.getGpCount() == (groupJoinUsers.size() + 1)) {
                        return AjaxResult.buildFailInstance("该活动必须有一位新用户");
                    }
                }
            }
        }

        createGroupBuyDTO.setPrice(groupPrice.getGpPrice());
        createGroupBuyDTO.setGoodsId(groupInfo.getGoodsId().intValue());
        createGroupBuyDTO.setOpenId(bizUser.getOpenId());
        ShopOrder shopOrder = createOrderByGroupBuy(createGroupBuyDTO);

        ShopActivitiesGroupJoinUser joinUser = new ShopActivitiesGroupJoinUser();
        joinUser.setOrderId(shopOrder.getId().longValue());
        joinUser.setIsHasPay(ShopActivitiesGroupJoinUser.IS_HAS_PAY_N);
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MINUTE, Integer.parseInt(payTimeLimit));
        joinUser.setPayEndTime(calendar.getTime());
        joinUser.setUserId(bizUser.getOpenId());
        joinUser.setGiId(groupInfo.getId());
        joinUser.setGjId(groupJoin.getId());
        joinUser.setIsHead(ShopActivitiesGroupJoinUser.USER_IS_HEAD_N);
        joinUser.setCreateBy(bizUser.getNickName() == null ? "游客" : bizUser.getNickName());
        joinUser.setUpdateBy(bizUser.getNickName() == null ? "游客" : bizUser.getNickName());
        joinUser.setIsNewUser(isOld ? 2 : 1);
        joinUser.setIsHasCancel(ShopActivitiesGroupJoinUser.IS_HAS_CANCEL_N);
        joinUser.setCompanyId(groupJoin.getCompanyId());

        // 同步锁，处理拼团中最后一个位置同时多个人加入的情况
        synchronized (this) {
            List<ShopActivitiesGroupJoinUser> users = shopActivitiesGroupJoinUserDao.selectByModel(groupJoinUser);
            if (groupPrice.getGpCount() <= users.size()) {
                return AjaxResult.buildFailInstance("该拼团已满员或正等待其他用户支付");
            }
            shopActivitiesGroupJoinUserDao.insert(joinUser);
        }
        BrandWCPayRequestData payData = wxShopOrderService.startPayment(shopOrder);
        AjaxResult result = new AjaxResult(AjaxResult.STATUS_SUCCESS, Arrays.asList(payData));
        result.putInMap("orderId", shopOrder.getId());
        return result;

//        return new AjaxResult(AjaxResult.STATUS_SUCCESS, "参团成功");
    }

    /**
     * 创建拼团订单
     *
     * @param createGroupBuyDTO
     * @return
     */
    private ShopOrder createOrderByGroupBuy(CreateGroupBuyDTO createGroupBuyDTO) {
        ShopReceiveAddress shopReceiveAddress = shopReceiveAddressDao.selectById(createGroupBuyDTO.getAddressId());
        if (shopReceiveAddress == null) {
            throw new GlobleException("请选择正确的收获地址");
        }
        BizUser user=redisUserLoginUtils.getLoginUser(BizUser.class);
        ShopOrder shopOrder = new ShopOrder();
        shopOrder.setCompanyId(user.getCompanyId());
        shopOrder.setStoreId(Integer.parseInt(createGroupBuyDTO.getShopId().toString()));
        shopOrder.setOrderType(ShopOrder.ORDER_TYPE_SERVICE);

        List<ShopSku> shopSkus = shopSkuDao.selectByPid(createGroupBuyDTO.getGoodsId());

        List<ShopOrderDetails> details = new ArrayList<>();
        ShopOrderDetails shopOrderDetails = new ShopOrderDetails();
        shopOrderDetails.setCreateBy(AppConstance.SYSTEM_USER);
        shopOrderDetails.setUpdateBy(AppConstance.SYSTEM_USER);
        shopOrderDetails.setpId(createGroupBuyDTO.getGoodsId());
        shopOrderDetails.setsId(shopSkus.get(0).getId());
        shopOrderDetails.setPrice(createGroupBuyDTO.getPrice());
        shopOrderDetails.setCount(createGroupBuyDTO.getCount());
        shopOrderDetails.setsTitle(shopSkus.get(0).getName());
        shopOrderDetails.setDiscountAmount(BigDecimal.ZERO);
        shopOrderDetails.setTotalPrice(shopOrderDetails.getPrice().multiply(BigDecimal.valueOf(shopOrderDetails.getCount())));
        details.add(shopOrderDetails);

        //查询绑定的产品是否为家居产品,如果已经含家具产品则不再比较
        if (ShopOrder.ORDER_TYPE_GOODS != shopOrder.getOrderType()) {
            ShopSku shopSku = shopSkuDao.selectById(shopSkus.get(0).getId().intValue());
            String stokCode = shopSku.getStockCode();
            if (StringUtils.isNotBlank(stokCode)) {
                ShoppingGoods shoppingGoods = shoppingGoodsDao.selectById(Long.parseLong(stokCode));
                if (shoppingGoods != null) {
                    //根据购买的产品设置订单类型
                    if (Dictionary.SHOPPING_GOODS_TYPE_JJCP.equals(shoppingGoods.getGoodType())) {
                        shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
                    } else {

                    }
                } else {
                    shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
                }
            }
        }

        //TODO 更新库存和销量 更新库存和销量[考虑和erp库存联动]
        wxShopOrderUtil.updateProductAndSkuInfo(details);

        shopOrder.setUserId(createGroupBuyDTO.getOpenId());
        shopOrder.setCreateBy("微信小程序生成");
        shopOrder.setUpdateBy("微信小程序生成");
        shopOrder.setCommodityPrice(createGroupBuyDTO.getPrice());
        shopOrder.setPurchaseQuantity(1);
        //购买方式
        shopOrder.setShippingMethod(createGroupBuyDTO.getShippingMethod());
        //生成订单号
        shopOrder.setOrderNo(WxUtils.getOrderNum());
        //设置支付状态
        shopOrder.setPayStatus(ShopOrder.ORDER_STATUS_WAIT_PAY);
        //设置订单状态
        shopOrder.setOrderStatus(ShopOrder.ORDER_PAY_STATUS_WAIT);

        //设置退款费用(注：下次优化从数据字典表获取)
        shopOrder.setRefundCharge(BigDecimal.ZERO);
        //客户电话
        shopOrder.setUserTel(shopReceiveAddress.getAddrTelephone());
        //客户姓名
        shopOrder.setUserName(shopReceiveAddress.getAddrLiaisonman());
        //删除标识
        shopOrder.setDelFlag(AppConstance.DATA_USEABLE);
        shopOrder.setActivityType(ShopOrder.ACTIVITY_TYPE_GROUP);
        //微信订单号
        shopOrder.setWxOrderNo("");
        //微信支付结果
        shopOrder.setPayResult(ShopOrder.ORDER_WX_STATUS_WAIT_PAY);
        //如果没有提交购买方式或配送方式不是物流
        //获取邮费
        BigDecimal postPrice = wxShopOrderService.calculationPostage(createGroupBuyDTO.getPrice(),user.getCompanyId());
        shopOrder.setPostage(postPrice);
        BigDecimal payPrice = createGroupBuyDTO.getPrice().multiply(BigDecimal.valueOf(createGroupBuyDTO.getCount())).add(shopOrder.getPostage());
        shopOrder.setOrderMoney(payPrice);
        DiscountExplain discountExplain = new DiscountExplain();
        discountExplain.setPayPrice(payPrice);
        discountExplain.setPostage(postPrice);
        discountExplain.setActivity(BigDecimal.ZERO);
        discountExplain.setCoupon(BigDecimal.ZERO);
        discountExplain.setBillPrice(payPrice);
        Gson g = new GsonBuilder().create();
        shopOrder.setDiscountExplain(g.toJson(discountExplain));
        shopOrderDao.insert(shopOrder);

        wxShopOrderUtil.insertSendPackageInfo(shopOrder, createGroupBuyDTO.getShippingMethod(), shopReceiveAddress);
        //给订单详情表添加订单ID
        for (ShopOrderDetails detail : details) {
            detail.setOrderId(shopOrder.getId());
        }
        if (CollectionUtils.isNotEmpty(details)) {
            shopOrderDetailsDao.batchInsert(details);
        }
        return shopOrder;
    }

    /**
     * 根据手机号判断用户是否为老用户 true--老用户 false--新用户
     *
     * @param telphone
     * @return
     */
    private boolean isOldUser(String telphone) {
        SysVipInfo sysVipInfo = sysVipInfoDao.selectOldUserByTelphone(telphone);
        if (sysVipInfo != null) {
            return true;
        }
        return false;
    }
}