package com.iamberry.wechat.handles.order;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.regex.Pattern;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.iamberry.wechat.core.entity.coupon.*;
import com.iamberry.wechat.core.entity.product.ProductColor;
import com.iamberry.wechat.face.coupon.ExchangeService;
import com.iamberry.wechat.face.porduct.ProductColorService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.iamberry.wechat.core.entity.PageBean;
import com.iamberry.wechat.core.entity.ResultMsg;
import com.iamberry.wechat.core.entity.WechatUtils;
import com.iamberry.wechat.core.entity.cart.CartDto;
import com.iamberry.wechat.core.entity.cart.OrderPayDto;
import com.iamberry.wechat.core.entity.cart.SendPayDto;
import com.iamberry.wechat.core.entity.cart.ShopSalesOrderDto;
import com.iamberry.wechat.core.entity.cart.TempOrderDto;
import com.iamberry.wechat.core.entity.cart.UserGiftDto;
import com.iamberry.wechat.core.entity.member.CashLog;
import com.iamberry.wechat.core.entity.member.Member;
import com.iamberry.wechat.core.entity.mq.MQMessage;
import com.iamberry.wechat.core.entity.order.Order;
import com.iamberry.wechat.core.entity.order.OrderItem;
import com.iamberry.wechat.core.entity.pay.PayResult;
import com.iamberry.wechat.core.entity.product.Product;
import com.iamberry.wechat.face.admin.SystemService;
import com.iamberry.wechat.face.cart.CartService;
import com.iamberry.wechat.face.cart.ProductInfoService;
import com.iamberry.wechat.face.coupon.CouponItemService;
import com.iamberry.wechat.face.coupon.CouponTypeService;
import com.iamberry.wechat.face.home.HomeService;
import com.iamberry.wechat.face.member.CashLogService;
import com.iamberry.wechat.face.member.MemberService;
import com.iamberry.wechat.face.pay.PayService;
import com.iamberry.wechat.face.qrcode.TemporaryQrcodeService;
import com.iamberry.wechat.face.reback.RebackServices;
import com.iamberry.wechat.handles.mq.MQServiceProxy;
import com.iamberry.wechat.tools.NameUtils;
import com.iamberry.wechat.tools.OrderNOUtil;
import com.iamberry.wechat.tools.ResultInfo;
import com.iamberry.wechat.tools.ValidatorUtil;

/**
 * @author 何秀刚
 * Class Description: 订单hander
 * Create Date:2016年4月20日
 * Update Date:2016年4月20日
 */
@Controller
@RequestMapping("/wechat/order")
public class OrderHandler {
	
	@Autowired
	private CartService cartService;
	
	@Autowired
	private HomeService homeService;
	
	@Autowired
	private SystemService systemService;
	
	@Autowired
	private ValidatorUtil validatorUtil;
	
	@Autowired
	private PayService payService;
	
	@Autowired
	private MemberService memberService;
	@Autowired
	CouponItemService couponItemService;
	@Autowired
	ExchangeService exchangeService;
	@Autowired
	CouponTypeService couponTypeService;
	@Autowired
	CashLogService cashLogService;
	@Autowired
	private RebackServices rebackServices;
	@Autowired
	private MQServiceProxy mQservice;
	@Autowired
	private ProductInfoService productInfoService;
	@Autowired
	private TemporaryQrcodeService temporaryQrcodeService;
	@Autowired
	private ProductColorService productColorService;
	/**
	 * 支付前，调用方法
	 * @param request
	 * @return
	 * @throws Exception
	 */
	@ResponseBody
	@RequestMapping(value = "/payBefore", method = RequestMethod.POST)
	public ResultMsg payBefore(HttpServletRequest request) {
		
		ResultMsg msg = new ResultMsg();
		msg.setResultCode(ResultInfo.ERRORCODE);
		
		OrderPayDto dto = new OrderPayDto();
		// 用户信息
		Member member = WechatUtils.getUserBySession(request);
		member = memberService.getMemberByUserId(member.getUserId());
		String cartIds = request.getParameter("cartId");
		if (cartIds == null) {
			msg.setMessage(ResultInfo.cartEmptyError);
			return msg;
		}
		cartIds.trim();
		// split 购物车ID
		String [] cartList = cartIds.split("-");
		if (cartList == null || cartList.length <= 0) {
			msg.setMessage(ResultInfo.cartEmptyError);
			return msg;
		}
		// 转化 String 类型的购物车ID集合 --> Integer 类型的购物车集合
		Integer[] cartIntList = new Integer[cartList.length];
		for (int i = 0; i < cartList.length; i++) {
			String string = cartList[i];
			try {
				cartIntList[i] = Integer.parseInt(string);
			} catch (Exception e) {
				msg.setMessage(e.getMessage());
				return msg;
			}
		}
		if (cartIntList.length <= 0) {
			msg.setMessage(ResultInfo.cartEmptyError);
			return msg;
		}
		// 根据购物车ID，查询数据库中对应的产品信息（ID、产品状态）
		List<CartDto> cartDtos = cartService.selectCartItemByListId(cartIntList);
		if (cartDtos == null || cartDtos.size() <= 0) {
			msg.setMessage(ResultInfo.cartEmptyError);
			return msg;
		}
		
		//根据openid查询该用户是否购买过订单
		ShopSalesOrderDto shopSalesOrderDto = new ShopSalesOrderDto();
		shopSalesOrderDto.setSalesOpenid(member.getUserOpenid());
		shopSalesOrderDto.setSalesStatus("2");
		int orderNum = cartService.selectOrderCount(shopSalesOrderDto);
		//如果购买过订单，则滤芯的价格可按折扣价购买
		if (orderNum > 0) {
			if (cartDtos != null && cartDtos.size() >= 1) {
				for (CartDto cartDto : cartDtos) {
					if (cartDto.getProductType().intValue() == 2) {
						UserGiftDto userGiftDto = new UserGiftDto();
						userGiftDto.setUserLevel(3);
						userGiftDto.setUserProductId(cartDto.getCartProductId());
						userGiftDto.setUserColorId(cartDto.getCartColorId());
						//根据商品id和会员等级查询礼品信息
						userGiftDto = productInfoService.selectUserGift(userGiftDto);
						if (userGiftDto != null) {
							cartDto.setProductPrice(userGiftDto.getUserDiscount());
						}
					}
				}
			}
		}
		
		// 判断当前提交的购物车ID，有多少产品在售
		int total = 0; // 支付金额
		int sum = 0; // 产品数量
		int productNum = 0;	//计算商品为滤芯的数量
		boolean disable = true;	//标识，是否可用优惠券，当购买商品只有滤芯时禁止使用优惠券
		
		List<CartDto> tempCarts = new ArrayList<CartDto>();
		for (CartDto cartDto : cartDtos) {
			if (cartDto.getProductStatus() != null && cartDto.getProductStatus().intValue() == 1) {
				total += cartDto.getCartNum() * cartDto.getProductPrice();
				sum++;
				tempCarts.add(cartDto);
			}
			//计算商品为滤芯的数量
			if (cartDto.getProductType().intValue() == 2) {
				productNum++;
			}
		}
		
		//当购买商品只有滤芯时禁止使用优惠券
		if(productNum == cartDtos.size()) {
			disable = false;
		}
		
		if (sum <= 0) {
			msg.setMessage(ResultInfo.cartEmptyError);
			return msg;
		}
		
		//未使用的优惠券
		CouponItemDto cDto = new CouponItemDto();	
		cDto.setUseropenid(member.getUserOpenid());
		cDto.setCouponUseStatus(1);
		cDto.setBeginDate(new Date());
		cDto.setPage(new PageBean());
		cDto.getPage().setPageSize(12);
		//cDto.getPage().setPageNumber(pageNO);
		List<CouponItemDto> list = couponItemService.getCouponItemDtoList(cDto);

		//整理优惠券，在下面循环中有可能会删除无法使用的优惠券
		List<CouponItemDto> couponItemDtoList = new ArrayList<>();
		for (CouponItemDto cid : list){

			if(total < cid.getCouponConsumeEnough()){
				cid.setIsCanUsed(2);
			}else{
				cid.setIsCanUsed(1);
			}

			if(3 == cid.getCouponType()){
				//判断抵扣券的是否能够使用
				Exchange exchange = new Exchange();
				exchange.setCouponId(cid.getCouponId());
				List<Exchange>  exchangeList = exchangeService.getExchangeList(exchange);
				for (Exchange ex : exchangeList){
					boolean fl = false;	//用于表示是否有兑换的产品
					for (CartDto cartDto : cartDtos) {
						Integer noColor = 0;
						for (ExchangeItem exchangeItem : ex.getExchangeItemList()){
							if(cartDto.getCartColorId().equals(exchangeItem.getColorId())){
								fl = true;
							}
						}
					}
					if(!fl){
						cid.setIsCanUsed(2);
					}
				}
			}
			couponItemDtoList.add(cid);
		}
		
		dto.setCouponItems(couponItemDtoList);

		dto.setUserIsVip(member.getUserIsVip());
		dto.setCartId(cartIds);// 购物车ID
		dto.setPayTotal(total); // 支付金额,单位为分
		dto.setCartItems(tempCarts); // 订单项
		dto.setSuccess(true); // 请求成功
		dto.setMeonyProportion(0);
		dto.setBalance(member.getUserIncome());
		
		dto.setDisable(disable);
		
		//回显用户支付过的地址信息
		Order order=cartService.getOrderRecentAddress(member.getUserOpenid());
		if(order!=null){
			HashMap<String,String> map = new HashMap<String,String>();
			//map.put("orderId", order.getSalesOrderid());
			map.put("salesAddressName", order.getSalesAddressName());
			map.put("salesAddressInfo", order.getSalesAddressInfo());
			map.put("salesAddressTel", order.getSalesAddressTel());
			map.put("salesAddressPostnum", order.getSalesAddressPostnum());
			dto.setAddressInfo(map);
		}
		
		msg.setResultCode(ResultInfo.SUCCESSCODE);
		msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
		msg.setData(dto);
		msg.setStatus(true);
		
		return msg;
	}
	
	/**
	 * 发起支付请求
	 * @param request 支付参数, 根据情况调整方法是否进行synchronized<br>在生成订单时不会存在安全问题
	 * @return
	 * @throws Exception 
	 */
	@ResponseBody
	@RequestMapping(value = "/pay", method = RequestMethod.POST)
	public ResultMsg requestPay(
			TempOrderDto temp,
			HttpServletRequest request
			)  {
		
		ResultMsg msg = new ResultMsg();
		msg.setResultCode(ResultInfo.ERRORCODE);
		//System.out.println(temp.toString());
		//当前支付时间
		Date nowDate=new Date();

		SendPayDto dto = new SendPayDto();
		dto.setSuccess(false);
		Member member = WechatUtils.getUserBySession(request); // 当前用户
		member = memberService.getMemberByUserId(member.getUserId());
		/** 数据格式校验 */
		if (member == null || member.getUserOpenid() == null) {// 校验当前用户信息是否丢失
			msg.setMessage(ResultInfo.loginOutError);
			return msg;
		}
		
		member=memberService.getMemberByUserId(member.getUserId());
		if (!validatorUtil.validatorObject(temp)) { // 校验订单信息是否输入有误
			msg.setMessage(ResultInfo.paramFormatError);
			return msg;
		}
		if (temp.getOrderUserRemark() != null && !temp.getOrderUserRemark().isEmpty()) {
			Pattern pattern = Pattern.compile("^[\u4e00-\u9fa5_a-zA-Z0-9]+$");
			if (!pattern.matcher(temp.getOrderUserRemark()).find()) {
				msg.setMessage(ResultInfo.paramFormatError);
				return msg;
			}
			if (!(temp.getOrderUserRemark().length() >= 1 && temp.getOrderUserRemark().length() <= 100)) {
				msg.setMessage(ResultInfo.paramFormatError);
				return msg;
			}
		}
		Integer [] cartId = null;
		try {
			cartId = checkCartIdListString(temp.getCartIdStr());
		} catch (Exception e) { // 一旦发生异常，表示错误
			msg.setMessage(ResultInfo.paramFormatError);
			return msg;
		}
		List<CartDto> cartDtos = cartService.selectCartItemByListId(cartId);
		if (cartDtos == null || cartDtos.size() <= 0) {// 根据购物车ID，查询数据库中对应的产品信息（ID、产品状态）
			msg.setMessage(ResultInfo.cartEmptyError);
			return msg;
		}

		if(temp.getExchangeColorId() != null && !"".equals(temp.getExchangeColorId())){
			ProductColor productColor = productColorService.selectProductColorById(Integer.valueOf(temp.getExchangeColorId()));
			CartDto cartDto = new CartDto();
			cartDto.setCartProductId(productColor.getColorProductId());
			cartDto.setCartColorId(productColor.getColorId());
			cartDto.setCartNum(1);
			cartDto.setProductName(productColor.getColorProductName());
			cartDto.setProductType(productColor.getColorProductType());	//colorProductType
			cartDto.setProductPrice(productColor.getColorDiscount());
			cartDto.setProductDiscount(productColor.getColorPrice());
			cartDto.setProductStatus(1);
			cartDto.setTotal(productColor.getColorDiscount());
			cartDto.setProductColor(productColor.getColorName());
			cartDto.setColorImg(productColor.getColorProductPic());
			cartDtos.add(cartDto);
		}

		//根据openid查询该用户是否购买过订单
		ShopSalesOrderDto shopSalesOrderDto = new ShopSalesOrderDto();
		shopSalesOrderDto.setSalesOpenid(member.getUserOpenid());
		shopSalesOrderDto.setSalesStatus("2");
		int orderNum = cartService.selectOrderCount(shopSalesOrderDto);
		
		int total = 0; // 需要支付的总额, 单位为分
		
		
		//查询金牌会员模板id
		int templateId = systemService.selectOneShopRuleById(114).getRuleNum().intValue();
		UserGiftDto userGift = null;
		int giftNum = 0;
		//vip会员买年套滤芯减价，此表示为减价金额
		int priceReduction = 0;
		
		/** 提前准备订单项数据 */
		/** 准备数据 */
		Order order = new Order();
		order.setSalesOrderid(OrderNOUtil.createOrderCode(member.getUserId())); // 订单ID
		List<OrderItem> list = new ArrayList<OrderItem>();
		List<Integer> cartIds = new ArrayList<Integer>();
		
		for (CartDto cartDto : cartDtos) {
			//如果购买过订单，则滤芯的价格可按折扣价购买
			if (orderNum > 0) {
				if (cartDto.getProductType().intValue() == 2) {
					UserGiftDto userGiftDto = new UserGiftDto();
					userGiftDto.setUserLevel(3);
					userGiftDto.setUserProductId(cartDto.getCartProductId());
					userGiftDto.setUserColorId(cartDto.getCartColorId());
					//根据商品id和会员等级查询礼品信息
//					userGiftDto = productInfoService.selectUserGift(userGiftDto);
//					if (userGiftDto != null) {
//						cartDto.setProductPrice(userGiftDto.getUserDiscount());
//					}
				}
			}
			//VIP用户滤芯年套减一百
			if(cartDto.getCartColorId() == 5 && member.getUserIsVip() == 2){
				priceReduction += 10000*cartDto.getCartNum();
			}
			
			//如果模板id等于金牌会模板id，则该用户为金牌会员下线
//			if (member.getUserDealers() != null && member.getTemplateId() != null
//					&& templateId == member.getTemplateId().intValue() && member.getUserResType().intValue() == 3) {
//				UserGiftDto userGiftDto = new UserGiftDto();
//				userGiftDto.setUserLevel(2);
//				userGiftDto.setUserProductId(cartDto.getCartProductId());
//				userGiftDto.setUserColorId(cartDto.getCartColorId());
//				//根据商品id和会员等级查询礼品信息
//				userGiftDto = productInfoService.selectUserGift(userGiftDto);
//				if (userGiftDto != null) {
//					cartDto.setProductPrice(userGiftDto.getUserDiscount());
//					giftNum += cartDto.getCartNum();
//					if (userGift == null) {
//						userGift = userGiftDto;
//					}
//				}
//			}
			
			if (cartDto.getProductStatus() != null && cartDto.getProductStatus().intValue() == 1) {
				cartIds.add(cartDto.getCartId());
				Integer subTotal = cartDto.getCartNum() * cartDto.getProductPrice(); // 小计
				total += subTotal;
				OrderItem item = new OrderItem();
				item.setItemNum(cartDto.getCartNum());
				item.setItemProductDiscount(cartDto.getProductPrice());
				item.setItemProductId(cartDto.getCartProductId());
				item.setItemProductName(cartDto.getProductName());
				item.setItemProductPic(cartDto.getProductIntroduceImg());
				item.setItemSalesOrderid(order.getSalesOrderid());
				item.setItemTotal(subTotal);
				item.setItemProductType(cartDto.getProductType());
				item.setItemProductPrice(cartDto.getProductDiscount());
				item.setItemColorId(cartDto.getCartColorId());
				list.add(item);
			}
		}

		//如果模板id等于金牌会模板id，来源是3，则该用户为金牌会员直接下线，直接下线送三年滤芯
		if (member.getUserDealers() != null && member.getTemplateId() != null && 
				templateId == member.getTemplateId().intValue() && member.getUserResType().intValue() == 3) {
			//当userGift不为空时，说明该用户购买的商品有奖励礼品，奖励礼品取第一个产品的，不适用于多个产品有不同奖励礼品的情况
			if (userGift != null && userGift.getUserGiftId() != null && !"".equals(userGift.getUserGiftId())) {
				Product product = productInfoService.getProductByProductId(userGift.getUserGiftId(),userGift.getUserGiftColor());
				OrderItem orderItem = new OrderItem();
				orderItem.setItemNum(userGift.getUserGiftCount() * giftNum);
				orderItem.setItemProductDiscount(0);
				orderItem.setItemProductId(userGift.getUserGiftId());
				orderItem.setItemProductName(product.getProductName());
				orderItem.setItemProductPic(product.getProductIntroduceImg());
				orderItem.setItemSalesOrderid(order.getSalesOrderid());
				orderItem.setItemTotal(0);
				orderItem.setItemProductType(product.getProductType().getTypeId());
				orderItem.setItemProductPrice(0);
				orderItem.setItemColorId(userGift.getUserColorId());
				list.add(orderItem);
			}
		}
		
		// 准备订单对象
		order.setSalesOpenid(member.getUserOpenid()); // openid 
		order.setSalesAmount(total); // 订单金额
		total -= priceReduction;
		
		int mustPay=0;
		
		String couponId=temp.getCouponId();
		CouponItemDto couponItemDto=new CouponItemDto();
		CouponItem couponItem=new CouponItem();
		boolean hasCoupon=false;
		//获取优惠券不为空
		if(couponId!=null && !couponId.equals("")){
			hasCoupon=true;
			//查询优惠券，获取对应的金额
			couponItemDto = couponItemService.getCouponItemById(couponId);
			couponItem.setCouponId(couponItemDto.getCouponId());
			couponItem.setCouponItemId(couponItemDto.getCouponItemId());
			couponItem.setCouponItemRemark(couponItemDto.getCouponItemRemark());
			couponItem.setCouponItemUseropenid(couponItemDto.getUseropenid());
			couponItem.setCouponUseEndDate(couponItemDto.getCouponUseEndDate());
			couponItem.setCouponUseDate(couponItemDto.getCouponUseDate());
			
			if(null==couponItemDto || !couponItemDto.getUseropenid().equals(member.getUserOpenid()) || couponItemDto.getCouponUseStatus()!=1){
				msg.setMessage(ResultInfo.COUPON_INVALID); //优惠券无效
				return msg;
			}
			if(couponItem.getCouponUseEndDate().getTime()<nowDate.getTime()){
				msg.setMessage(ResultInfo.COUPON_OUTOFDATE); //优惠券过期
				return msg;
			}
			
			//消费达到指定额度
			CouponType couponType = couponTypeService.getCouponTypeById(couponItemDto.getCouponId());
			if(couponType.getCouponConsumeEnough()>total){
				msg.setMessage(ResultInfo.COUPON_CONSUME_NO_ENOUGH); //消费额度不足
				return msg;
			}

			if(3 == couponType.getCouponType()){
				//判断抵扣券的是否能够使用
				Exchange exchange = new Exchange();
				exchange.setCouponId(couponType.getCouponId());
				List<Exchange>  exchangeList = exchangeService.getExchangeList(exchange);
				boolean fl = false;
				for (Exchange ex : exchangeList){
					for (ExchangeItem exchangeItem : ex.getExchangeItemList()){
						for (CartDto cartDto : cartDtos) {
							if(cartDto.getCartColorId().equals(exchangeItem.getColorId())){
								fl = true;
							}
						}
					}
					if(fl){
						break;
					}
				}
				if(!fl){
					msg.setMessage(ResultInfo.COUPON_NO_MEET_DEMAND); //消费没有达到需求
					return msg;
				}
			}


			//优惠券的类型，是直接减免额度 还是折扣价 
			if(couponType.getCouponType()==1){
				total=total-couponType.getCouponReduce();
			}else if(couponType.getCouponType()==2){
				total=total*couponType.getCouponReduce()/100;
			}else if(couponType.getCouponType()==3){
				total=total-couponType.getCouponReduce();
			}
		
		}
		if(total==0 || total<0){
			total=0;
			mustPay=0;
		}else{
			mustPay=total;
		}
		
		//获取账户余额，判断是否在可用范围内
		int balancePayAmount=temp.getBalancePayAmount();
		if(balancePayAmount>0 && member.getUserIncome()>balancePayAmount){
			mustPay=total-temp.getBalancePayAmount()>0?total-temp.getBalancePayAmount():0;
		}else if(balancePayAmount>0 && member.getUserIncome()<balancePayAmount){
			msg.setMessage(ResultInfo.NO_ENOUGH_FOR_PAY);
			return msg;
		}
		
		order.setSalesYetAmount(total);
		order.setSalesRateAmount(0);
		order.setSalesIntegralNum(temp.getOrderIntegralNum()); // 订单使用积分
		order.setSalesCreateDate(new Date()); // 创建时间
		order.setBalancePayAmount(temp.getBalancePayAmount()); //账户余额支付金额
		order.setCouponId(couponId);   //优惠券id

		order.setSalesStatus(1); // 待支付订单
		order.setSalesTransactionDate(nowDate);  //事务时间
		order.setSalesTransactionId("8990"+nowDate.getTime());
		order.setSalesAddressInfo(temp.getOrderAddressInfo()); // 收货地址
		order.setSalesAddressName(temp.getOrderAddressName()); // 收货人
		order.setSalesAddressTel(temp.getOrderAddressMoblie()); // 收入联系方式
		order.setSalesAddressPostnum(temp.getOrderAddressPostNum()); // 物流编号
		order.setSalesUserRemark(temp.getOrderUserRemark()); // 用户备注
		// 保存
		boolean flag = false;
		try {
			flag = cartService.addOrderAndSaveOrderItem(order, list, cartIds);
//System.out.println("====插入订单列表信息===="+flag);
			//修改优惠券状态为临时状态
			if(hasCoupon){
				couponItem.setCouponUseStatus(7);
				couponItemService.updateCouponItemById(couponItem);
			}
		} catch (Exception e) {
			flag = false;
			System.out.println("====插入订单列表信息失败====");
			msg.setMessage(ResultInfo.paramFormatError);
			return msg;
		}
		
		boolean updateFlase=false;
		if (flag && mustPay>0) {
			// 发起支付
			PayResult result = payService.requestPay(order.getSalesOpenid(), order.getSalesOrderid(), mustPay, list.get(0).getItemProductName() + "...", NameUtils.getConfig("WECHAT_ORDER_BACK"));
			if (result.isPaySuccess()) {
				dto.setInfo(result.getPayData());
				dto.setSuccess(true);
				dto.setOrderId(order.getSalesOrderid());
				updateFlase=false;
			} else {
				dto.setInfo(result.getPayData());
				dto.setOrderId(order.getSalesOrderid());
				msg.setResultCode(ResultInfo.ERRORCODE);
				msg.setMessage(NameUtils.getConfig("ERRORINFO"));
				msg.setData(dto);
				msg.setStatus(false);
				return msg;
			}
		} else if(flag && mustPay==0){
			dto.setInfo("isOK");
			dto.setSuccess(true);
			dto.setOrderId(order.getSalesOrderid());
			updateFlase=true;
		}else{
			msg.setMessage(ResultInfo.paramFormatError);
			return msg;
		}
	
		if(updateFlase){
			//设置订单状态，还有优惠券id
			order.setSalesStatus(2);
			cartService.updateOrderStatus(order);
			//修改优惠券状态
			if(hasCoupon){
				couponItem.setCouponUseStatus(2);
//				int i=couponItemService.updateCouponItemById(couponItem);
			}
				
			//更新账户余额
			if(balancePayAmount>0){
				member.setUserIncome(-balancePayAmount);
				memberService.updateUserIncomeByOpenId(member);
				
				//修改用户购买记录为已购买
				memberService.updateIsBaughtByOpenid(member.getUserOpenid(), 2);
				//更新用户绑定状态
				if (member.getUserIsFlag()!= null && member.getUserIsFlag() == 1) {
					member.setUserIsFlag(2);//终身绑定
					homeService.updateMemberIsFlagByOpenid(member);
				}
				try {
					temporaryQrcodeService.applyTempQrcode(member.getUserOpenid());//为用户生成二维码
				} catch (Exception e) {
					System.out.println("为用户生成二维码失败!");
				}
				
				//现金使用记录
				CashLog log=new CashLog();
				log.setCashLogsIntroduction("订单支出");
				log.setCashLogsNum(balancePayAmount);
				log.setCashLogsOpenid(member.getUserOpenid());
				log.setCashLogsType(2);
				log.setCashLogsResType(3);
				log.setCashLogsOrderid(order.getSalesOrderid());
				log.setCashLogsCreateDate(nowDate);
				cashLogService.addCashLog(log);
			
			}
			rebackServices.loadSingleOrderReward(order);
			productInfoService.updateProductNumList(order.getSalesOrderid());
			
		}
		msg.setResultCode(ResultInfo.SUCCESSCODE);
		msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
		dto.setOrderId(order.getSalesOrderid());
		msg.setData(dto);
		msg.setStatus(true);
		
		return msg;
	}
	
	/**
	 * 校验订单状态，判断是否支付成功
	 * @param orderId
	 * @return
	 */
	@ResponseBody
	@RequestMapping(value = "/checkOrderPaySuccess")
	public ResultMsg checkOrderPaySuccess(
			@RequestParam(value = "orderId") String orderId) {
		ResultMsg msg = new ResultMsg();
		msg.setResultCode(ResultInfo.ERRORCODE);
		Integer orderStatus = cartService.selectOrderStatusByOrderId(orderId);
		if (orderStatus != null && orderStatus.intValue() == 2) {
			msg.setResultCode(ResultInfo.SUCCESSCODE);
			msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
			msg.setStatus(true);
			return msg;
		}
		msg.setResultCode(ResultInfo.ERRORCODE);
		msg.setMessage(NameUtils.getConfig("ERRORINFO"));
		msg.setStatus(false);
		
		return msg;
	}

	@RequestMapping("/paySuccess")
	public void paySuccess(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.getRequestDispatcher(NameUtils.getConfig("WECHAT_SHOP_ORDER_PAY_SUCCESS")).forward(request, response);
	}
	
	@RequestMapping(value = "/getOrderInfo", method = RequestMethod.POST)
	@ResponseBody
	public ResultMsg getOrderInfoByOrderId(
			HttpServletRequest request,
			@RequestParam(value = "orderId") String orderId) throws Exception {
		ResultMsg msg = new ResultMsg();
		msg.setResultCode(ResultInfo.ERRORCODE);
		Member member = WechatUtils.getUserBySession(request); // 当前用户
		Order order = new Order();
		order.setSalesOrderid(orderId);
		order.setSalesOpenid(member.getUserOpenid());
		order = cartService.selectOrderInfoById(order);
		
		if (order == null || order.getSalesStatus() != 2) {
			msg.setMessage(ResultInfo.paramFormatError);
			return msg;
		}
		
		msg.setData(order);
		msg.setResultCode(ResultInfo.SUCCESSCODE);
		msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
		msg.setStatus(true);
		return msg;
	}
	
	/**
	 * 校验一个购物车字符串
	 * @param cartIds 购物车ID字符串
	 * @param cartId 接受数据数组
	 * @return
	 * @throws Exception 
	 */
	public Integer[] checkCartIdListString(String cartIds) throws Exception {
		if (cartIds == null) {
			throw new Exception(ResultInfo.paramFormatError);
		}
		cartIds.trim();
		// split 购物车ID
		String [] cartList = cartIds.split("-");
		if (cartList == null || cartList.length <= 0) {
			throw new Exception(ResultInfo.paramFormatError);
		}
		// 转化 String 类型的购物车ID集合 --> Integer 类型的购物车集合
		Integer[] cartIntList = new Integer[cartList.length];
		for (int i = 0; i < cartList.length; i++) {
			String string = cartList[i];
			try {
				cartIntList[i] = Integer.parseInt(string);
			} catch (Exception e) {
				throw new Exception(ResultInfo.paramFormatError);
			}
		}
		if (cartIntList.length <= 0) {
			throw new Exception(ResultInfo.paramFormatError);
		}
		return cartIntList;
	}
}
