package com.yeshi.fanli.service.impl.order;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.yeshi.fanli.dao.mybatis.AccountDetailsMapper;
import com.yeshi.fanli.dao.mybatis.AccountMessageMapper;
import com.yeshi.fanli.dao.mybatis.HongBaoManageMapper;
import com.yeshi.fanli.dao.mybatis.HongBaoV2Mapper;
import com.yeshi.fanli.dao.mybatis.MoneyRecordMapper;
import com.yeshi.fanli.dao.mybatis.PidOrderMapper;
import com.yeshi.fanli.dao.mybatis.ThreeSaleGiftMapper;
import com.yeshi.fanli.dao.mybatis.UserInfoMapper;
import com.yeshi.fanli.dao.mybatis.hongbao.HongBaoMapper;
import com.yeshi.fanli.dao.mybatis.money.UserMoneyDetailMapper;
import com.yeshi.fanli.dao.mybatis.order.HongBaoOrderMapper;
import com.yeshi.fanli.dao.mybatis.order.OrderItemMapper;
import com.yeshi.fanli.dao.mybatis.order.OrderMapper;
import com.yeshi.fanli.dao.mybatis.share.PidUserMapper;
import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoWeiQuanOrderMapper;
import com.yeshi.fanli.entity.bus.user.AccountDetails;
import com.yeshi.fanli.entity.bus.user.HongBao;
import com.yeshi.fanli.entity.bus.user.HongBaoV2;
import com.yeshi.fanli.entity.bus.user.Order;
import com.yeshi.fanli.entity.bus.user.UserInfo;
import com.yeshi.fanli.entity.money.UserMoneyDetail;
import com.yeshi.fanli.entity.order.CommonOrder;
import com.yeshi.fanli.entity.order.HongBaoOrder;
import com.yeshi.fanli.entity.taobao.PidOrder;
import com.yeshi.fanli.entity.taobao.PidUser;
import com.yeshi.fanli.entity.taobao.TaoBaoOrder;
import com.yeshi.fanli.entity.taobao.TaoBaoUnionConfig;
import com.yeshi.fanli.entity.taobao.TaoBaoWeiQuanOrder;
import com.yeshi.fanli.exception.HongBaoException;
import com.yeshi.fanli.exception.ObjectStateException;
import com.yeshi.fanli.exception.OrderItemException;
import com.yeshi.fanli.exception.TaoBaoWeiQuanException;
import com.yeshi.fanli.exception.money.UserMoneyDetailException;
import com.yeshi.fanli.exception.order.CommonOrderException;
import com.yeshi.fanli.log.LogHelper;
import com.yeshi.fanli.service.inter.hongbao.AccountDetailsHongBaoMapService;
import com.yeshi.fanli.service.inter.hongbao.HongBaoManageService;
import com.yeshi.fanli.service.inter.hongbao.HongBaoService;
import com.yeshi.fanli.service.inter.hongbao.HongBaoV2Service;
import com.yeshi.fanli.service.inter.msg.UserMoneyMsgNotificationService;
import com.yeshi.fanli.service.inter.order.CommonOrderService;
import com.yeshi.fanli.service.inter.order.LostOrderService;
import com.yeshi.fanli.service.inter.order.OrderItemServcie;
import com.yeshi.fanli.service.inter.order.OrderProcessService;
import com.yeshi.fanli.service.inter.order.OrderService;
import com.yeshi.fanli.service.inter.order.PidOrderService;
import com.yeshi.fanli.service.inter.push.PushService;
import com.yeshi.fanli.service.inter.taobao.TaoBaoOrderService;
import com.yeshi.fanli.service.inter.taobao.TaoBaoUnionConfigService;
import com.yeshi.fanli.service.inter.taobao.TaoBaoWeiQuanDrawBackService;
import com.yeshi.fanli.service.inter.user.UserNotificationService;
import com.yeshi.fanli.util.CMQManager;
import com.yeshi.fanli.util.RedisManager;
import com.yeshi.fanli.util.StringUtil;
import com.yeshi.fanli.util.TimeUtil;
import com.yeshi.fanli.util.factory.AccountDetailsFactory;
import com.yeshi.fanli.util.factory.UserMoneyDetailFactory;

@Service
public class OrderProcessServiceImpl implements OrderProcessService {

	@Resource
	private PidOrderMapper pidOrderMapper;

	@Resource
	private OrderMapper orderMapper;

	@Resource
	private PidUserMapper pidUserMapper;

	@Resource
	private HongBaoService hongBaoService;

	@Resource
	private OrderItemServcie orderItemService;

	@Resource
	private PidOrderService pidOrderService;

	@Resource
	private UserInfoMapper userInfoMapper;

	@Resource
	private OrderItemMapper orderItemMapper;

	@Resource
	private HongBaoMapper hongBaoMapper;

	@Resource
	private HongBaoManageMapper hongBaoManageMapper;

	@Resource
	private AccountDetailsMapper accountDetailsMapper;

	@Resource
	private AccountMessageMapper accountMessageMapper;

	@Resource
	private MoneyRecordMapper moneyRecordMapper;

	@Resource
	private ThreeSaleGiftMapper threeSaleGiftMapper;

	@Resource
	private OrderService orderService;

	@Resource
	private PushService pushService;

	@Resource
	private UserNotificationService userNotificationService;

	@Resource
	private TaoBaoUnionConfigService taoBaoUnionConfigService;

	@Resource
	private TaoBaoWeiQuanDrawBackService taoBaoWeiQuanDrawBackService;

	@Resource
	private TaoBaoOrderService taoBaoOrderService;

	@Resource
	private RedisManager redisManager;

	@Resource
	private LostOrderService lostOrderService;

	@Resource
	private TaoBaoWeiQuanOrderMapper taoBaoWeiQuanOrderMapper;

	@Resource
	private HongBaoManageService hongBaoManageService;

	@Resource
	private AccountDetailsHongBaoMapService accountDetailsHongBaoMapService;

	@Resource
	private UserMoneyDetailMapper userMoneyDetailMapper;

	@Resource
	private HongBaoV2Mapper hongBaoV2Mapper;

	@Resource
	private UserMoneyMsgNotificationService userMoneyMsgNotificationService;

	@Override
	public void processOrder(Map<String, List<TaoBaoOrder>> orders) {
		List<TaoBaoUnionConfig> configList = taoBaoUnionConfigService.getConfigByTypeCache(PidUser.TYPE_FANLI_ANDROID);

		// 分离出返利订单与分享赚订单
		Iterator<String> its = orders.keySet().iterator();
		Map<String, List<TaoBaoOrder>> fanliOrderMap = new HashMap<>();
		Map<String, List<PidOrder>> sharePidOrderMap = new HashMap<>();
		Map<String, List<TaoBaoOrder>> shareOrderMap = new HashMap<>();
		while (its.hasNext()) {
			String orderId = its.next();
			if (orders.get(orderId) != null && orders.get(orderId).size() > 0) {
				List<TaoBaoOrder> list = orders.get(orderId);
				String pid = String.format("mm_%s_%s_%s", configList.get(0).getAccountId(),
						list.get(0).getSourceMediaId(), list.get(0).getAdPositionId());
				PidUser pidUser = pidUserMapper.selectByPid(pid);
				if (pidUser != null && pidUser.getType() == PidUser.TYPE_SHARE_GOODS) {// 商品分享订单
					// List<PidOrder> pidOrderList = new ArrayList<>();
					// for (TaoBaoOrder order : list) {
					// pidOrderList.add(TaoBaoOrderUtil.convertToPidOrder(order));
					// }
					// sharePidOrderMap.put(orderId, pidOrderList);
					shareOrderMap.put(orderId, list);
				} else {// 普通返利订单
					fanliOrderMap.put(orderId, list);
				}
			}
		}

		// 处理返利订单
		processShopingFanliOrder(fanliOrderMap);
		// 处理分享赚订单
		processShareGoodsOrder(shareOrderMap);
	}

	/**
	 * 利用redis的原子性将订单号锁住，不让其他处理
	 * 
	 * @param orderId
	 */
	private void redisLockOrder(String orderId) {
		String key = "doorder-" + orderId;
		redisManager.cacheCommonString(key, "1");
	}

	/**
	 * 订单解锁
	 * 
	 * @param orderId
	 */
	private void redisUnlockOrder(String orderId) {
		String key = "doorder-" + orderId;
		redisManager.removeCommonString(key);
	}

	/**
	 * 订单是否被锁住了
	 * 
	 * @param orderId
	 * @return
	 */
	private boolean isRedisLockOrder(String orderId) {
		String key = "doorder-" + orderId;
		String doing = redisManager.getCommonString(key);
		if (!StringUtil.isNullOrEmpty(doing))
			return true;
		else
			return false;
	}

	@Override
	public void processShopingFanliOrder(Map<String, List<TaoBaoOrder>> orders) {
		// 查询在Order中是否存在该订单号
		Iterator<String> its = orders.keySet().iterator();
		String tempOrderId = "";
		while (its.hasNext()) {
			try {
				String orderId = its.next();
				tempOrderId = orderId;
				// 处理红包与子红包
				// if (isRedisLockOrder(orderId))
				// continue;
				// redisLockOrder(orderId);
				processShopingFanliOrderNew(orderId, orders.get(orderId));
				// redisUnlockOrder(orderId);
				// 出错了就不处理该订单了，需要定期检查

				// 更改丢失订单的状态
				lostOrderService.processSuceess(orderId);

			} catch (HongBaoException e1) {
				e1.printStackTrace();
			} catch (OrderItemException e2) {
				e2.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
				try {
					LogHelper.errorDetailInfo(e, null, tempOrderId);
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
		}
	}

	@Transactional
	@Override
	public void processShareGoodsOrder(Map<String, List<TaoBaoOrder>> orders) {
		// pidOrderService.addPidOrderFromTaoBao(orders);
		if (orders != null) {
			Iterator<String> its = orders.keySet().iterator();
			while (its.hasNext()) {
				String orderId = its.next();
				processShareGoodsOrderNew(orderId, orders.get(orderId));
			}
		}
	}

	/**
	 * 获取最大的创建时间与最小的创建时间
	 * 
	 * @param hongBaoList
	 * @return
	 */
	private Map<String, Long> getMaxAndMinCreateTime(List<HongBao> hongBaoList) {
		if (hongBaoList.size() > 0) {
			Map<String, Long> map = new HashMap<>();
			long min = hongBaoList.get(0).getCreatetime();
			long max = hongBaoList.get(0).getCreatetime();
			for (HongBao hb : hongBaoList) {
				if (hb.getCreatetime() > max)
					max = hb.getCreatetime();
				if (hb.getCreatetime() < min)
					min = hb.getCreatetime();
			}
			map.put("max", max);
			map.put("min", min);
			return map;
		}
		return null;
	}

	@Override
	public void fanli() {
		// 获取主红包
		List<HongBaoV2> hongBaoList = hongBaoV2Mapper.listCanBalanceHongBaoByType(HongBao.TYPE_TAOBAO, 100);
		//
		// /**
		// * 需要实时更新待返利的订单
		// */
		//
		// // 计算最大的创建时间与最小的创建时间
		// Map<String, Long> map = getMaxAndMinCreateTime(hongBaoList);
		// if (map != null) {
		// long max = map.get("max");
		// long min = map.get("min");
		// // 最小时间提前10分钟
		// min = min - 1000 * 60 * 10L;
		// // 更新该段时间的订单
		// List<TaoBaoOrder> orderList = new ArrayList<>();
		// try {
		// orderList = TaoBaoOrderUtil.getOrderList(min, max);
		// } catch (TaoBaoOrderException e) {
		// e.printStackTrace();
		// }
		// // try {
		// if (orderList != null)
		// processOrder(TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(orderList));
		// // } catch (Exception e) {
		// // e.printStackTrace();
		// // try {
		// // LogHelper.errorDetailInfo(e);
		// // } catch (Exception e1) {
		// // e1.printStackTrace();
		// // }
		// // }
		// }

		/**
		 * 开始返利
		 */
		for (HongBaoV2 hb : hongBaoList) {
			//
			if (hb.getState() == HongBaoV2.STATE_SHIXIAO || hb.getState() == HongBaoV2.STATE_YILINGQU)
				continue;

			if (hb.getPreGetTime() == null || hb.getPreGetTime().getTime() == 0
					|| hb.getPreGetTime().getTime() > System.currentTimeMillis())
				continue;
			try {
				CMQManager.getInstance().addFanLiMsgNew(hb);
			} catch (Exception e) {
				try {
					LogHelper.errorDetailInfo(e);
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
		}
	}

	/**
	 * 判断订单是否失效 全部订单失效才判断为失效
	 * 
	 * @param list
	 * @return
	 */
	private boolean isOrderValid(List<TaoBaoOrder> list) {
		int validCount = 0;
		for (TaoBaoOrder order : list) {
			if (order.getOrderState().equalsIgnoreCase("订单失效"))
				validCount++;
		}
		return validCount >= list.size();
	}

	@Resource
	private HongBaoOrderMapper hongBaoOrderMapper;

	@Override
	@Transactional
	public void fanli(HongBaoV2 hb1) throws TaoBaoWeiQuanException {
		// 查询最新的红包数据
		hb1 = hongBaoV2Mapper.selectByPrimaryKeyForUpdate(hb1.getId());
		// 查询红包相关联的订单
		HongBaoOrder hongBaoOrder = hongBaoOrderMapper.selectByHongBaoId(hb1.getId());
		if (hongBaoOrder == null) {
			LogHelper.error("返利失败:" + hb1.getId());
			return;
		}
		// 维权中的不返利
		List<TaoBaoWeiQuanOrder> taoBaoWeiQuanList = taoBaoWeiQuanOrderMapper
				.selectListByOrderIdAndState(hongBaoOrder.getCommonOrder().getOrderNo(), "维权创建");
		if (taoBaoWeiQuanList != null && taoBaoWeiQuanList.size() > 0)
			return;

		taoBaoWeiQuanList = taoBaoWeiQuanOrderMapper
				.selectListByOrderIdAndState(hongBaoOrder.getCommonOrder().getOrderNo(), "等待处理");
		if (taoBaoWeiQuanList != null && taoBaoWeiQuanList.size() > 0)
			return;

		// 查询同一订单号的红包
		List<CommonOrder> orderList = commonOrderService.listBySourceTypeAndOrderId(
				hongBaoOrder.getCommonOrder().getSourceType(), hongBaoOrder.getCommonOrder().getOrderNo());
		List<HongBaoV2> hongBaoList = new ArrayList<>();
		Map<Long, BigDecimal> userMoney = new HashMap<>();
		Map<Long, List<HongBaoV2>> userHongBao = new HashMap<>();
		Map<Long, Integer> userGoodsCount = new HashMap<>();
		// Map<Long, BigDecimal> userPayMent = new HashMap<>();
		for (CommonOrder co : orderList) {
			hongBaoOrder = hongBaoOrderMapper.selectByCommonOrderId(co.getId());
			hongBaoList.add(hongBaoOrder.getHongBaoV2());
			Long uid = co.getUserInfo().getId();
			if (userGoodsCount.get(uid) == null)
				userGoodsCount.put(uid, co.getCount());
			else
				userGoodsCount.put(uid, Integer.valueOf(co.getCount() + userGoodsCount.get(uid)));
			// if (userPayMent.get(uid) == null)
			// userPayMent.put(uid, new BigDecimal(0));
			// if (co.getState() == CommonOrder.STATE_JS)
			// userPayMent.put(uid,
			// userPayMent.get(uid).add(co.getSettlement()));
			// else
			// userPayMent.put(uid, userPayMent.get(uid).add(co.getPayment()));
		}

		for (HongBaoV2 hb : hongBaoList) {
			long currentTimeMillis = System.currentTimeMillis();
			if (hb.getState() != HongBao.STATE_SHIXIAO) {
				// 设置为已返利
				// 处理主红包
				if (hb.getState() != HongBaoV2.STATE_SHIXIAO && hb.getState() != HongBaoV2.STATE_YILINGQU
						&& hb.getType() == HongBaoV2.TYPE_ZIGOU) {
					// 如果红包没被领取
					Long uid = hb.getUserInfo().getId();
					HongBaoV2 updateHongBao = new HongBaoV2();
					updateHongBao.setId(hb.getId());
					updateHongBao.setState(HongBaoV2.STATE_YILINGQU);
					updateHongBao.setGetTime(new Date(currentTimeMillis));
					hongBaoV2Mapper.updateByPrimaryKeySelective(updateHongBao);
					if (userMoney.get(uid) == null)
						userMoney.put(uid, hb.getMoney());
					else
						userMoney.put(uid, userMoney.get(uid).add(hb.getMoney()));

					// 添加红包到用户
					if (userHongBao.get(uid) == null)
						userHongBao.put(uid, new ArrayList<>());
					userHongBao.get(uid).add(hb);
				}
			}
		}

		Iterator<Long> its = userMoney.keySet().iterator();

		while (its.hasNext()) {
			// 将自己添加到用户
			Long uid = its.next();
			BigDecimal money = userMoney.get(uid);
			userInfoMapper.addHongBaoByUid(uid, money);

			AccountDetails accountDetails = AccountDetailsFactory.create("+" + money, AccountDetailsFactory.FANLI, null,
					null, new UserInfo(uid));
			accountDetailsMapper.insertSelective(accountDetails);

			// 插入新版资金明细
			try {
				UserMoneyDetail userMoneyDetail = UserMoneyDetailFactory.createFanLi(uid,
						hongBaoOrder.getCommonOrder().getOrderNo(), hongBaoOrder.getCommonOrder().getSourceType(), null,
						money);
				userMoneyDetail.setId(accountDetails.getId());
				userMoneyDetailMapper.insert(userMoneyDetail);
			} catch (UserMoneyDetailException e1) {
				try {
					LogHelper.errorDetailInfo(e1);
				} catch (Exception e2) {
					e2.printStackTrace();
				}
			}

			// 添加资金明细与红包的映射关系
			for (HongBaoV2 v2 : userHongBao.get(uid)) {
				accountDetailsHongBaoMapService.saveAccountDetailsHongBaoMap(v2.getId(), accountDetails.getId());
			}

			// 站内信+推送
			UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
			try {
				userNotificationService.orderFanliRecieved(uid, hongBaoOrder.getCommonOrder().getOrderNo(),
						userGoodsCount.get(uid), user.getMyHongBao(), money);
			} catch (Exception e) {
				try {
					LogHelper.errorDetailInfo(e);
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}

			// 新版通知
			userMoneyMsgNotificationService.fanliOrderReceived(uid, hongBaoOrder.getCommonOrder().getOrderNo(),
					userGoodsCount.get(uid), money, user.getMyHongBao());

		}

		// 维权扣款（2018-08-05后开始实行）
		if (hongBaoOrder.getCommonOrder().getSettleTime() != null && hongBaoOrder.getCommonOrder().getSettleTime()
				.getTime() >= TimeUtil.convertToTimeTemp("2018-08-05", "yyyy-MM-dd")) {
			taoBaoWeiQuanDrawBackService.doWeiQuanFanli(hongBaoOrder.getCommonOrder().getOrderNo());
		}

	}

	@Override
	public void weiQuanOrder(List<TaoBaoWeiQuanOrder> orderList) {
		if (orderList != null)
			for (TaoBaoWeiQuanOrder order : orderList) {
				if (order.getState().equalsIgnoreCase("维权成功")) {
					CMQManager.getInstance().addWeiQuanOrderMsg(order);
				}
			}
	}

	@Transactional
	@Override
	public void weiQuanOrder(TaoBaoWeiQuanOrder order) {
		// 订单结算时间在2018-08-05后就不处理维权了

		List<TaoBaoOrder> orderList = taoBaoOrderService.getTaoBaoOrderByOrderId(order.getOrderId());
		if (orderList != null && orderList.size() > 0 & !StringUtil.isNullOrEmpty(orderList.get(0).getSettlementTime()))
			order.setJieSuanTime(
					new Date(TimeUtil.convertToTimeTemp(orderList.get(0).getSettlementTime(), "yyyy-MM-dd HH:mm:ss")));
		if (order.getJieSuanTime().getTime() >= TimeUtil.convertToTimeTemp("2018-08-05", "yyyy-MM-dd")) {
			return;
		}
		try {
			orderService.failureOrderWithWeiQuan(order.getOrderId(), Order.ORDER_TYPE_TAOBAO);
		} catch (ObjectStateException e) {
			e.printStackTrace();
		}
		pidOrderService.weiQuan(order.getOrderId());
	}

	@Override
	public void fanliInvaiteAndShare() {
		// 查出邀请赚与分享赚该返利的用户ID
		List<Long> inviteAndShareUids = hongBaoV2Mapper.listUidCanBanlanceShareAndInvite(1000);
		Set<Long> uidSets = new HashSet<>();
		if (inviteAndShareUids != null)
			for (Long uid : inviteAndShareUids)
				uidSets.add(uid);
		// 根据用户ID
		Iterator<Long> its = uidSets.iterator();
		while (its.hasNext()) {
			Long uid = its.next();
			try {
				CMQManager.getInstance().addFanLiTiChengMsg(uid);
			} catch (Exception e) {
				e.printStackTrace();
				LogHelper.error(e);
			}
		}
	}

	private HongBaoV2 filterWeiQuanINGHongBao(HongBaoV2 hongBao) {

		long hbId = hongBao.getId();
		if (hongBao.getParent() != null) {
			hbId = hongBao.getParent().getId();
		}

		HongBaoOrder hongbaoOrder = hongBaoOrderMapper.selectByHongBaoId(hbId);

		if (hongbaoOrder == null)
			return null;

		List<TaoBaoWeiQuanOrder> taoBaoWeiQuanList = taoBaoWeiQuanOrderMapper
				.selectListByOrderIdAndState(hongbaoOrder.getCommonOrder().getOrderNo(), "维权创建");

		List<TaoBaoWeiQuanOrder> taoBaoWeiQuanList1 = taoBaoWeiQuanOrderMapper
				.selectListByOrderIdAndState(hongbaoOrder.getCommonOrder().getOrderNo(), "等待处理");
		if ((taoBaoWeiQuanList != null && taoBaoWeiQuanList.size() > 0)
				|| (taoBaoWeiQuanList1 != null && taoBaoWeiQuanList1.size() > 0)) {
			return null;
		}
		return hongBao;
	}

	@Override
	@Transactional
	public void fanliInvaiteAndShare(Long uid) throws TaoBaoWeiQuanException {
		/**
		 * 处理邀请赚订单
		 */
		// 查询UID的邀请赚订单
		List<Integer> types = new ArrayList<>();
		types.add(HongBaoV2.TYPE_YIJI);
		types.add(HongBaoV2.TYPE_ERJI);
		List<HongBaoV2> hongBaoList = hongBaoV2Mapper.listCanBalanceHongBaoByTypeAndUid(types, uid, 1000);

		List<Long> hbIdList = new ArrayList<>();

		BigDecimal invitemoney = new BigDecimal(0);
		Set<String> inviteOrders = new HashSet<>();
		int inviteGoodsCount = 0;

		// 需要判断退款的订单号
		Set<String> drawBackOrders = new HashSet<String>();
		for (HongBaoV2 hongBao : hongBaoList) {
			hongBao = filterWeiQuanINGHongBao(hongBao);
			if (hongBao == null)
				continue;

			hongBao = hongBaoV2Mapper.selectByPrimaryKeyForUpdate(hongBao.getId());
			if (hongBao.getState() == HongBaoV2.STATE_BUKELINGQU || hongBao.getState() == HongBaoV2.STATE_KELINGQU) {
				invitemoney = invitemoney.add(hongBao.getMoney());
				HongBaoV2 updateHongBao = new HongBaoV2();
				updateHongBao.setId(hongBao.getId());
				updateHongBao.setGetTime(new Date());
				updateHongBao.setState(HongBaoV2.STATE_YILINGQU);
				updateHongBao.setUpdateTime(new Date());
				hongBaoV2Mapper.updateByPrimaryKeySelective(updateHongBao);
				// 添加到红包返利记录集合
				hbIdList.add(hongBao.getId());

				// 2018-08-05 过后的订单才处理维权

				HongBaoOrder hongBaoOrder = hongBaoOrderMapper.selectByHongBaoId(hongBao.getParent().getId());
				inviteGoodsCount += hongBaoOrder.getCommonOrder().getCount();
				inviteOrders.add(hongBaoOrder.getCommonOrder().getOrderNo());

				Date balanceTime = hongBaoOrder.getCommonOrder().getSettleTime();
				if (balanceTime != null
						&& balanceTime.getTime() >= TimeUtil.convertToTimeTemp("2018-08-05", "yyyy-MM-dd")) {
					if (!StringUtil.isNullOrEmpty(hongBaoOrder.getCommonOrder().getOrderNo()))
						drawBackOrders.add(hongBaoOrder.getCommonOrder().getOrderNo());
				}
			}
		}

		/**
		 * 处理一级二级分享赚(属于邀请赚类型)
		 */

		List<HongBaoV2> totalHongBaoList = new ArrayList<>();
		// 查询UID的二级或者三级分享赚订单
		// TODO 暂时查询10000条数据，后面再做分页
		types.clear();
		types.add(HongBaoV2.TYPE_SHARE_YIJI);
		types.add(HongBaoV2.TYPE_SHARE_ERJI);
		List<HongBaoV2> hbList = hongBaoV2Mapper.listCanBalanceHongBaoByTypeAndUid(types, uid, 10000);

		if (hbList != null && hbList.size() > 0)
			totalHongBaoList.addAll(hbList);

		for (HongBaoV2 hb : totalHongBaoList) {
			if (hb.getState() == HongBaoV2.STATE_BUKELINGQU || hb.getState() == HongBaoV2.STATE_KELINGQU) {
				hb = filterWeiQuanINGHongBao(hb);
				if (hb == null)
					continue;
				invitemoney = invitemoney.add(hb.getMoney());
				HongBaoV2 updateHongBao = new HongBaoV2();
				updateHongBao.setId(hb.getId());
				updateHongBao.setGetTime(new Date());
				updateHongBao.setState(HongBaoV2.STATE_YILINGQU);
				updateHongBao.setUpdateTime(new Date());
				hongBaoV2Mapper.updateByPrimaryKeySelective(updateHongBao);
				// 添加到红包返利记录集合
				hbIdList.add(hb.getId());

				HongBaoOrder hongBaoOrder = hongBaoOrderMapper.selectByHongBaoId(hb.getParent().getId());
				inviteGoodsCount += hongBaoOrder.getCommonOrder().getCount();
				inviteOrders.add(hongBaoOrder.getCommonOrder().getOrderNo());
				if (!StringUtil.isNullOrEmpty(hongBaoOrder.getCommonOrder().getOrderNo()))
					drawBackOrders.add(hongBaoOrder.getCommonOrder().getOrderNo());
			}
		}

		// 邀请赚到账
		if (invitemoney.compareTo(new BigDecimal(0)) > 0) {
			userInfoMapper.addHongBaoByUid(uid, invitemoney);
			// 添加记录
			AccountDetails accountDetails = AccountDetailsFactory.create("+" + invitemoney,
					AccountDetailsFactory.TICHENG, null, null, new UserInfo(uid));
			accountDetailsMapper.insertSelective(accountDetails);

			// 添加新版详情记录
			try {
				// 查询邀请赚的有效订单，失效订单，维权订单
				Calendar ca = Calendar.getInstance();
				Date maxDate = new Date(TimeUtil
						.convertToTimeTemp(ca.get(Calendar.YEAR) + "-" + (ca.get(Calendar.MONTH) + 1), "yyyy-M"));
				ca.add(Calendar.MONTH, -1);

				Date minDate = new Date(TimeUtil
						.convertToTimeTemp(ca.get(Calendar.YEAR) + "-" + (ca.get(Calendar.MONTH) + 1), "yyyy-M"));
				long validCount = hongBaoV2Mapper.countInviteOrderCountByUidAndSettleTime(uid, CommonOrder.STATE_JS,
						minDate, maxDate);
				long weiQuanCount = hongBaoV2Mapper.countInviteOrderCountByUidAndSettleTime(uid, CommonOrder.STATE_WQ,
						minDate, maxDate);
				long invalidCount = hongBaoV2Mapper.countInviteOrderCountByUidAndSettleTime(uid, CommonOrder.STATE_SX,
						minDate, maxDate);

				UserMoneyDetail userMoneyDetail = UserMoneyDetailFactory.createInvite(uid, (int) validCount,
						(int) weiQuanCount, (int) invalidCount, invitemoney, new Date());
				userMoneyDetail.setId(accountDetails.getId());
				userMoneyDetailMapper.insert(userMoneyDetail);
			} catch (UserMoneyDetailException e) {
				try {
					LogHelper.errorDetailInfo(e);
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}

			// 记录返利红包与资金详情的对应关系

			// 添加到红包返利记录集合
			accountDetailsHongBaoMapService.saveAccountDetailsHongBaoMap(hbIdList, accountDetails.getId());

			// 发送推送
			try {
				// 提成到账消息通知
				userNotificationService.tiChengInviteRecieved(uid, inviteOrders.size(), inviteGoodsCount, null,
						invitemoney);
			} catch (Exception e) {
				e.printStackTrace();
			}

			// 新版通知
			userMoneyMsgNotificationService.inviteOrderReceived(uid, inviteOrders.size(), inviteGoodsCount, invitemoney,
					userInfoMapper.selectByPrimaryKey(uid).getMyHongBao());

			for (String orderId : drawBackOrders)
				taoBaoWeiQuanDrawBackService.doWeiQuanInvite(orderId);
		}

		hbIdList.clear();
		drawBackOrders.clear();

		/**
		 * 处理分享赚
		 */

		int shareGoodsCount = 0;
		Set<String> shareOrders = new HashSet<>();
		BigDecimal sharemoney = new BigDecimal(0);
		// 查询UID的分享赚订单
		types.clear();
		types.add(HongBaoV2.TYPE_SHARE_GOODS);
		List<HongBaoV2> hongBaoShareList = hongBaoV2Mapper.listCanBalanceHongBaoByTypeAndUid(types, uid, 10000);
		for (HongBaoV2 hongBao : hongBaoShareList) {
			hongBao = hongBaoV2Mapper.selectByPrimaryKeyForUpdate(hongBao.getId());
			hongBao = filterWeiQuanINGHongBao(hongBao);
			if (hongBao == null)
				continue;
			if (hongBao.getState() == HongBaoV2.STATE_BUKELINGQU || hongBao.getState() == HongBaoV2.STATE_KELINGQU) {
				sharemoney = sharemoney.add(hongBao.getMoney());
				HongBaoV2 updateHongBao = new HongBaoV2();
				updateHongBao.setId(hongBao.getId());
				updateHongBao.setGetTime(new Date());
				updateHongBao.setState(HongBao.STATE_YILINGQU);
				updateHongBao.setUpdateTime(new Date());
				hongBaoV2Mapper.updateByPrimaryKeySelective(updateHongBao);
				// 添加到红包返利记录集合
				hbIdList.add(hongBao.getId());
				// 2018-08-05 过后的订单才处理维权
				Date balanceTime = null;
				HongBaoOrder hongBaoOrder = hongBaoOrderMapper.selectByHongBaoId(hongBao.getId());
				if (hongBaoOrder != null)
					balanceTime = hongBaoOrder.getCommonOrder().getSettleTime();
				shareOrders.add(hongBaoOrder.getCommonOrder().getOrderNo());
				if (balanceTime != null
						&& balanceTime.getTime() >= TimeUtil.convertToTimeTemp("2018-08-05", "yyyy-MM-dd")) {
					drawBackOrders.add(hongBaoOrder.getCommonOrder().getOrderNo());
				}
			}
		}

		/**
		 * 分享赚到账
		 */

		if (sharemoney.compareTo(new BigDecimal(0)) > 0) {
			userInfoMapper.addHongBaoByUid(uid, sharemoney);
			// 添加记录
			AccountDetails accountDetails = AccountDetailsFactory.create("+" + sharemoney,
					AccountDetailsFactory.SHARE_GOODS, null, null, new UserInfo(uid));
			accountDetailsMapper.insertSelective(accountDetails);

			// 添加新版详情记录
			try {
				// 计算本月的有效订单，失效订单，维权订单
				Calendar ca = Calendar.getInstance();

				Date maxDate = new Date(TimeUtil
						.convertToTimeTemp(ca.get(Calendar.YEAR) + "-" + (ca.get(Calendar.MONTH) + 1), "yyyy-M"));
				ca.add(Calendar.MONTH, -1);

				Date minDate = new Date(TimeUtil
						.convertToTimeTemp(ca.get(Calendar.YEAR) + "-" + (ca.get(Calendar.MONTH) + 1), "yyyy-M"));
				long validCount = commonOrderService.countByUidAndOrderStateWithOrderBalanceTime(uid,
						CommonOrder.STATE_JS, minDate, maxDate);
				long weiQuanCount = commonOrderService.countByUidAndOrderStateWithOrderBalanceTime(uid,
						CommonOrder.STATE_WQ, minDate, maxDate);
				long invalidCount = commonOrderService.countByUidAndOrderStateWithOrderBalanceTime(uid,
						CommonOrder.STATE_SX, minDate, maxDate);

				UserMoneyDetail userMoneyDetail = UserMoneyDetailFactory.createShare(uid, (int) validCount,
						(int) weiQuanCount, (int) invalidCount, sharemoney, new Date());
				userMoneyDetail.setId(accountDetails.getId());
				userMoneyDetailMapper.insert(userMoneyDetail);
			} catch (UserMoneyDetailException e) {
				try {
					LogHelper.errorDetailInfo(e);
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
			// 记录返利红包与资金详情的对应关系

			// 添加到红包返利记录集合
			accountDetailsHongBaoMapService.saveAccountDetailsHongBaoMap(hbIdList, accountDetails.getId());

			// 发送推送
			try {
				// 提成到账消息通知
				userNotificationService.tiChengShareRecieved(uid, shareOrders.size(), shareGoodsCount, null,
						sharemoney);
			} catch (Exception e) {
				e.printStackTrace();
			}

			// 新版通知
			userMoneyMsgNotificationService.shareOrderReceived(uid, shareOrders.size(), shareGoodsCount, sharemoney,
					userInfoMapper.selectByPrimaryKey(uid).getMyHongBao());

			for (String orderId : drawBackOrders)
				taoBaoWeiQuanDrawBackService.doWeiQuanShare(orderId);
		}

	}

	@Resource
	private CommonOrderService commonOrderService;

	@Resource
	private HongBaoV2Service hongBaoV2Service;

	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	@Override
	public void processShopingFanliOrderNew(String orderId, List<TaoBaoOrder> orderList)
			throws HongBaoException, OrderItemException {
		List<TaoBaoUnionConfig> configList = taoBaoUnionConfigService.getConfigByTypeCache(PidUser.TYPE_FANLI_ANDROID);

		if (orderList != null && orderList.size() > 0) {
			String pid = String.format("mm_%s_%s_%s", configList.get(0).getAccountId(),
					orderList.get(0).getSourceMediaId(), orderList.get(0).getAdPositionId());

			Order oldOrder = orderMapper.selectOrderByOrderId(orderId);
			// 原来不存在订单
			Long uid = null;
			if (oldOrder == null) {
				PidUser pidUser = pidUserMapper.selectByPid(pid);
				if (pidUser != null) {
					uid = pidUser.getUid();

					// 插入到Order中
					// 添加到订单中去
					Order order = new Order();
					order.setBeizhu("PID返利订单");
					order.setCreatetime(System.currentTimeMillis());
					order.setOrderId(orderId);
					order.setOrderType(1);
					order.setState(Order.STATE_YIZHIFU);
					order.setUserInfo(new UserInfo(uid));
					order.setVersion(2);
					// 加入到订单表
					orderMapper.insertSelective(order);
					oldOrder = order;
				}
			} else {
				uid = oldOrder.getUserInfo().getId();
			}
			// 尚未找到和PID对应的用户
			if (uid == null)
				return;

			// 计算订单总额度
			Order updateOrder = new Order();
			updateOrder.setId(oldOrder.getId());
			BigDecimal money = new BigDecimal(0);
			for (TaoBaoOrder o : orderList) {
				if (o.getOrderState().equalsIgnoreCase("订单结算"))
					money = money.add(o.getSettlement());
				else {
					money = money.add(o.getPayment());
				}
			}
			updateOrder.setMoney(money);
			String thirdState = null;
			for (TaoBaoOrder o : orderList)
				if (!o.getOrderState().equalsIgnoreCase("订单失效")) {
					thirdState = o.getOrderState();
					break;
				}

			if (StringUtil.isNullOrEmpty(thirdState))
				thirdState = "订单失效";
			updateOrder.setThirdState(thirdState);
			updateOrder.setThirdCreateTime(
					new Date(TimeUtil.convertToTimeTemp(orderList.get(0).getCreateTime(), "yyyy-MM-dd HH:mm:ss")));
			orderMapper.updateByPrimaryKeySelective(updateOrder);

			// 用第一个子订单锁定用户
			List<CommonOrder> commonOrderList = null;
			try {
				commonOrderList = commonOrderService.addTaoBaoOrder(orderList, uid);
				hongBaoV2Service.addHongBao(commonOrderList, HongBaoV2.TYPE_ZIGOU);
			} catch (CommonOrderException e) {
				try {
					LogHelper.errorDetailInfo(e, null, "订单号:" + orderId);
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
		}
	}

	@Override
	public void processShareGoodsOrderNew(String orderId, List<TaoBaoOrder> orderList) {
		List<TaoBaoUnionConfig> configList = taoBaoUnionConfigService.getConfigByTypeCache(PidUser.TYPE_FANLI_ANDROID);
		if (orderList != null && orderList.size() > 0) {
			String pid = String.format("mm_%s_%s_%s", configList.get(0).getAccountId(),
					orderList.get(0).getSourceMediaId(), orderList.get(0).getAdPositionId());
			// 原来不存在订单
			Long uid = null;
			PidUser pidUser = pidUserMapper.selectByPid(pid);
			if (pidUser != null)
				uid = pidUser.getUid();

			// 尚未找到和PID对应的用户
			if (uid == null)
				return;

			// 用第一个子订单锁定用户
			try {
				List<CommonOrder> commonOrders = commonOrderService.addTaoBaoOrder(orderList, uid);
				hongBaoV2Service.addHongBao(commonOrders, HongBaoV2.TYPE_SHARE_GOODS);
			} catch (CommonOrderException e) {
				e.printStackTrace();
			} catch (HongBaoException e1) {
				e1.printStackTrace();
			}
		}

	}

}