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

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

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
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.PidOrderMapper;
import com.yeshi.fanli.dao.mybatis.ThreeSaleMapper;
import com.yeshi.fanli.dao.mybatis.UserInfoMapper;
import com.yeshi.fanli.dao.mybatis.hongbao.HongBaoMapper;
import com.yeshi.fanli.dao.mybatis.share.PidUserMapper;
import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoOrderMapper;
import com.yeshi.fanli.dao.order.PidOrderDao;
import com.yeshi.fanli.entity.bus.user.AccountDetails;
import com.yeshi.fanli.entity.bus.user.HongBao;
import com.yeshi.fanli.entity.bus.user.HongBaoManage;
import com.yeshi.fanli.entity.bus.user.UserInfo;
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.exception.share.UserShareGoodsRecordException;
import com.yeshi.fanli.log.LogHelper;
import com.yeshi.fanli.service.inter.hongbao.HongBaoManageService;
import com.yeshi.fanli.service.inter.order.PidOrderService;
import com.yeshi.fanli.service.inter.taobao.TaoBaoUnionConfigService;
import com.yeshi.fanli.service.inter.user.UserNotificationService;
import com.yeshi.fanli.service.inter.user.UserShareGoodsGroupService;
import com.yeshi.fanli.util.CMQManager;
import com.yeshi.fanli.util.Constant;
import com.yeshi.fanli.util.MoneyBigDecimalUtil;
import com.yeshi.fanli.util.RedisManager;
import com.yeshi.fanli.util.StringUtil;
import com.yeshi.fanli.util.factory.AccountDetailsFactory;
import com.yeshi.fanli.util.factory.HongBaoFactory;
import com.yeshi.fanli.util.factory.UserMoneyDetailFactory;
import com.yeshi.fanli.util.taobao.TaoBaoOrderUtil;

@Service
public class PidOrderServiceImpl implements PidOrderService {
	@Resource
	private PidOrderMapper pidOrderMapper;

	@Resource
	private HongBaoMapper hongBaoMapper;

	@Resource
	private PidUserMapper pidUserMapper;

	@Resource
	private HongBaoManageService hongBaoManageService;

	@Resource
	private UserInfoMapper userInfoMapper;

	@Resource
	private AccountDetailsMapper accountDetailsMapper;

	@Resource
	private AccountMessageMapper accountMessageMapper;

	@Resource
	private PidOrderDao pidOrderDao;

	@Resource
	private ThreeSaleMapper threeSaleMapper;

	@Resource
	private HongBaoManageMapper hongBaoManageMapper;

	@Resource
	private UserNotificationService userNotificationService;

	@Resource
	private TaoBaoUnionConfigService taoBaoUnionConfigService;

	@Resource
	private TaoBaoOrderMapper taoBaoOrderMapper;

	@Resource
	private RedisManager redisManager;

	// @Resource
	// private LostOrderService lostOrderService;
	
	@Resource	
	private UserShareGoodsGroupService userShareGoodsGroupService;

	@Override
	@Transactional
	public void addPidOrderFromTaoBao(Map<String, List<PidOrder>> map) {

		Iterator<String> its = map.keySet().iterator();
		while (its.hasNext()) {
			String orderId = its.next();
			List<PidOrder> orders = map.get(orderId);
			List<PidOrder> list = pidOrderMapper.getPidOrderListByOrderId(orderId);
			// 订单号已经入数据库
			if (list != null && list.size() > 0) {
				// 判断预估和订单状态是否改变
				// 订单数量一致才会改变
				if (orders.size() == list.size()) {
					for (int i = 0; i < orders.size(); i++) {
						PidOrder oldOrder = list.get(i);
						PidOrder newOrder = orders.get(i);
						// 订单的状态改变或者订单的金额改变
						if (!oldOrder.getState().equalsIgnoreCase(newOrder.getState())
								|| oldOrder.getPreMoney().compareTo(newOrder.getPreMoney()) != 0) {
							// 改变本地订单的状态与金额
							PidOrder updatePidOrder = new PidOrder();
							updatePidOrder.setId(oldOrder.getId());
							updatePidOrder.setOrderUpdateTime(new Date());
							updatePidOrder.setState(newOrder.getState());
							updatePidOrder.setPreMoney(newOrder.getPreMoney());
							updatePidOrder.setBalanceTime(newOrder.getBalanceTime());// 更改结算时间
							updatePidOrder.setFinalMoney(newOrder.getFinalMoney());
							pidOrderMapper.updateByPrimaryKeySelective(updatePidOrder);
						}
					}
				} else {
					LogHelper.orderInfo("分享商品订单数量不一致");
				}
			} else// 插入数据库
			{
				for (PidOrder order : orders) {
					order.setCreateTime(new Date());
					order.setOrderUpdateTime(new Date());
					pidOrderMapper.insertSelective(order);
				}
			}

		}

	}

	private Map<String, List<PidOrder>> parseOrderMap(List<PidOrder> orderList) {
		Map<String, List<PidOrder>> map = new HashMap<>();
		for (PidOrder pidOrder : orderList) {
			if (map.get(pidOrder.getOrderId()) == null)
				map.put(pidOrder.getOrderId(), new ArrayList<>());
			map.get(pidOrder.getOrderId()).add(pidOrder);
		}
		return map;
	}

	@Override
	@Transactional
	public void doPidOrder() {
		List<TaoBaoUnionConfig> configList = taoBaoUnionConfigService.getConfigByTypeCache(PidUser.TYPE_FANLI_ANDROID);

		// 处理本地缓存的订单数量
		List<PidOrder> list = pidOrderMapper.getPidOrderListCanUpdate(1000);
		// 防止相同订单号落入下一页
		if (list != null && list.size() > 0) {
			List<PidOrder> lastList = pidOrderMapper
					.getPidOrderListCanUpdateByOrderId(list.get(list.size() - 1).getOrderId());
			if (lastList != null && lastList.size() > 1) {
				// 相同单号的顺序是连在一起的
				List<PidOrder> oldList = new ArrayList<>();
				for (int i = list.size() - 1; i >= 0; i--) {
					if (list.get(i).getOrderId().equalsIgnoreCase(list.get(list.size() - 1).getOrderId())) {
						oldList.add(list.get(i));
					}
				}
				if (lastList.size() > oldList.size()) {// 有相同的订单没有爬完
					lastList.removeAll(oldList);
					for (PidOrder order : lastList)
						list.add(order);
				}
			}
		}

		// 设置用户的Uid
		for (PidOrder pidOrder : list) {
			if (pidOrder.getUserInfo() == null) {
				PidUser pidUser = pidUserMapper.selectByPid(String.format("mm_%s_%s_%s",
						configList.get(0).getAccountId(), pidOrder.getSrcMediaId(), pidOrder.getAdzoneId()));
				if (pidUser != null) {
					PidOrder pidOrderUpdate = new PidOrder();
					pidOrderUpdate.setId(pidOrder.getId());
					pidOrderUpdate.setUserInfo(new UserInfo(pidUser.getUid()));
					pidOrderMapper.updateByPrimaryKeySelective(pidOrderUpdate);
					pidOrder.setUserInfo(new UserInfo(pidUser.getUid()));
				} else {
					PidOrder pidOrderUpdate = new PidOrder();
					pidOrderUpdate.setId(pidOrder.getId());
					pidOrderUpdate.setBeizhu("无绑定用户");
					pidOrderUpdate.setLocalUpdateTime(new Date());
					pidOrderMapper.updateByPrimaryKeySelective(pidOrderUpdate);
				}
			}
		}

		// 获取等待处理的订单
		// 判断红包中是否存在该订单
		Map<String, List<PidOrder>> map = parseOrderMap(list);
		Iterator<String> its = map.keySet().iterator();
		while (its.hasNext()) {
			String orderId = its.next();
			// 订单锁定
			// if (isRedisLockOrder(orderId))
			// continue;
			// redisLockOrder(orderId);
			doPidOrder(orderId);
			// 处理订单找回
			// lostOrderService.processSuceess(orderId);
			// redisUnlockOrder(orderId);
		}
	}

	/**
	 * 利用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
	@Transactional
	public void doPidOrder(String orderId) {

		List<PidOrder> orders = pidOrderMapper.getPidOrderListByOrderId(orderId);
		// 只看有用户Id的情况
		if (orders.get(0).getUserInfo() != null) {
			// 根据第一个的订单创建时间来确定返利比例
			BigDecimal rate = hongBaoManageService.getShareRate(orders.get(0).getOrderCreateTime().getTime())
					.divide(new BigDecimal("100"));
			List<HongBao> hbList = hongBaoMapper.selectByOrderId(orderId);
			if (hbList.size() <= 0) {// 还没有加入红包
				// 加入红包
				for (PidOrder order : orders) {

					// 防止同一订单号来源于不同的PID
					if (order.getUserInfo() == null)
						continue;
					if (order.getState().equalsIgnoreCase("订单付款") || order.getState().equalsIgnoreCase("订单结算")
							|| order.getState().equalsIgnoreCase("订单成功")) {
						HongBao hongBao = new HongBao(order.getUserInfo(),
								order.getPreMoney().multiply(rate).setScale(2, BigDecimal.ROUND_DOWN), null,
								HongBao.TYPE_SHARE_GOODS, HongBao.STATE_BUKELINGQU, new Date().getTime(),
								new Date().getTime(), 0, "192.168.1.1", "系统添加");
						hongBao.setOrderId(order.getOrderId());
						if ("订单结算".equalsIgnoreCase(order.getState()))
							hongBao.setPayMoney(order.getFinalMoney());
						else
							hongBao.setPayMoney(order.getPayMoney());
						if (order.getBalanceTime() != null)
							hongBao.setBalanceTime(order.getBalanceTime());

						System.out.println(order.getOrderId());

						UserInfo boss = threeSaleMapper.selectBoss(order.getUserInfo().getId());
						if (boss != null) {
							hongBao.setHasChild(true);
						}

						hongBaoMapper.insertSelective(hongBao);
						
						//统计分享订单的数据
						try {
							hongBao.setAuctionId(order.getAuctionId());
							userShareGoodsGroupService.updateOrderRecord(hongBao);
						} catch (UserShareGoodsRecordException e1) {
							try {
								LogHelper.errorDetailInfo(e1);
							} catch (Exception e) {
								e.printStackTrace();
							}
						}
						

						PidOrder updatePidOrder = new PidOrder();
						updatePidOrder.setId(order.getId());
						updatePidOrder.setLocalUpdateTime(new Date());
						updatePidOrder.setHongBao(hongBao);
						pidOrderMapper.updateByPrimaryKeySelective(updatePidOrder);
						// 插入分享赚的分销红包

						if (boss != null) {
							// 计算上级返利金额
							HongBaoManage hbm = hongBaoManageMapper
									.selectByKey("share_21_" + (boss.getRank() == null ? 0 : boss.getRank()));

							BigDecimal rate21 = null;
							if (hbm == null)
								rate21 = new BigDecimal(0);
							else
								rate21 = new BigDecimal(hbm.getValue()).divide(new BigDecimal(100));
							if (rate21.compareTo(new BigDecimal(0)) > 0) {
								HongBao hongBao2 = HongBaoFactory.createHongBao(
										MoneyBigDecimalUtil.mul(rate21, hongBao.getMoney()), null, hongBao, boss,
										Constant.ONESHARE);
								// 设置订单号
								hongBao2.setOrderId(order.getOrderId());

								hongBaoMapper.insertSelective(hongBao2);
	

							}

							UserInfo boss2 = threeSaleMapper.selectBoss(boss.getId());
							// 计算上上级返利
							if (boss2 != null) {
								hbm = hongBaoManageMapper
										.selectByKey("share_22_" + (boss.getRank() == null ? 0 : boss.getRank()));
								BigDecimal rate22 = null;
								if (hbm == null)
									rate22 = new BigDecimal(0);
								else
									rate22 = new BigDecimal(hbm.getValue()).divide(new BigDecimal(100));
								if (rate.compareTo(new BigDecimal(0)) > 0) {
									HongBao hongBao3 = HongBaoFactory.createHongBao(
											MoneyBigDecimalUtil.mul(rate22,
													MoneyBigDecimalUtil.mul(hongBao.getMoney(), rate21)),
											null, hongBao, boss2, Constant.TWOSHARE);
									// 设置返利订单号
									hongBao3.setOrderId(order.getOrderId());
									hongBaoMapper.insertSelective(hongBao3);

								}
							}
						}

					} else if (order.getState().equalsIgnoreCase("订单失效")) {
						PidOrder updatePidOrder = new PidOrder();
						updatePidOrder.setId(order.getId());
						updatePidOrder.setLocalUpdateTime(new Date());
						pidOrderMapper.updateByPrimaryKeySelective(updatePidOrder);
					}
				}

			} else {// 已经存在红包

				// 需要处理子订单
				for (int i = 0; i < orders.size(); i++) {// 查询订单的红包
					if (orders.get(i).getHongBao() == null)
						continue;
					HongBao updateHongBao = new HongBao();
					updateHongBao.setId(orders.get(i).getHongBao().getId());
					if (orders.get(i).getPreMoney() != null
							&& orders.get(i).getPreMoney().compareTo(new BigDecimal(0)) > 0)
						updateHongBao.setMoney(MoneyBigDecimalUtil.mul(orders.get(i).getPreMoney(), rate));
					updateHongBao.setPayMoney(orders.get(i).getPayMoney());
					List<HongBao> childHongBaoList = hongBaoMapper
							.findChildHongBaoList(orders.get(i).getHongBao().getId());
					if (orders.get(i).getState().equalsIgnoreCase("订单失效")) {
						updateHongBao.setState(HongBao.STATE_SHIXIAO);
						// 使子红包失效
						if (childHongBaoList != null && childHongBaoList.size() > 0)
							for (HongBao childHongBao : childHongBaoList) {
								HongBao updateChildHongBao = new HongBao();
								updateChildHongBao.setId(childHongBao.getId());
								updateChildHongBao.setState(HongBao.STATE_SHIXIAO);
								hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
							}

					} else if (orders.get(i).getState().equalsIgnoreCase("订单结算")) {// 考虑到订单维权，此处不更改状态
						// 正常的订单状态
						updateHongBao.setBalanceTime(orders.get(i).getBalanceTime());
						updateHongBao.setPreGettime(
								TaoBaoOrderUtil.computeInviteFanLiTime(orders.get(i).getBalanceTime().getTime()));
						if (childHongBaoList != null && childHongBaoList.size() > 0)
							for (HongBao childHongBao : childHongBaoList) {
								HongBao updateChildHongBao = new HongBao();
								updateChildHongBao.setId(childHongBao.getId());
								updateChildHongBao.setBalanceTime(orders.get(i).getBalanceTime());
								updateChildHongBao.setPreGettime(TaoBaoOrderUtil
										.computeInviteFanLiTime(orders.get(i).getBalanceTime().getTime()));
								hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
							}
					} else if (orders.get(i).getState().equalsIgnoreCase("订单付款")) {
						updateHongBao.setState(HongBao.STATE_BUKELINGQU);
						if (childHongBaoList != null && childHongBaoList.size() > 0)
							for (HongBao childHongBao : childHongBaoList) {
								HongBao updateChildHongBao = new HongBao();
								updateChildHongBao.setId(childHongBao.getId());
								// 更改资金

								if (childHongBao.getType() == HongBao.TYPE_SHARE_YIJI) {
									HongBaoManage hbm = hongBaoManageMapper
											.selectByKey("share_21_" + (childHongBao.getUrank()));
									BigDecimal shareYiJiRate = new BigDecimal(hbm.getValue())
											.divide(new BigDecimal(100));
									BigDecimal money = MoneyBigDecimalUtil.mul(updateHongBao.getMoney(), shareYiJiRate);
									updateChildHongBao.setMoney(money);

								} else if (childHongBao.getType() == HongBao.TYPE_SHARE_ERJI) {
									HongBaoManage hbm = hongBaoManageMapper
											.selectByKey("share_21_" + (childHongBao.getUrank()));
									BigDecimal shareFirstRate = new BigDecimal(hbm.getValue())
											.divide(new BigDecimal(100));

									hbm = hongBaoManageMapper.selectByKey("share_22_" + (childHongBao.getUrank()));

									BigDecimal shareSecondRate = new BigDecimal(hbm.getValue())
											.divide(new BigDecimal(100));

									BigDecimal money = MoneyBigDecimalUtil.mul(
											MoneyBigDecimalUtil.mul(updateHongBao.getMoney(), shareFirstRate),
											shareSecondRate);

									updateChildHongBao.setMoney(money);
								}
								hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
							}
					}
					hongBaoMapper.updateByPrimaryKeySelective(updateHongBao);
					PidOrder updatePidOrder = new PidOrder();
					updatePidOrder.setId(orders.get(i).getId());
					updatePidOrder.setLocalUpdateTime(new Date());
					pidOrderMapper.updateByPrimaryKeySelective(updatePidOrder);
				}
			}
		}
	}

	// 结算到账户

	@Override
	public void compareOrderAndHongBao() {
		List<PidOrder> list = pidOrderMapper.selectByState("订单付款", 100);
		list.addAll(pidOrderMapper.selectByState("订单结算", 100));
		list.addAll(pidOrderMapper.selectByState("订单成功", 100));
		// 按订单号分类
		Map<String, List<PidOrder>> map = new HashMap<>();
		for (PidOrder pd : list) {
			if (map.get(pd.getOrderId()) == null)
				map.put(pd.getOrderId(), new ArrayList<>());
			map.get(pd.getOrderId()).add(pd);
		}
		Iterator<String> its = map.keySet().iterator();

		while (its.hasNext()) {
			String order = its.next();
			List<HongBao> hbList = hongBaoMapper.selectByOrderId(order);
			if (hbList.size() < map.get(order).size()) {
				System.out.println("尚未加入红包:" + order);
				System.out.println(map.get(order).size());
			} else if (hbList.size() > map.get(order).size()) {
				System.out.println("红包多了:" + order);
			}
		}

		for (int i = 0; i < list.size(); i++) {

		}
	}


	@Override
	public void weiQuan(String orderId) {
		List<PidOrder> list = pidOrderMapper.getPidOrderListByOrderId(orderId);
		if (list != null)
			for (PidOrder pidOrder : list) {
				if (pidOrder.getState().equalsIgnoreCase("订单失效"))
					continue;
				if (pidOrder.getHongBao() == null)
					continue;

				HongBao mainHongBao = hongBaoMapper.selectByPrimaryKey(pidOrder.getHongBao().getId());

				// 已经结算到余额
				if (mainHongBao.getState() == HongBao.STATE_YILINGQU) {
					PidOrder updatePidOrder = new PidOrder();
					updatePidOrder.setId(pidOrder.getId());
					updatePidOrder.setLocalUpdateTime(new Date());
					updatePidOrder.setBeizhu("订单维权,处理退款");
					updatePidOrder.setState("订单失效");
					pidOrderMapper.updateByPrimaryKeySelective(updatePidOrder);
					if (pidOrder.getHongBao() != null) {
						HongBao hongBao = hongBaoMapper.selectByPrimaryKey(pidOrder.getHongBao().getId());
						if (hongBao != null) {// 处理退款
							if (hongBao.getState() == HongBao.STATE_YILINGQU) {
								HongBao updateHongBao = new HongBao();
								updateHongBao.setId(hongBao.getId());
								updateHongBao.setState(HongBao.STATE_SHIXIAO);
								hongBaoMapper.updateByPrimaryKeySelective(updateHongBao);
								// 处理退款
								userInfoMapper.subHongBaoByUid(hongBao.getUserInfo().getId(), hongBao.getMoney());
								// 添加资金明细
								AccountDetails ad = AccountDetailsFactory.create("-" + hongBao.getMoney(),
										AccountDetailsFactory.SHARE_GOODS_DRAWBACK, null, null, hongBao.getUserInfo());
								accountDetailsMapper.insertSelective(ad);
								
								
								

								// 维权通知
								try {
									userNotificationService.weiQuanTiCheng(hongBao.getUserInfo().getId(), orderId,
											hongBao.getMoney());
								} catch (Exception e) {

								}
							}

							// 查询是否有子订单
							if (hongBao.getHasChild()) {
								List<HongBao> childHongBao = hongBaoMapper.selectChildHongBaoByPid(hongBao.getId());
								if (childHongBao != null && childHongBao.size() > 0)
									for (HongBao cb : childHongBao) {
										if (cb.getState() == HongBao.STATE_YILINGQU) {
											// 需要退款
											HongBao updateChildHongBao = new HongBao();
											updateChildHongBao.setId(cb.getId());
											updateChildHongBao.setState(HongBao.STATE_SHIXIAO);
											hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
											// 处理退款
											userInfoMapper.subHongBaoByUid(cb.getUserInfo().getId(), cb.getMoney());
											// 添加资金明细
											AccountDetails ad = AccountDetailsFactory.create("-" + cb.getMoney(),
													AccountDetailsFactory.SHARE_GOODS_DRAWBACK, null, null,
													cb.getUserInfo());
											accountDetailsMapper.insertSelective(ad);

											// 维权通知
											try {
												userNotificationService.weiQuanTiCheng(cb.getUserInfo().getId(),
														orderId, cb.getMoney());
											} catch (Exception e) {

											}

										} else {// 设置为失效
											HongBao updateChildHongBao = new HongBao();
											updateChildHongBao.setId(cb.getId());
											updateChildHongBao.setState(HongBao.STATE_SHIXIAO);
											hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
										}
									}
							}

						}
					}
				} else { // 尚未结算到余额
					// 先让自己失效
					if (mainHongBao.getState() != HongBao.STATE_SHIXIAO) {
						PidOrder updatePidOrder = new PidOrder();
						updatePidOrder.setId(pidOrder.getId());
						updatePidOrder.setState("订单失效");
						updatePidOrder.setLocalUpdateTime(new Date());
						updatePidOrder.setBeizhu("订单维权");
						pidOrderMapper.updateByPrimaryKeySelective(updatePidOrder);
						// 让hongbao失效
						HongBao updateHongBao = new HongBao();
						updateHongBao.setId(pidOrder.getHongBao().getId());
						updateHongBao.setState(HongBao.STATE_SHIXIAO);
						hongBaoMapper.updateByPrimaryKeySelective(updateHongBao);
						// 维权通知
						try {
							userNotificationService.weiQuanTiCheng(mainHongBao.getUserInfo().getId(), orderId,
									mainHongBao.getMoney());
						} catch (Exception e) {

						}

					}
					// 子订单维权
					// 查询是否有子订单
					if (mainHongBao.getHasChild()) {
						List<HongBao> childHongBao = hongBaoMapper.selectChildHongBaoByPid(mainHongBao.getId());
						if (childHongBao != null && childHongBao.size() > 0)
							for (HongBao cb : childHongBao) {
								if (cb.getState() == HongBao.STATE_YILINGQU) {
									// 需要退款
									HongBao updateChildHongBao = new HongBao();
									updateChildHongBao.setId(cb.getId());
									updateChildHongBao.setState(HongBao.STATE_SHIXIAO);
									hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
									// 处理退款
									userInfoMapper.subHongBaoByUid(cb.getUserInfo().getId(), cb.getMoney());
									// 添加资金明细
									AccountDetails ad = AccountDetailsFactory.create("-" + cb.getMoney(),
											AccountDetailsFactory.SHARE_GOODS_DRAWBACK, null, null, cb.getUserInfo());
									accountDetailsMapper.insertSelective(ad);

									// 维权通知
									try {
										userNotificationService.weiQuanTiCheng(cb.getUserInfo().getId(), orderId,
												cb.getMoney());
									} catch (Exception e) {

									}

								} else {// 设置为失效
									HongBao updateChildHongBao = new HongBao();
									updateChildHongBao.setId(cb.getId());
									updateChildHongBao.setState(HongBao.STATE_SHIXIAO);
									hongBaoMapper.updateByPrimaryKeySelective(updateChildHongBao);
								}
							}
					}
				}

			}

	}

	@Override
	public long getPidOrderNormalCount(Date startTime, Date endTime) {
		return pidOrderMapper.getPidOrderNormalCount(startTime, endTime);
	}

	@Override
	public PidOrder getPidOrderByHongBaoId(Long hongBaoId) {
		return pidOrderMapper.getPidOrderByHongBaoId(hongBaoId);
	}

	@Override
	public void updatePidOrderFromLocalTaoBaoOrder() {
		// 查询创建时间在40天以前的并且订单状态为付款的列表
		List<PidOrder> pidOrderList = pidOrderMapper.getPidOrderListbyStateAndMaxTime("订单付款",
				System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 40L);
		List<TaoBaoOrder> taoBaoOrderList = new ArrayList<>();
		if (pidOrderList != null)
			for (PidOrder pidOrder : pidOrderList) {
				List<TaoBaoOrder> orderList = taoBaoOrderMapper.selectTaoBaoOrderByOrderId(pidOrder.getOrderId());
				if (orderList != null && orderList.size() > 0)
					taoBaoOrderList.addAll(orderList);
			}

		Map<String, List<TaoBaoOrder>> map = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(taoBaoOrderList);
		if (map != null) {
			Iterator<String> its = map.keySet().iterator();
			while (its.hasNext()) {
				String key = its.next();
				List<TaoBaoOrder> orders = map.get(key);
				CMQManager.getInstance().addTaoBaoOrderMsg(key, orders);
			}
		}
	}
}