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.integral.StayIntegral;
import com.iamberry.wechat.core.entity.product.ProductColor;
import com.iamberry.wechat.core.entity.product.QrcodeGift;
import com.iamberry.wechat.face.integral.UseIntegralService;
import com.iamberry.wechat.face.mq.EfastOrderService;
import com.iamberry.wechat.face.order.AdminOrderService;
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.coupon.CouponItem;
import com.iamberry.wechat.core.entity.coupon.CouponItemDto;
import com.iamberry.wechat.core.entity.coupon.CouponType;
import com.iamberry.wechat.core.entity.member.CashLog;
import com.iamberry.wechat.core.entity.member.Member;
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
	CouponTypeService couponTypeService;
	@Autowired
	CashLogService cashLogService;
	@Autowired
	private RebackServices rebackServices;
	@Autowired
	private ProductInfoService productInfoService;
	@Autowired
	private TemporaryQrcodeService temporaryQrcodeService;
	@Autowired
	private ProductColorService productColorService;

	@Autowired
	private UseIntegralService useIntegralService;

	@Autowired
	private EfastOrderService efastOrderService;

	/**
	 * 支付前，调用方法
	 * @param request
	 * @return
	 * @throws Exception
	 */
	@ResponseBody
	@RequestMapping(value = "/payBefore")
	public ResultMsg payBefore(HttpServletRequest request) throws Exception {

		ResultMsg msg = new ResultMsg();
		msg.setResultCode(ResultInfo.ERRORCODE);

		OrderPayDto dto = new OrderPayDto();
		// 用户信息
		String openId  = WechatUtils.getUserBySession(request).getUserOpenid();
		Member member = memberService.getMemberByUserOpenId(openId);
		String cartIds = request.getParameter("cartIds");
		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;
		}

		// 判断当前提交的购物车ID，有多少产品在售
		int total = 0; // 支付金额
		int sum = 0; // 产品数量
		boolean disable = false;	//标识，是否可以使用(新人券)优惠券，当购买商品需要有牙刷时才能使用优惠券
		String element = systemService.selectOneShopRuleById(249).getRuleDesc();

		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);
			}else if(cartDto.getProductStatus().intValue() != 1){
				msg.setMessage(ResultInfo.cartNoStatusError);
				return msg;
			}
			String[] els = element.split("-");
			for(String el : els){
				if(cartDto.getProductType() == Integer.valueOf(el)){		//订单中没有牙刷的时候，不能使用新人券
					disable = true;
				}
			}
		}
		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> couponItemDtoList = couponItemService.getCouponItemDtoList(cDto);
		List<CouponItemDto> list = new ArrayList<>();
		for(CouponItemDto couponItemDto : couponItemDtoList){
			boolean flag = true;
			if(couponItemDto.getCouponIsNewPeople() == 1 && member.getUserIdentity() != 1){  //当券为新人券，用户为非会员时，需要有牙刷，结算才可以使用该券
				if(!disable){		//订单中没有牙刷
					flag = false;
				}
			}
			if(flag){
				list.add(couponItemDto);
			}
		}
		/*插入优惠券*/
		dto.setCouponItems(list);

		dto.setCartId(cartIds);// 购物车ID
		dto.setPayTotal(total); // 支付金额,单位为分
		dto.setCartItems(tempCarts); // 订单项
		dto.setSuccess(true); // 请求成功
		dto.setMeonyProportion(0);

		//回显用户支付过的地址信息
		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;
	}


	/**
	 * 测试推送efast
	 * @return
	 * @throws Exception
	 */
	@ResponseBody
	@RequestMapping(value = "/toEfast")
	public ResultMsg toEfast(HttpServletRequest request) throws Exception {
		ResultMsg msg = new ResultMsg();

		Order order = new Order();
		order.setSalesOrderid("0119173614I15563Z");
		efastOrderService.addOrderInfoToEfastTest(order);

		msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
		msg.setData("");
		msg.setStatus(true);
		return msg;
	}

	/**
	 * 发起支付请求
	 * @return
	 * @throws Exception
	 */
	@ResponseBody
	@RequestMapping(value = "/pay", method = RequestMethod.POST)
	public ResultMsg requestPay(
			TempOrderDto temp,
			HttpServletRequest request
	) throws Exception {

		ResultMsg msg = new ResultMsg();
		int machineNum = 0;//所有水机的数量
		StringBuilder preGift = new StringBuilder();
		msg.setResultCode(ResultInfo.ERRORCODE);
		//当前支付时间
		Date nowDate=new Date();

		SendPayDto dto = new SendPayDto();
		dto.setSuccess(false);

		Member member = WechatUtils.getUserBySession(request); // 当前用户

		/** 数据格式校验 */
		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;
		}

		/*是否含有电动牙刷*/
		boolean isContainProduct = false;

		int total = 0; // 需要支付的总额, 单位为分
		/** 提前准备订单项数据 */
		/** 准备数据 */
		Order order = new Order();
		order.setSalesOrderid(OrderNOUtil.createOrderCode(member.getUserId())); // 订单ID
		List<OrderItem> list = new ArrayList<OrderItem>();
		List<Integer> cartIds = new ArrayList<Integer>();
		int num = productInfoService.getQrCodeByPlaceOpenId(member.getUserOpenid());
		for (CartDto cartDto : cartDtos) {
			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);
			}else if(cartDto.getProductStatus().intValue() != 1){
				msg.setMessage(ResultInfo.cartNoStatusError);
				return msg;
			}
			if(cartDto.getProductType() == 100){		//当订单中有电动牙刷时，isContainProduct为true
				isContainProduct = true;
			}
		}

		// 准备订单对象
		order.setSalesOpenid(member.getUserOpenid()); // openid 
		order.setSalesAmount(total); // 订单金额

		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());
			couponItem.setCouponIsNewPeople(couponItemDto.getCouponIsNewPeople());

			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(member.getUserIdentity() != 1){  //判断该用户是否为会员
				if(couponItem.getCouponIsNewPeople() == 1 && !isContainProduct){
					msg.setMessage(ResultInfo.COUPON_NO_MEMBER); //非会员需要购买电动牙刷才能使用该优惠券
					return msg;
				}
			}
			//优惠券的类型，是直接减免额度 还是折扣价
			if(couponType.getCouponType()==1){
				total=total-couponType.getCouponReduce();
			}else if(couponType.getCouponType()==2){
				Integer all =  new Integer(total);
				total=total*couponType.getCouponReduce()/100;
			}
		}
		if(total==0 || total<0){
			total=0;
			mustPay=0;
		}else{
			mustPay=total;
		}

		order.setSalesYetAmount(total);
		order.setSalesRateAmount(0);
		order.setSalesIntegralNum(0); // 订单使用积分
		order.setSalesCreateDate(new Date()); // 创建时间
		order.setBalancePayAmount(0); //账户余额支付金额
		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);
				couponItem.setCouponUseDate(new Date());//添加使用时间
				int i=couponItemService.updateCouponItemById(couponItem);
			}
			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(HttpServletRequest request,
			@RequestParam(value = "orderId") String orderId) {
		Member member = WechatUtils.getUserBySession(request); // 当前用户
		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.setData(orderId);
			msg.setStatus(true);
			return msg;
		}
		msg.setResultCode(ResultInfo.ERRORCODE);
		msg.setMessage(NameUtils.getConfig("ERRORINFO"));
		msg.setData(orderId);
		msg.setStatus(false);
		return msg;
	}

	/**
	 * 获取订单支付的积分
	 * @param orderId
	 * @return
	 */
	@ResponseBody
	@RequestMapping(value = "/getOrderIntegral")
	public ResultMsg getOrderIntegral(HttpServletRequest request,@RequestParam(value = "orderId") String orderId) {
		Member member = WechatUtils.getUserBySession(request); // 当前用户
		ResultMsg msg = new ResultMsg();
		msg.setResultCode(ResultInfo.ERRORCODE);
		//Integer orderStatus = cartService.selectOrderStatusByOrderId(orderId);
		if(orderId == null || "".equals(orderId)){
			msg.setResultCode(ResultInfo.ERRORCODE);
			msg.setMessage(NameUtils.getConfig("未查询到订单信息！"));
			msg.setStatus(false);
			return msg;
		}
		StayIntegral stayIntegral = new StayIntegral();
		stayIntegral.setOrderId(orderId);
		List<StayIntegral>  listStayIntegral = useIntegralService.listStayIntegral(stayIntegral);
		if (listStayIntegral != null && listStayIntegral.size() > 0) {
			msg.setResultCode(ResultInfo.SUCCESSCODE);
			msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
			msg.setData(listStayIntegral.get(0).getStayNumber());
			msg.setStatus(true);
			return msg;
		}else{
			msg.setResultCode(ResultInfo.SUCCESSCODE);
			msg.setMessage(NameUtils.getConfig("SUCCESSINFO"));
			msg.setData(0);
			msg.setStatus(true);
			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字符串
	 * @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;
	}
}
