package project.web.api;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.ObjectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import kernel.exception.BusinessException;
import kernel.sessiontoken.SessionTokenService;
import kernel.util.StringUtils;
import kernel.util.ThreadUtils;
import kernel.web.ApplicationUtil;
import kernel.web.BaseAction;
import kernel.web.Page;
import kernel.web.ResultObject;
import project.Constants;
import project.RedisKeys;
import project.c2c.C2cAdvert;
import project.c2c.C2cAdvertService;
import project.c2c.C2cLock;
import project.c2c.C2cOrder;
import project.c2c.C2cOrderLock;
import project.c2c.C2cOrderService;
import project.c2c.C2cPaymentMethod;
import project.c2c.C2cPaymentMethodService;
import project.c2c.C2cTranslate;
import project.c2c.C2cTranslateService;
import project.onlinechat.otc.OtcOnlineChatMessageService;
import project.party.PartyService;
import project.party.model.Party;
import project.redis.RedisHandler;
import project.syspara.Syspara;
import project.syspara.SysparaService;
import util.DateUtil;
import util.RandomUtil;

/**
 * C2C订单
 */
@RestController
@CrossOrigin
public class C2cOrderController extends BaseAction {

	private Logger logger = LoggerFactory.getLogger(C2cOrderController.class);

	@Autowired
	private C2cOrderService c2cOrderService;
	@Autowired
	protected OtcOnlineChatMessageService otcOnlineChatMessageService;
	@Autowired
	protected PartyService partyService;
	@Autowired
	private SessionTokenService sessionTokenService;
	@Autowired
	private SysparaService sysparaService;
	@Autowired
	private C2cAdvertService c2cAdvertService;
	@Autowired
	private C2cPaymentMethodService c2cPaymentMethodService;
	@Autowired
	private RedisHandler redisHandler;
	@Autowired
	private C2cTranslateService c2cTranslateService;
    
	private final String action = "/api/c2cOrder!";
	
	/**
	 * 首次进入下单页面，传递session_token
	 */
	@RequestMapping(action + "order_open.action")
	public Object order_open(HttpServletRequest request) throws IOException {
		String currency = request.getParameter("currency");		

		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		try {
			
			if (StringUtils.isEmptyString(currency)) {
				throw new BusinessException("支付币种不正确");
			}

			String partyId = this.getLoginPartyId();
			String session_token = this.sessionTokenService.savePut(partyId);
			
			Map<String, String> allPrice = this.c2cAdvertService.getAllSymbolPrice(currency);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("session_token", session_token);
			data.put("all_price", allPrice);

			resultObject.setData(data);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}
		
		return resultObject;
	}
	
	/**
	 * 自选区下单：购买、出售
	 * 
	 * safe_password 资金密码
	 * c2c_advert_id 广告id
	 * payment_method_id 支付方式ID：购买为承兑商收款方式ID，出售为用户收款方式ID
	 * order_type 订单类型：by_amount按支付金额/by_num按币种数量
	 * amount 支付金额
	 * coin_amount 币种数量
	 * remark 备注
	 */
	@RequestMapping(action + "open.action")
	public Object open(HttpServletRequest request) {
		String session_token = request.getParameter("session_token");
//		String safe_password = request.getParameter("safe_password");
		String c2c_advert_id = request.getParameter("c2c_advert_id");
		String payment_method_id = request.getParameter("payment_method_id");
		String order_type = request.getParameter("order_type");
		String direction = request.getParameter("direction");
		String amount = request.getParameter("amount");
		String coin_amount = request.getParameter("coin_amount");
		String remark = request.getParameter("remark");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		String partyId = this.getLoginPartyId();
		if (null == partyId) {
			throw new BusinessException("请重新登录");
		}
		
		boolean lock = false;
		Party party = new Party();
		String orderNo = DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8);
		try {
			
			party = this.partyService.cachePartyBy(partyId, false);
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				throw new BusinessException("无权限");
			}
			
			if (!C2cLock.add(partyId)) {
				throw new BusinessException("Please try again later");
			}
			lock = true;
			
			Object object = this.sessionTokenService.cacheGet(session_token);
			this.sessionTokenService.del(session_token);
			if (null == object || !partyId.equals((String) object)) {
				throw new BusinessException("请稍后再试");
			}
			
			if (!party.getEnabled()) {
				resultObject.setCode("506");
				resultObject.setMsg("用户已锁定");
				return resultObject;
			}
						
			// C2C用户未结束订单最大数量
			Long nofinishOrderCount = this.c2cOrderService.getNofinishOrderCount(partyId,direction);
			Syspara syspara = this.sysparaService.find("c2c_sell_only_one");
			if(ObjectUtils.isNotEmpty(syspara)) {
				String c2c_sell_only_one = syspara.getValue();
				if(StringUtils.isNotEmpty(c2c_sell_only_one)&&"1".equals(c2c_sell_only_one)) {
					if(nofinishOrderCount >= 1) {
						throw new BusinessException("提交失败，当前有未处理订单");
					}
					Long.valueOf(c2c_sell_only_one).longValue();
				}
			}
			Object obj2 = this.sysparaService.find("c2c_nofinish_order_count_max");
			if (null != obj2) {
				if (nofinishOrderCount >= Long.valueOf(this.sysparaService.find("c2c_nofinish_order_count_max").getValue()).longValue()) {
					throw new BusinessException("用户未结束订单数量已达上限");
				}
			}
			
			// C2C用户下单是否需要基础认证（true:是，false:否）
			Object obj = this.sysparaService.find("c2c_order_need_kyc");
			if (null != obj) {
				if (!party.getKyc_authority() && "true".equals(this.sysparaService.find("c2c_order_need_kyc").getValue())) {
					resultObject.setCode("401");
					resultObject.setMsg("未实名认证，是否认证？");
					return resultObject;
				}
			}
			
			// C2C每日订单取消最大次数
			int orderCancelDayTimes = 0;			
			Map<String, Integer> map = (Map<String, Integer>) this.redisHandler.get(RedisKeys.C2C_ORDER_CANCEL_DAY_TIMES);
			if (null != map && null != map.get(partyId)) {
				orderCancelDayTimes = map.get(partyId);
			}			
			Object obj1 = this.sysparaService.find("c2c_order_cancel_day_times");
			if (null != obj1) {
				if (orderCancelDayTimes >= Integer.valueOf(this.sysparaService.find("c2c_order_cancel_day_times").getValue()).intValue()) {
					throw new BusinessException("今日取消订单次数太多了，请明日再试");
				}
			}
			
			C2cAdvert c2cAdvert = this.c2cAdvertService.get(c2c_advert_id);
			if (null == c2cAdvert) {
				throw new BusinessException("广告不存在");
			}
			
			C2cPaymentMethod method = this.c2cPaymentMethodService.get(payment_method_id);
			if (null == method) {
				throw new BusinessException("支付方式不存在");
			}
			
			if (StringUtils.isEmptyString(order_type) || !Arrays.asList("by_amount", "by_num").contains(order_type)) {
				throw new BusinessException("订单类型不正确");
			}
			
			if (C2cOrder.ORDER_TYPE_BY_AMOUNT.equals(order_type)) {
				// 按支付金额支付				
				if (StringUtils.isEmptyString(amount) || !StringUtils.isDouble(amount) || Double.valueOf(amount).doubleValue() <= 0) {
					throw new BusinessException("支付金额不正确");
				}
				coin_amount = "0";
			} else {
				// 按币种数量支付								
				if (StringUtils.isEmptyString(coin_amount) || !StringUtils.isDouble(coin_amount) || Double.valueOf(coin_amount).doubleValue() <= 0) {
					throw new BusinessException("币种数量不正确");
				}
				amount = "0";
			}			

			Map<String, Object> data = new HashMap<String, Object>();
			
			C2cOrder c2cOrder = new C2cOrder();
			c2cOrder.setId(ApplicationUtil.getCurrentTimeUUID());
			c2cOrder.setPartyId(partyId);
			c2cOrder.setC2cUserId(c2cAdvert.getC2cUserId());
			c2cOrder.setC2cAdvertId(c2c_advert_id);
			c2cOrder.setPaymentMethodId(payment_method_id);
			c2cOrder.setOrderType(order_type);
			c2cOrder.setOrderNo(orderNo);
			// 0未付款
			c2cOrder.setState("0");
			c2cOrder.setAmount(StringUtils.isEmptyString(amount) ? 0 : Double.valueOf(amount).doubleValue());
			c2cOrder.setCoinAmount(StringUtils.isEmptyString(coin_amount) ? 0 : Double.valueOf(coin_amount).doubleValue());
			c2cOrder.setRemark(remark);
			String remarks = "name:"+party.getUsername()+"code:"+party.getUsercode()+"direction:"+direction+"orderNo:"+orderNo;
			this.c2cOrderService.saveOpen(c2cOrder,remarks);
			data.put("order_no", c2cOrder.getOrderNo());
			resultObject.setData(data);
		} catch (BusinessException e) {
			logger.error("用户"+direction+"执行异常1当前用户uid:"+party.getUsercode()+"当前用户名:"+party.getUsername()+"生成的订单号:"+orderNo);
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
			logger.error("error:"+e.getMessage());
		} catch (Throwable t) {
			logger.error("用户"+direction+"执行异常2当前用户uid:"+party.getUsercode()+"当前用户名:"+party.getUsername()+"生成的订单号:"+orderNo);
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}  finally {
			if (lock) {
				C2cLock.remove(partyId);
			}
		}

		return resultObject;
	}
	
	// =================================================================================
	
	/**
	 * 快捷区下单：获取最优价格的广告
	 * 
	 * order_type 订单类型：by_amount按支付金额/by_num按币种数量
	 * amount 支付金额
	 * coin_amount 币种数量
	 * direction 买卖方式：buy买/sell卖
	 * currency 支付币种
	 * symbol 上架币种
	 */
	@RequestMapping(action + "get_best_price_advert.action")
	public Object get_best_price_advert(HttpServletRequest request) {
		String order_type = request.getParameter("order_type");
		String amount = request.getParameter("amount");
		String coin_amount = request.getParameter("coin_amount");
		String direction = request.getParameter("direction");
		String currency = request.getParameter("currency");
		String symbol = request.getParameter("symbol");
		String language = request.getParameter("language");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		try {
			
			String partyId = this.getLoginPartyId();
			if (null == partyId) {
				throw new BusinessException("请重新登录");
			}
			
			Party party = this.partyService.cachePartyBy(partyId, false);
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				throw new BusinessException("无权限");
			}
			
			if (!party.getEnabled()) {
				resultObject.setCode("506");
				resultObject.setMsg("用户已锁定");
				return resultObject;
			}
			
			String error = this.verifOpen(direction, currency, symbol, order_type);
			if (StringUtils.isNotEmpty(error)) {
				throw new BusinessException(error);
			}
						
			if (C2cOrder.ORDER_TYPE_BY_AMOUNT.equals(order_type)) {
				// 按支付金额支付				
				if (StringUtils.isEmptyString(amount) || !StringUtils.isDouble(amount) || Double.valueOf(amount).doubleValue() <= 0) {
					throw new BusinessException("支付金额不正确");
				}
				coin_amount = "0";
			} else {
				// 按币种数量支付								
				if (StringUtils.isEmptyString(coin_amount) || !StringUtils.isDouble(coin_amount) || Double.valueOf(coin_amount).doubleValue() <= 0) {
					throw new BusinessException("币种数量不正确");
				}
				amount = "0";
			}
			
			double amount_double = StringUtils.isEmptyString(amount) ? 0 : Double.valueOf(amount).doubleValue();
			double coin_amount_double = StringUtils.isEmptyString(coin_amount) ? 0 : Double.valueOf(coin_amount).doubleValue();
			
			Map<String, C2cPaymentMethod> cpmMap = new HashMap<String, C2cPaymentMethod>();
			List<C2cPaymentMethod> cpmList = new ArrayList<C2cPaymentMethod>();

			// 获取用户所有支付方式  id做key
			cpmMap = this.c2cPaymentMethodService.getByPartyId(partyId);
			if (null == cpmMap) {
				cpmMap = new HashMap<String, C2cPaymentMethod>();
			}
			for (String id : cpmMap.keySet()) {
				C2cPaymentMethod cpm = cpmMap.get(id);
				if (null != cpm) {
					cpmList.add(cpm);
				}
			}
			
			Map<String, Map<String, Object>> retMap = this.c2cAdvertService.getBestPriceAdvert(currency, symbol, direction, order_type, amount_double, coin_amount_double, cpmList);
			
			List<Map<String, Object>> retList = new ArrayList<Map<String, Object>>();
			for (String pmi : retMap.keySet()) {
				Map<String, Object> map = retMap.get(pmi);
				if (null != map) {
					
					if (null != map.get("method_name") && StringUtils.isNotEmpty(map.get("method_name").toString())) {
						C2cTranslate trans = this.c2cTranslateService.get(map.get("method_name").toString(), language);
						if (null != trans) {
							map.put("method_name", trans.getTranslate());
						}
					}
					
					retList.add(map);
				}
			}
			
			resultObject.setData(retList);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}

		return resultObject;
	}
	
	/**
	 * 快捷区下单：购买、出售，提交订单
	 * 
	 * safe_password 资金密码
	 * payment_method_id 用户选择的自己的支付方式ID
	 * order_type 订单类型：by_amount按支付金额/by_num按币种数量
	 * amount 支付金额
	 * coin_amount 币种数量
	 * direction 买卖方式：buy买/sell卖
	 * currency 支付币种
	 * symbol 上架币种
	 * remark 备注
	 */
	@RequestMapping(action + "open_quick_apply.action")
	public Object open_quick_apply(HttpServletRequest request) {
		String session_token = request.getParameter("session_token");
//		String safe_password = request.getParameter("safe_password");
		String payment_method_id = request.getParameter("payment_method_id");
		String order_type = request.getParameter("order_type");
		String amount = request.getParameter("amount");
		String coin_amount = request.getParameter("coin_amount");
		String direction = request.getParameter("direction");
		String currency = request.getParameter("currency");
		String symbol = request.getParameter("symbol");
		String remark = request.getParameter("remark");
		String c2c_advert_id = request.getParameter("c2c_advert_id");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		try {
			
			String partyId = this.getLoginPartyId();
			if (null == partyId) {
				throw new BusinessException("请重新登录");
			}
			
			Party party = this.partyService.cachePartyBy(partyId, false);
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				throw new BusinessException("无权限");
			}
			
//			if (!this.partyService.checkSafeword(safe_password, partyId)) {
//				throw new BusinessException("资金密码错误");
//			}
			
			Object object = this.sessionTokenService.cacheGet(session_token);
			this.sessionTokenService.del(session_token);
			if (null == object || !partyId.equals((String) object)) {
				throw new BusinessException("请稍后再试");
			}
			
			if (!party.getEnabled()) {
				resultObject.setCode("506");
				resultObject.setMsg("用户已锁定");
				return resultObject;
			}
			
			String error = this.verifOpen(direction, currency, symbol, order_type);
			if (StringUtils.isNotEmpty(error)) {
				throw new BusinessException(error);
			}
			
			if (StringUtils.isEmptyString(c2c_advert_id)) {
				throw new BusinessException("广告不存在");
			}
			
			if (C2cOrder.ORDER_TYPE_BY_AMOUNT.equals(order_type)) {
				// 按支付金额支付				
				if (StringUtils.isEmptyString(amount) || !StringUtils.isDouble(amount) || Double.valueOf(amount).doubleValue() <= 0) {
					throw new BusinessException("支付金额不正确");
				}
				coin_amount = "0";
			} else {
				// 按币种数量支付								
				if (StringUtils.isEmptyString(coin_amount) || !StringUtils.isDouble(coin_amount) || Double.valueOf(coin_amount).doubleValue() <= 0) {
					throw new BusinessException("币种数量不正确");
				}
				amount = "0";
			}
					
			// C2C用户未结束订单最大数量
			Long nofinishOrderCount = this.c2cOrderService.getNofinishOrderCount(partyId,direction);
			Object obj2 = this.sysparaService.find("c2c_nofinish_order_count_max");
			if (null != obj2) {
				if (nofinishOrderCount >= Long.valueOf(this.sysparaService.find("c2c_nofinish_order_count_max").getValue()).longValue()) {
					throw new BusinessException("用户未结束订单数量已达上限");
				}
			}
			
			// C2C用户下单是否需要基础认证（true:是，false:否）
			Object obj = this.sysparaService.find("c2c_order_need_kyc");
			if (null != obj) {
				if (!party.getKyc_authority() && "true".equals(this.sysparaService.find("c2c_order_need_kyc").getValue())) {
					resultObject.setCode("401");
					resultObject.setMsg("未实名认证，是否认证？");
					return resultObject;
				}
			}
			
			// C2C每日订单取消最大次数
			int orderCancelDayTimes = 0;			
			Map<String, Integer> map = (Map<String, Integer>) this.redisHandler.get(RedisKeys.C2C_ORDER_CANCEL_DAY_TIMES);
			if (null != map && null != map.get(partyId)) {
				orderCancelDayTimes = map.get(partyId);
			}			
			Object obj1 = this.sysparaService.find("c2c_order_cancel_day_times");
			if (null != obj1) {
				if (orderCancelDayTimes >= Integer.valueOf(this.sysparaService.find("c2c_order_cancel_day_times").getValue()).intValue()) {
					throw new BusinessException("今日取消订单次数太多了，请明日再试");
				}
			}
			
			C2cOrder c2cOrder = new C2cOrder();
			c2cOrder.setId(ApplicationUtil.getCurrentTimeUUID());
			c2cOrder.setPartyId(partyId);
			c2cOrder.setPaymentMethodId(payment_method_id);
			c2cOrder.setOrderType(order_type);
			c2cOrder.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
			// 0未付款
			c2cOrder.setState("0");
			c2cOrder.setAmount(StringUtils.isEmptyString(amount) ? 0 : Double.valueOf(amount).doubleValue());
			c2cOrder.setCoinAmount(StringUtils.isEmptyString(coin_amount) ? 0 : Double.valueOf(coin_amount).doubleValue());
			c2cOrder.setDirection(direction);
			c2cOrder.setCurrency(currency);
			c2cOrder.setSymbol(symbol);
			c2cOrder.setRemark(remark);
			c2cOrder.setC2cAdvertId(c2c_advert_id);

			this.c2cOrderService.saveOpenQuickApply(c2cOrder);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("order_no", c2cOrder.getOrderNo());
			
			resultObject.setData(data);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}

		return resultObject;
	}
	
	/**
	 * 支付完成
	 */
	@RequestMapping(action + "pay_finish.action")
	public Object pay_finish(HttpServletRequest request) {
		String order_no = request.getParameter("order_no");
		String safe_password = request.getParameter("safe_password");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		boolean lock = false;
		
		try {
			
			String partyId = this.getLoginPartyId();
			if (null == partyId) {
				throw new BusinessException("请重新登录");
			}
			
			Party party = this.partyService.cachePartyBy(partyId, false);
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				throw new BusinessException("无权限");
			}
			
			if (!this.partyService.checkSafeword(safe_password, partyId)) {
				throw new BusinessException("资金密码错误");
			}
			
			if (!party.getEnabled()) {
				resultObject.setCode("506");
				resultObject.setMsg("用户已锁定");
				return resultObject;
			}
			
			C2cOrder order = this.c2cOrderService.get(order_no);
			if (null == order) {
				throw new BusinessException("订单不存在");
			}
			
			if (partyId.equals(order.getPartyId())) {
				// 用户操作
				if (!"buy".equals(order.getDirection())) {
					throw new BusinessException("用户不能支付卖单");
				}
			} else if (partyId.equals(order.getC2cUserPartyId())) {
				// 承兑商操作
				if (!"sell".equals(order.getDirection())) {
					throw new BusinessException("承兑商不能支付买单");
				}
			} else {
				throw new BusinessException("无权限");
			}

			if (!"0".equals(order.getState())) {
				throw new BusinessException("订单不是未付款状态");
			}
			
			if (!C2cOrderLock.add(order_no)) {
				throw new BusinessException(1, "请稍后再试");
			}
			
			lock = true;
			
			order.setState("1");
			order.setPayTime(new Date());
			
			this.c2cOrderService.update(order);
			
			this.c2cOrderService.c2cSendMessageByState(order, "1");

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		} finally {
			if (lock) {
				ThreadUtils.sleep(100);
				C2cOrderLock.remove(order_no);
			}
		}

		return resultObject;
	}
	
	/**
	 * 取消订单
	 */
	@RequestMapping(action + "order_cancel.action")
	public Object order_cancel(HttpServletRequest request) {
		String order_no = request.getParameter("order_no");
		String remark = request.getParameter("remark");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		boolean lock = false;
		
		try {
			
			String partyId = this.getLoginPartyId();
			if (null == partyId) {
				throw new BusinessException("请重新登录");
			}
			
			Party party = this.partyService.cachePartyBy(partyId, false);
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				throw new BusinessException("无权限");
			}
			
			if (!party.getEnabled()) {
				resultObject.setCode("506");
				resultObject.setMsg("用户已锁定");
				return resultObject;
			}
			
			C2cOrder order = this.c2cOrderService.get(order_no);
			if (null == order || !order.getPartyId().equals(this.getLoginPartyId())) {
				throw new BusinessException("订单不存在");
			}
			
			if (!C2cOrderLock.add(order_no)) {
				throw new BusinessException(1, "请稍后再试");
			}
			
			lock = true;
						
			if (StringUtils.isEmptyString(remark)) {
				throw new BusinessException("请选择取消理由");
			}
			
			order.setRemark("订单号:"+order.getOrderNo()+"用户手动取消订单:"+remark);
			
			// 用户不能取消卖单，承兑商不能取消买单			
			if (partyId.equals(order.getPartyId())) {
				// 用户操作
				if (!"buy".equals(order.getDirection())) {
					throw new BusinessException("用户不能取消卖单");
				}
				
				this.c2cOrderService.saveOrderCancel(order, "user");
				
			} else if (partyId.equals(order.getC2cUserPartyId())) {
				// 承兑商操作
				if (!"sell".equals(order.getDirection())) {
					throw new BusinessException("承兑商不能取消买单");
				}
				
				this.c2cOrderService.saveOrderCancel(order, "c2c_user");
				
			} else {
				throw new BusinessException("无权限");
			}
						
		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		} finally {
			if (lock) {
				ThreadUtils.sleep(100);
				C2cOrderLock.remove(order_no);
			}
		}

		return resultObject;
	}
	
	/**
	 * 订单放行
	 */
	@RequestMapping(action + "order_pass.action")
	public Object order_pass(HttpServletRequest request) {
		String order_no = request.getParameter("order_no");
		String safe_password = request.getParameter("safe_password");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		boolean lock = false;
		
		try {
			
			String partyId = this.getLoginPartyId();
			if (null == partyId) {
				throw new BusinessException("请重新登录");
			}
			
			Party party = this.partyService.cachePartyBy(partyId, false);
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				throw new BusinessException("无权限");
			}
			
			if (!C2cOrderLock.add(order_no)) {
				throw new BusinessException(1, "请稍后再试");
			}
			
			lock = true;
			
			if (!this.partyService.checkSafeword(safe_password, partyId)) {
				throw new BusinessException("资金密码错误");
			}
			
			if (!party.getEnabled()) {
				resultObject.setCode("506");
				resultObject.setMsg("用户已锁定");
				return resultObject;
			}
			
			C2cOrder order = this.c2cOrderService.get(order_no);
			if (null == order || !order.getPartyId().equals(this.getLoginPartyId())) {
				throw new BusinessException("订单不存在");
			}
			if ("0".equals(order.getState())) {
				throw new BusinessException("待付款的订单无法放行");
			}
			if ("3".equals(order.getState())) {
				throw new BusinessException("订单已完成，无法放行");
			}
			if ("4".equals(order.getState())) {
				throw new BusinessException("订单已取消，无法放行");
			}
			
			this.c2cOrderService.saveOrderPass(order);
			
//			PassDelayThread lockDelayThread = new PassDelayThread(order, this.c2cOrderService);
//			Thread t = new Thread(lockDelayThread);
//			t.start();
			
		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		} finally {
			if (lock) {
				ThreadUtils.sleep(100);
				C2cOrderLock.remove(order_no);
			}
		}

		return resultObject;
	}
	
	/**
	 * 获取 用户订单 列表
	 */
	@RequestMapping(action + "list.action")
	public Object list(HttpServletRequest request) {
		String page_no = request.getParameter("page_no");
		String direction = request.getParameter("direction");
		String state = request.getParameter("state");
		String startTime = request.getParameter("startTime");
		String endTime = request.getParameter("endTime");
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		try {
			
			String partyId = this.getLoginPartyId();
			if (null == partyId) {
				throw new BusinessException("请重新登录");
			}
			
			if (StringUtils.isNullOrEmpty(page_no)) {
				page_no = "1";
			}
			if (!StringUtils.isInteger(page_no)) {
				throw new BusinessException("页码不是整数");
			}
			if (Integer.valueOf(page_no).intValue() <= 0) {
				throw new BusinessException("页码不能小于等于0");
			}

			int page_no_int = Integer.valueOf(page_no).intValue();

			if (StringUtils.isNotEmpty(direction) && !Arrays.asList("buy", "sell").contains(direction)) {
				throw new BusinessException("买卖方式不正确");
			}

			if (StringUtils.isNotEmpty(state) && !Arrays.asList("0", "1", "2", "3", "4", "5").contains(state)) {
				throw new BusinessException("订单状态不正确");
			}

			Page page = this.c2cOrderService.pagedQuery(page_no_int, 20, direction, state, partyId, false,startTime,endTime);
			if (null == page) {
				resultObject.setData(new ArrayList<Map<String, Object>>());
			} else {
				
				for (Map<String, Object> map : (List<Map<String, Object>>) page.getElements()) {
					
					if (null == map.get("c2c_user_head_img")) {
						map.put("c2c_user_head_img", "");
					} else {
						String headImg = map.get("c2c_user_head_img").toString();
						map.put("c2c_user_head_img", Constants.WEB_URL + "/public/showimg!showImg.action?imagePath=" + headImg);
					}
				}
				
				List<String> nos = new ArrayList<String>();
				for (Map<String, Object> map : (List<Map<String, Object>>) page.getElements()) {
					nos.add(map.get("order_no").toString());
				}
				
				Map<String, Integer> unreadMsgs = this.otcOnlineChatMessageService.unreadMsgsApi(nos);
				for (Map<String, Object> map : (List<Map<String, Object>>) page.getElements()) {
					String orderNo = map.get("order_no").toString();
					if (unreadMsgs.containsKey(orderNo)) {
						map.put("unread_msg", unreadMsgs.get(orderNo));
					}
				}
				
				resultObject.setData((List<Map<String, Object>>) page.getElements());
			}

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}

		return resultObject;
	}
	
	/**
	 * 获取 订单 详情
	 */
	@RequestMapping(action + "get.action")
	public Object get(HttpServletRequest request) {
		String order_no = request.getParameter("order_no");
		String language = request.getParameter("language");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		try {
			
			C2cOrder c2cOrder = this.c2cOrderService.get(order_no);
			if (null == c2cOrder) {
				throw new BusinessException("订单不存在");
			}
			
			List<String> nos = new ArrayList<String>();
			nos.add(c2cOrder.getOrderNo());
			
			Map<String, Integer> unreadMsgs = this.otcOnlineChatMessageService.unreadMsgsApi(nos);
			Integer unreadMsg = unreadMsgs.get(c2cOrder.getOrderNo());
			if (null == unreadMsg) {
				c2cOrder.setUnreadMsg(0);
			} else {
				c2cOrder.setUnreadMsg(unreadMsg.intValue());
			}
			
			if (StringUtils.isNotEmpty(c2cOrder.getC2cUserHeadImg())) {
				String path = Constants.WEB_URL + "/public/showimg!showImg.action?imagePath=" + c2cOrder.getC2cUserHeadImg();
				c2cOrder.setC2cUserHeadImg(path);
			}
			
			if (StringUtils.isNotEmpty(c2cOrder.getMethodImg())) {
				String path = Constants.WEB_URL + "/public/showimg!showImg.action?imagePath=" + c2cOrder.getMethodImg();
				c2cOrder.setMethodImg(path);
			}
			
			// 多语言
			c2cOrder = this.c2cTranslateService.translateOrder(c2cOrder, language);
			
			long nowTimestamp = (new Date()).getTime();
			long createTimestamp = c2cOrder.getCreateTime().getTime();
			long autoCancelSeconds = 0;
			long remainSeconds = 0;
			
			if ("0".equals(c2cOrder.getState())) {
				autoCancelSeconds = c2cOrder.getExpireTime() * 60 * 1000 - (nowTimestamp - createTimestamp);
				remainSeconds = c2cOrder.getExpireTime() * 60 * 1000 * 2 - (nowTimestamp - createTimestamp);
			} else if ("1".equals(c2cOrder.getState())) {
				long payTimestamp = c2cOrder.getPayTime().getTime();
				autoCancelSeconds = c2cOrder.getExpireTime() * 60 * 1000 - (nowTimestamp - createTimestamp);
				remainSeconds = c2cOrder.getExpireTime() * 60 * 1000 - (nowTimestamp - payTimestamp);
			}
			
			c2cOrder.setAutoCancelTimeRemain((int) (autoCancelSeconds <= 0 ? 0 : autoCancelSeconds / 1000));
			c2cOrder.setExpireTimeRemain((int) (remainSeconds <= 0 ? 0 : remainSeconds / 1000));

			resultObject.setData(c2cOrder);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}

		return resultObject;
	}

	private String verifOpen(String direction, String currency, String symbol, String order_type) {
		
		if (StringUtils.isEmptyString(direction) || !Arrays.asList("buy", "sell").contains(direction)) {
			return "买卖方式不正确";
		}				
		
		Map<String, String> currencyMap = this.c2cAdvertService.getCurrencyMap();
		Map<String, String> symbolMap = this.c2cAdvertService.getSymbolMap();		
		if (null == currencyMap || !currencyMap.containsKey(currency)) {
			return "支付币种不正确";
		}		
		if (null == symbolMap || !symbolMap.containsKey(symbol)) {
			return "上架币种不正确";
		}
				
		if (StringUtils.isEmptyString(order_type) || !Arrays.asList("by_amount", "by_num").contains(order_type)) {
			throw new BusinessException("订单类型不正确");
		}
		
		return null;
	}
	
//	public class PassDelayThread implements Runnable {
//		
//		private C2cOrderService c2cOrderService;
//		private C2cOrder order;
//
//		public void run() {
//			
//			try {
//				
//				while (true) {
//					if (C2cOrderLock.add(order.getOrderNo())) {
//						this.c2cOrderService.saveOrderPass(order);
//						// 处理完退出
//						break;
//					}
//					ThreadUtils.sleep(200);
//				}
//
//			} catch (Throwable t) {
//				logger.error("error:", t);
//			} finally {
//				C2cOrderLock.remove(order.getOrderNo());
//			}
//
//		}
//
//		public PassDelayThread(C2cOrder order, C2cOrderService c2cOrderService) {
//			this.order = order;
//			this.c2cOrderService = c2cOrderService;
//		}
//
//	}
	
}