package project.web.api;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
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.util.DateUtils;
import kernel.util.ImageVerificationCodeUtil;
import kernel.util.ImageVerificationEndecrypt;
import kernel.util.StringUtils;
import kernel.util.ThreadUtils;
import kernel.util.UUIDGenerator;
import kernel.web.BaseAction;
import kernel.web.ResultObject;
import project.Constants;
import project.ddos.IpMenuService;
import project.log.Log;
import project.log.LogService;
import project.party.PartyService;
import project.party.model.Party;
import project.party.model.UserRecom;
import project.party.recom.UserRecomService;
import project.syspara.Syspara;
import project.syspara.SysparaService;
import project.user.LocalNormalReg;
import project.user.LocalUserService;
import project.user.QRGenerateService;
import project.user.UserService;
import project.user.captcha.GeetestService;
import project.user.idcode.IdentifyingCodeTimeWindowService;
import project.user.kyc.Kyc;
import project.user.kyc.KycHighLevel;
import project.user.kyc.KycHighLevelService;
import project.user.kyc.KycService;
import project.user.token.TokenService;
import security.SecUser;
import security.internal.SecUserService;
import util.IpUtil;
import util.LockFilter;
import util.RegexUtil;
import util.Strings;

@RestController
@CrossOrigin
public class LocalUserController extends BaseAction {
	
	private Logger logger = LoggerFactory.getLogger(LocalUserController.class);
	
	@Autowired
	private PartyService partyService;
	@Autowired
	private QRGenerateService qRGenerateService;
	@Autowired
	private KycService kycService;
	@Autowired
	private KycHighLevelService kycHighLevelService;
	@Autowired
	private SysparaService sysparaService;
	@Autowired
	private UserService userService;
	@Autowired
	private LocalUserService localUserService;
	@Autowired
	private SecUserService secUserService;
	@Autowired
	private LogService logService;
	@Autowired
	protected TokenService tokenService;
	@Autowired
	private IpMenuService ipMenuService;
	@Autowired
	private IdentifyingCodeTimeWindowService identifyingCodeTimeWindowService;
	@Autowired
	private GeetestService geetestService;
	@Autowired
	private UserRecomService userRecomService;
	@Autowired
	protected JdbcTemplate jdbcTemplate;
	
	private final String action = "api/localuser!";
	
	/**
	 * 交易所用户注册（Geetest滑动图片验证方式）
	 * 备注：可以用，但是目前没用到
	 */
	@RequestMapping(action + "register_username_geetest.action")
	public Object register_username_geetest(HttpServletRequest request) {
		
		String username = request.getParameter("username").replace(" ", "");
		String password = request.getParameter("password").replace(" ", "");
		String safeword = request.getParameter("safeword").replace(" ", "");
		String usercode = request.getParameter("usercode");
		
		String challenge = request.getParameter("geetest_challenge");
		String validate = request.getParameter("geetest_validate");
		String seccode = request.getParameter("geetest_seccode");
		String gt_server_status = request.getParameter("gt_server_status");

		ResultObject resultObject = new ResultObject();
		
		boolean lock = false;
		
		try {			
			
			if (!LockFilter.add(username)) {
				throw new BusinessException("重复提交");
			}
			
			lock = true;
			
			String error = this.validateParamUsername(username, password);
			if (!StringUtils.isNullOrEmpty(error)) {
				throw new BusinessException(error);
			}
			
			if (StringUtils.isEmptyString(safeword)) {
				throw new BusinessException("资金密码不能为空");
			}
			if (safeword.length() != 6 || !Strings.isNumber(safeword)) {
				throw new BusinessException("资金密码不符合设定");
			}
			
			Syspara geetest_open = this.sysparaService.find("geetest_open");
			if (null != geetest_open && true == geetest_open.getBoolean()) {
				
				HashMap<String, String> retGeetest = this.geetestVerif(challenge, validate, seccode, gt_server_status);
				if ("fail".equals(retGeetest.get("status"))) {
					throw new BusinessException("图形验证错误，请重新再试");
				}
			}
			
			LocalNormalReg reg = new LocalNormalReg();
			reg.setUsername(username);
			reg.setPassword(password);
			reg.setReco_usercode(usercode);
			reg.setSafeword(safeword);
			this.localUserService.saveRegisterUsername(reg);

			SecUser secUser = this.secUserService.findUserByLoginName(username);
			
			Log log = new Log();
			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户无验证码注册,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(secUser.getPartyId());
			log.setUsername(username);
			this.logService.saveAsyn(log);

			// 注册完直接登录返回token
			String token = this.tokenService.savePut(secUser.getPartyId(),secUser.getUsername());
			this.userService.online(secUser.getPartyId());
			this.ipMenuService.saveIpMenuWhite(this.getIp());
			
			Party party = this.partyService.cachePartyBy(secUser.getPartyId(), true);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("token", token);
			data.put("username", secUser.getUsername());
			data.put("usercode", party.getUsercode());
			
			party.setLogin_ip(this.getIp(getRequest()));
			this.partyService.update(party);
			
			resultObject.setData(data);
			
		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			this.error = ("[ERROR] " + t.getMessage());
			resultObject.setCode("1");
			resultObject.setMsg(this.error);
		} finally {
			if (lock) {
				LockFilter.remove(username);
			}
		}

		return resultObject;
	}
	
	/**
	 * 交易所用户注册（验证码方式）
	 * 备注：可以用，但是目前没用到
	 */
	@RequestMapping(action + "register_username.action")
	public Object register_username(HttpServletRequest request) {
		
		String username = request.getParameter("username").replace(" ", "");
		String password = request.getParameter("password").replace(" ", "");
		String safeword = request.getParameter("safeword").replace(" ", "");
		String usercode = request.getParameter("usercode");
		String code = request.getParameter("code");
		String key = request.getParameter("key");

		ResultObject resultObject = new ResultObject();
		String error = "";
		boolean lock = false;
		try {
			
			if (!LockFilter.add(username)) {
				resultObject.setCode("1");
				resultObject.setMsg("重复提交");
				return resultObject;
			}
			lock = true;
			error = validateParamUsername(username, password);
			if (!StringUtils.isNullOrEmpty(error)) {
				resultObject.setCode("1");
				resultObject.setMsg(error);
				return resultObject;
			}
			
			if (StringUtils.isEmptyString(safeword)) {
				throw new BusinessException("资金密码不能为空");
			}
			if (safeword.length() != 6 || !Strings.isNumber(safeword)) {
				throw new BusinessException("资金密码不符合设定");
			}
			
			boolean register_image_code_button = sysparaService.find("register_image_code_button").getBoolean();
			if (register_image_code_button) {
				if (StringUtils.isEmptyString(code) || StringUtils.isEmptyString(key)) {
					throw new BusinessException("验证码不能为空");
				} else {
					String decryptCode = ImageVerificationEndecrypt.decryptDES(code, key + "key");
					if (!decryptCode.equalsIgnoreCase(userService.cacheImageCode(key))) {
						logger.info("ip:{" + this.getIp() + "},图片验证码不正确,paramcode:{" + decryptCode + "},truecode:{"
								+ userService.cacheImageCode(key) + "}");
						throw new BusinessException("验证码错误");
					}
				}
			}
			LocalNormalReg reg = new LocalNormalReg();
			reg.setUsername(username);
			reg.setPassword(password);
			reg.setReco_usercode(usercode);
			reg.setSafeword(safeword);

			this.localUserService.saveRegisterUsername(reg);

			SecUser secUser = secUserService.findUserByLoginName(username);
			Log log = new Log();

			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户无验证码注册,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(secUser.getPartyId());
			log.setUsername(username);
			logService.saveAsyn(log);

			// 注册完直接登录返回token
			String token = tokenService.savePut(secUser.getPartyId(),secUser.getUsername());
			userService.online(secUser.getPartyId());
			ipMenuService.saveIpMenuWhite(this.getIp());
			Party party = this.partyService.cachePartyBy(secUser.getPartyId(), true);
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("token", token);
			data.put("username", secUser.getUsername());
			data.put("usercode", party.getUsercode());
			party.setLogin_ip(this.getIp(getRequest()));
			this.partyService.update(party);
			resultObject.setData(data);
		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			this.error = ("[ERROR] " + t.getMessage());
			resultObject.setCode("1");
			resultObject.setMsg(this.error);
		} finally {
			if (lock) {
				LockFilter.remove(username);
			}
		}

		return resultObject;
	}

	/**
	 * 手机/邮箱注册接口
	 */
	@RequestMapping(action + "register.action")
	public Object register(HttpServletRequest request) {
		String username = request.getParameter("username").replace(" ", "");
		String password = request.getParameter("password").replace(" ", "");
		String safeword = request.getParameter("safeword").replace(" ", "");
		String verifcode = request.getParameter("verifcode");
		String usercode = request.getParameter("usercode");
		// 注册类型：1/手机；2/邮箱；
		String type = request.getParameter("type");
		
		ResultObject resultObject = new ResultObject();
		
		boolean lock = false;
		
		try {

			if (!LockFilter.add(username)) {
				throw new BusinessException("重复提交");
			}
			
			lock = true;
			
			String error = this.validateParam(username, verifcode, password, type);
			if (!StringUtils.isNullOrEmpty(error)) {
				throw new BusinessException(error);
			}
			
			if (StringUtils.isEmptyString(safeword)) {
				throw new BusinessException("资金密码不能为空");
			}
			if (safeword.length() != 6 || !Strings.isNumber(safeword)) {
				throw new BusinessException("资金密码不符合设定");
			}
			
			LocalNormalReg reg = new LocalNormalReg();
			reg.setUsername(username);
			reg.setPassword(password);
			reg.setSafeword(safeword);
			reg.setReco_usercode(usercode);
			reg.setIdentifying_code(verifcode);

			this.localUserService.saveRegister(reg, type);

			SecUser secUser = this.secUserService.findUserByLoginName(username);
			
			project.log.Log log = new project.log.Log();
			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户注册,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(secUser.getPartyId());
			log.setUsername(username);
			this.logService.saveAsyn(log);

			// 注册完直接登录返回token
			String token = this.tokenService.savePut(secUser.getPartyId(),secUser.getUsername());
			
			this.userService.online(secUser.getPartyId());
			this.ipMenuService.saveIpMenuWhite(this.getIp());
			
			Party party = this.partyService.cachePartyBy(secUser.getPartyId(), true);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("token", token);
			data.put("username", secUser.getUsername());
			data.put("usercode", party.getUsercode());
			
			party.setLogin_ip(this.getIp(getRequest()));
			this.partyService.update(party);
			
			ThreadUtils.sleep(500);

			resultObject.setData(data);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			resultObject.setCode("1");
			resultObject.setMsg("[ERROR] " + t.getMessage());
		} finally {
			if (lock) {
				LockFilter.remove(username);
			}
		}
		
		return resultObject;
	}

	/**
	 * 手机/邮箱/用户名注册（无验证码）
	 */
	@RequestMapping(action + "registerNoVerifcode.action")
	public Object registerNoVerifcode(HttpServletRequest request) {
		String username = request.getParameter("username").replace(" ", "");
		String password = request.getParameter("password").replace(" ", "");
		String re_password = request.getParameter("re_password").replace(" ", "");
		String usercode = request.getParameter("usercode");
		String phone = request.getParameter("phone");
		// 注册类型：1/手机；2/邮箱；3/用户名；
		String type = request.getParameter("type");
		
		ResultObject resultObject = new ResultObject();
		
		boolean lock = false;
		
		try {

			if (!LockFilter.add(username)) {
				throw new BusinessException("重复提交");
			}
			
			lock = true;
			
			if (StringUtils.isEmptyString(username)) {
				throw new BusinessException("用户名不能为空");
			}

			if (StringUtils.isEmptyString(password)) {
				throw new BusinessException("登录密码不能为空");
			}

			if (StringUtils.isEmptyString(re_password)) {
				throw new BusinessException("密码确认不能为空");
			}

			if (password.length() < 6 || password.length() > 12 || re_password.length() < 6 || re_password.length() > 12) {
				throw new BusinessException("密码必须6-12位");
			}

			if (!password.equals(re_password)) {
				throw new BusinessException("两次输入的密码不相同");
			}
			
			if (StringUtils.isEmptyString(type) || !Arrays.asList("1", "2", "3").contains(type)) {
				throw new BusinessException("类型不能为空");
			}
			
			// 手机
			if ("1".equals(type)) {
				if(!isValidPhone(username)) {
					throw new BusinessException("not a valid Phone!");
				}
			}
			
			// 邮箱
			if ("2".equals(type)) {
				if(!isValidEmail(username)) {
					throw new BusinessException("not a valid Email!");
				}
			}
			
			// 用户名
			if ("3".equals(type)) {
				if(!isValidUsername(username)) {
					throw new BusinessException("not a valid username!");
				}
			}
			
			String ip = this.getIp();
			if (!IpUtil.isCorrectIpRegular(ip)) {
				logger.error("校验IP不合法,参数{}", ip);
				throw new BusinessException("校验IP不合法");
			}

			LocalNormalReg reg = new LocalNormalReg();
			reg.setUsername(username);
			reg.setPassword(password);
			reg.setSafeword("000000");
			reg.setReco_usercode(usercode);

			SecUser  secUser = this.secUserService.findUserByLoginName(username);
			
			project.log.Log log = new project.log.Log();
			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户注册,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(secUser.getPartyId());
			log.setUsername(username);
			this.logService.saveAsyn(log);


			// 注册完直接登录返回token
			String token = this.tokenService.savePut(secUser.getPartyId(),secUser.getUsername());
			
			this.userService.online(secUser.getPartyId());
			this.ipMenuService.saveIpMenuWhite(this.getIp());
			
			Party party = this.partyService.cachePartyBy(secUser.getPartyId(), true);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("token", token);
			data.put("username", secUser.getUsername());
			data.put("usercode", party.getUsercode());
			
			party.setLogin_ip(this.getIp(getRequest()));
			this.partyService.update(party);
			
			ThreadUtils.sleep(500);

			resultObject.setData(data);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			resultObject.setCode("1");
			resultObject.setMsg("[ERROR] " + t.getMessage());
		} finally {
			if (lock) {
				LockFilter.remove(username);
			}
		}
		
		return resultObject;
	}
	
	/**
	 * 体验用户注册
	 */
	@RequestMapping(action + "registerTest.action")
	public Object registerTest(HttpServletRequest request) {
		String username = request.getParameter("username").replace(" ", "");
		String password = request.getParameter("password").replace(" ", "");
		String re_password = request.getParameter("re_password").replace(" ", "");
		String usercode = request.getParameter("usercode");
		//体验用户默认是账号类型
		String type = "3";
		
		ResultObject resultObject = new ResultObject();
		
		boolean lock = false;
		
		try {

			if (!LockFilter.add(username)) {
				throw new BusinessException("重复提交");
			}
			
			lock = true;
			
			if (StringUtils.isEmptyString(username)) {
				throw new BusinessException("用户名不能为空");
			}

			if (StringUtils.isEmptyString(password)) {
				throw new BusinessException("登录密码不能为空");
			}

			if (StringUtils.isEmptyString(re_password)) {
				throw new BusinessException("密码确认不能为空");
			}			

			if (password.length() < 6 || password.length() > 12 || re_password.length() < 6 || re_password.length() > 12) {
				throw new BusinessException("密码必须6-12位");
			}

			if (!password.equals(re_password)) {
				throw new BusinessException("两次输入的密码不相同");
			}			
			
			// 用户名
			if ("3".equals(type)) {
				if(!isValidUsername(username)) {
					throw new BusinessException("not a valid username!");
				}
			}
			
			String ip = this.getIp();
			if (!IpUtil.isCorrectIpRegular(ip)) {
				logger.error("校验IP不合法,参数{}", ip);
				throw new BusinessException("校验IP不合法");
			}

			LocalNormalReg reg = new LocalNormalReg();
			reg.setUsername(username);
			reg.setPassword(password);
			reg.setSafeword("000000");
			reg.setReco_usercode(usercode);

			this.localUserService.saveRegisterTest(reg, type);

			SecUser secUser = this.secUserService.findUserByLoginName(username);
			
			project.log.Log log = new project.log.Log();
			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户注册,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(secUser.getPartyId());
			log.setUsername(username);
			this.logService.saveAsyn(log);

			// 注册完直接登录返回token
			String token = this.tokenService.savePut(secUser.getPartyId(),secUser.getUsername());
			
			this.userService.online(secUser.getPartyId());
			this.ipMenuService.saveIpMenuWhite(this.getIp());
			
			Party party = this.partyService.cachePartyBy(secUser.getPartyId(), true);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("token", token);
			data.put("username", secUser.getUsername());
			data.put("usercode", party.getUsercode());
			
			party.setLogin_ip(this.getIp(getRequest()));
			this.partyService.update(party);
			
			ThreadUtils.sleep(500);

			resultObject.setData(data);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			resultObject.setCode("1");
			resultObject.setMsg("[ERROR] " + t.getMessage());
		} finally {
			if (lock) {
				LockFilter.remove(username);
			}
		}
		
		return resultObject;
	}


	/**
	 * 手机/邮箱/用户名注册（无验证码，填资金密码）
	 */
	@RequestMapping(action + "registerNoVerifcodeSafeword.action")
	public Object registerNoVerifcodeSafeword(HttpServletRequest request) {
		String username = request.getParameter("username").replace(" ", "");
		String password = request.getParameter("password").replace(" ", "");
		String re_password = request.getParameter("re_password").replace(" ", "");
		String usercode = request.getParameter("usercode");
		// 注册类型：1/手机；2/邮箱；3/用户名；
		String type = request.getParameter("type");
		// 资金密码选填，不填默认 000000
		String safeword = request.getParameter("safeword").replace(" ", "");
		String re_safeword = request.getParameter("re_safeword").replace(" ", "");
		
		ResultObject resultObject = new ResultObject();
		
		boolean lock = false;
		
		try {

			if (!LockFilter.add(username)) {
				throw new BusinessException("重复提交");
			}
			
			lock = true;
			
			if (StringUtils.isEmptyString(username)) {
				throw new BusinessException("用户名不能为空");
			}

			if (StringUtils.isEmptyString(password)) {
				throw new BusinessException("登录密码不能为空");
			}

			if (StringUtils.isEmptyString(re_password)) {
				throw new BusinessException("密码确认不能为空");
			}

			if (password.length() < 6 || password.length() > 12 || re_password.length() < 6 || re_password.length() > 12) {
				throw new BusinessException("密码必须6-12位");
			}

			if (!password.equals(re_password)) {
				throw new BusinessException("两次输入的密码不相同");
			}
			
			if (StringUtils.isEmptyString(safeword)) {
				safeword = "000000";
			}
			if (StringUtils.isEmptyString(re_safeword)) {
				re_safeword = "000000";
			}
			if (safeword.length() != 6 || !Strings.isNumber(safeword)) {
				throw new BusinessException("资金密码不符合设定");
			}

			if (!safeword.equals(re_safeword)) {
				throw new BusinessException("两次输入的资金密码不相同");
			}
			
			if (StringUtils.isEmptyString(type) || !Arrays.asList("1", "2", "3").contains(type)) {
				throw new BusinessException("类型不能为空");
			}
			
			// 手机
			if ("1".equals(type)) {
				if(!isValidPhone(username)) {
					throw new BusinessException("not a valid Phone!");
				}
			}
			
			// 邮箱
			if ("2".equals(type)) {
				if(!isValidEmail(username)) {
					throw new BusinessException("not a valid Email!");
				}
			}
			
			// 用户名
			if ("3".equals(type)) {
				if(!isValidUsername(username)) {
					throw new BusinessException("not a valid username!");
				}
			}
			
			String ip = this.getIp();
			if (!IpUtil.isCorrectIpRegular(ip)) {
				logger.error("校验IP不合法,参数{}", ip);
				throw new BusinessException("校验IP不合法");
			}

			LocalNormalReg reg = new LocalNormalReg();
			reg.setUsername(username);
			reg.setPassword(password);			
			reg.setSafeword(safeword);
			reg.setReco_usercode(usercode);

			this.localUserService.saveRegisterNoVerifcode(reg, type);

			SecUser secUser = this.secUserService.findUserByLoginName(username);
			
			project.log.Log log = new project.log.Log();
			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户注册,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(secUser.getPartyId());
			log.setUsername(username);
			this.logService.saveAsyn(log);

			// 注册完直接登录返回token
			String token = this.tokenService.savePut(secUser.getPartyId(),secUser.getUsername());
			
			this.userService.online(secUser.getPartyId());
			this.ipMenuService.saveIpMenuWhite(this.getIp());
			
			Party party = this.partyService.cachePartyBy(secUser.getPartyId(), true);
			
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("token", token);
			data.put("username", secUser.getUsername());
			data.put("usercode", party.getUsercode());
			
			party.setLogin_ip(this.getIp(getRequest()));
			this.partyService.update(party);
			
			ThreadUtils.sleep(500);

			resultObject.setData(data);

		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			resultObject.setCode("1");
			resultObject.setMsg("[ERROR] " + t.getMessage());
		} finally {
			if (lock) {
				LockFilter.remove(username);
			}
		}
		
		return resultObject;
	}
	
	/**
	 * 绑定邮箱or手机-确认
	 */
	@RequestMapping(action + "bindEmailOrPhone.action")
	public Object bindEmailOrPhone(HttpServletRequest request) {
		String target = request.getParameter("target");
		String verifcode = request.getParameter("verifcode");
		String phone = request.getParameter("phone");
		String email = request.getParameter("email");
		
		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		
		try {
			
			// 验证码
			Party party = this.partyService.cachePartyBy(this.getLoginPartyId(), true);
			String key = target;
			String authcode = this.identifyingCodeTimeWindowService.getAuthCode(key);
			
			String bind_phone_email_ver = this.sysparaService.find("bind_phone_email_ver").getValue();

			// 不是演示用户 && 绑定手机邮箱号是否需要验证：1需要，2不需要
			if (!"GUEST".contentEquals(party.getRolename()) && "1".equals(bind_phone_email_ver)) {
				if ((null == authcode) || (!authcode.equals(verifcode))) {
					resultObject.setCode("1");
					resultObject.setMsg("验证码不正确");
					return resultObject;
				}
			}
			
			if (target.indexOf("@") == -1) {
				// 绑定手机				
//				this.localUserService.savePhone(target, String.valueOf(party.getId()));

	            // 电话绑定成功
	            party.setPhone(phone);
	            party.setPhone_authority(true);
				
				// 获取用户系统等级：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证； 4/用户高级认证；
				int userLevelSystem = this.partyService.getUserLevelByAuth(party);

				// 十进制个位表示系统级别：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证；4/用户高级认证；
				// 十进制十位表示自定义级别：对应在前端显示为如VIP1 VIP2等级、黄金 白银等级；
				// 如：级别11表示：新注册的前端显示为VIP1；
				int userLevel = party.getUser_level();
				party.setUser_level(((int) Math.floor(userLevel / 10)) * 10 + userLevelSystem);
				
				this.partyService.update(party);
				
			} else {
				// 绑定邮箱
//				this.localUserService.saveEmail(target, String.valueOf(party.getId()));
				
	            // 邮箱绑定成功
	            party.setEmail(email);
	            party.setEmail_authority(true);

	            // 获取用户等级 1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证； 4/用户高级认证；
	            party.setUser_level(this.partyService.getUserLevelByAuth(party));

	            this.partyService.update(party);
			}
			
		} 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 + "save_phone.action")
	public Object save_phone(HttpServletRequest request) {
		String phone = request.getParameter("phone");
		String verifcode = request.getParameter("verifcode");
		String usercode = request.getParameter("usercode");

		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}

		try {
			
//			if (StringUtils.isEmptyString(phone) || !Strings.isNumber(phone) || phone.length() > 15) {
			if (StringUtils.isEmptyString(phone) || phone.length() > 20) {
				throw new BusinessException("请填写正确的电话号码");
			}

			String loginPartyId = this.getLoginPartyId();
			Party party = this.partyService.cachePartyBy(loginPartyId, false);
			
			if (null != party.getPhone() && party.getPhone().equals(phone) && true == party.getPhone_authority()) {
				throw new BusinessException("电话号码已绑定");
			}
			
			Party partyPhone = this.partyService.findPartyByVerifiedPhone(phone);
			if (null != partyPhone && !partyPhone.getId().toString().equals(loginPartyId)) {
				throw new BusinessException("电话号码已绑定其他用户");
			}			
			
			String authcode = this.identifyingCodeTimeWindowService.getAuthCode(phone);
			
			String bind_phone_email_ver = this.sysparaService.find("bind_phone_email_ver").getValue();
			String bind_usercode = this.sysparaService.find("bind_usercode").getValue();

			// 如果是演示用户，则不判断验证码
			if (!"GUEST".contentEquals(party.getRolename())) {
				
				if ("1".contentEquals(bind_phone_email_ver)) {
										
					if (StringUtils.isEmptyString(verifcode)) {
						throw new BusinessException("请填写正确的验证码");
					}
										
					if ((null == authcode) || (!authcode.equals(verifcode))) {
						throw new BusinessException("验证码不正确");
					}
				}
				
				if ("1".contentEquals(bind_usercode)) {
										
					if (StringUtils.isEmptyString(usercode)) {
						throw new BusinessException("推荐码不正确");
					}
					
					Party party_reco = this.partyService.findPartyByUsercode(usercode);
					if (null == party_reco || !party_reco.getEnabled()) {
						throw new BusinessException("推荐人无权限推荐");
					}
					
					UserRecom userRecom = this.userRecomService.findByPartyId(party.getId());
					if (null == userRecom) {
						userRecom = new UserRecom();
						userRecom.setPartyId(party.getId());
						userRecom.setReco_id(party_reco.getId());
						this.userRecomService.save(userRecom);
					} else {
//						this.userRecomService.update(party.getId(), party_reco.getId());
					}
				}
			}

			// 电话绑定成功
			party.setPhone(phone);
			party.setPhone_authority(true);
			
			// 获取用户系统等级：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证； 4/用户高级认证；
			int userLevelSystem = this.partyService.getUserLevelByAuth(party);

			// 十进制个位表示系统级别：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证；4/用户高级认证；
			// 十进制十位表示自定义级别：对应在前端显示为如VIP1 VIP2等级、黄金 白银等级；
			// 如：级别11表示：新注册的前端显示为VIP1；
			int userLevel = party.getUser_level();
			party.setUser_level(((int) Math.floor(userLevel / 10)) * 10 + userLevelSystem);
			
			this.partyService.update(party);
			
		} 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 + "save_email.action")
	public Object save_email(HttpServletRequest request) {
		String email = request.getParameter("email");
		String verifcode = request.getParameter("verifcode");

		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}

		try {
			
			if (StringUtils.isEmptyString(email) || !Strings.isEmail(email)) {
				throw new BusinessException("请填写正确的邮箱地址");
			}

			String loginPartyId = this.getLoginPartyId();
			Party party = this.partyService.cachePartyBy(loginPartyId, false);
			
			if (null != party.getEmail() && party.getEmail().equals(email) && true == party.getEmail_authority()) {
				throw new BusinessException("邮箱已绑定");
			}
			
			Party partyEmail = this.partyService.findPartyByVerifiedEmail(email);
			if (null != partyEmail && !partyEmail.getId().toString().equals(loginPartyId)) {
				throw new BusinessException("邮箱已绑定其他用户");
			}
			
			String authcode = this.identifyingCodeTimeWindowService.getAuthCode(email);
			
			String bind_phone_email_ver = sysparaService.find("bind_phone_email_ver").getValue();

			// 如果是演示用户，则不判断验证码
			if (!"GUEST".contentEquals(party.getRolename())) {
				if ("1".contentEquals(bind_phone_email_ver)) {
					
					if (StringUtils.isEmptyString(verifcode)) {
						throw new BusinessException("请填写正确的验证码");
					}
					
					if ((null == authcode) || (!authcode.equals(verifcode))) {
						resultObject.setCode("1");
						resultObject.setMsg("验证码不正确");
						return resultObject;
					}
				}
			}

			// 邮箱绑定成功
			party.setEmail(email);
			party.setEmail_authority(true);
			
			// 获取用户系统等级：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证； 4/用户高级认证；
			int userLevelSystem = this.partyService.getUserLevelByAuth(party);

			// 十进制个位表示系统级别：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证；4/用户高级认证；
			// 十进制十位表示自定义级别：对应在前端显示为如VIP1 VIP2等级、黄金 白银等级；
			// 如：级别11表示：新注册的前端显示为VIP1；
			int userLevel = party.getUser_level();
			party.setUser_level(((int) Math.floor(userLevel / 10)) * 10 + userLevelSystem);
			
			this.partyService.update(party);
			Log log = new Log();
			log.setCategory(Constants.LOG_CATEGORY_SECURITY);
			log.setLog("用户邮箱绑定,ip[" + this.getIp(getRequest()) + "]");
			log.setPartyId(party.getId());
			log.setUsername(party.getUsername());
			logService.saveAsyn(log);
		} 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 + "getShare.action")
	public Object getShare() {

		ResultObject resultObject = new ResultObject();
		resultObject = readSecurityContextFromSession(resultObject);
		
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}
		try {
			Party party = this.partyService.cachePartyBy(getLoginPartyId(), false);
			// 关闭后，正式用户进入推广页面的时候，接口就不返回内容
			boolean member_promote_button = sysparaService.find("member_promote_button").getBoolean();

			Kyc kyc = kycService.get(party.getId().toString());
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("username", party.getUsername());
			map.put("userrole", party.getRolename());
			map.put("usercode", party.getUsercode());

			// 十进制个位表示系统级别：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证；4/用户高级认证；
			// 十进制十位表示自定义级别：对应在前端显示为如VIP1 VIP2等级、黄金 白银等级；
			// 如：级别11表示：新注册的前端显示为VIP1；
			map.put("user_level", (int) (party.getUser_level() % 10));
			map.put("user_level_custom", (int) Math.floor(party.getUser_level() / 10));
			map.put("user_level_custom_display", "VIP");
			String user_level_custom_config = this.sysparaService.find("user_level_custom_config").getValue();
			String[] levelArray = user_level_custom_config.split(",");
			for (int i = 0; i < levelArray.length; i++) {
				String[] level = levelArray[i].split("-");
				if (level[0].equals(map.get("user_level_custom").toString())) {
					map.put("user_level_custom_display", level[1]);
					break;
				}
			}

			String shareUrl = sysparaService.find("share_url").getValue();
			if (party.getKyc_authority())
				map.put("name", kyc.getName());
			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				map.put("test", true);

			} else {
				if (Constants.SECURITY_ROLE_MEMBER.equals(party.getRolename()) && !member_promote_button) {
					map.put("url", "");
					map.put("usercode_qr", "");
				} else {
					
					map.put("url", shareUrl + "/?usercode=" + party.getUsercode());
					/**
					 * 生成二维码图片
					 */
					qRGenerateService.generate(party.getUsercode());

					map.put("usercode_qr", shareUrl + "/public/showimg!showImg.action?imagePath=/qr/"
							+ party.getUsercode() + ".png");
				}
			}

			resultObject.setData(map);
		} catch (Exception e) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
		}
		return resultObject;
	}
	
	@RequestMapping(action + "getImageCode.action")
	public Object getImageCode() {
		ResultObject resultObject = new ResultObject();
		try {
			Map<String, Object> data = new HashMap<String, Object>();
			String key = UUIDGenerator.getUUID();
			ImageVerificationCodeUtil iv = new ImageVerificationCodeUtil();
			data.put("code", iv.getBase64());
			data.put("key", key);
			resultObject.setData(data);
			userService.putImageCode(key, iv.getText());
		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			logger.error("UserAction.register error ", t);
			resultObject.setCode("1");
			resultObject.setMsg("[ERROR] " + t.getMessage());
		}

		return resultObject;
	}

	/**
	 * 获取个人信息
	 */
	@RequestMapping(action + "get.action")
	public Object get(HttpServletRequest request) {

		ResultObject resultObject = new ResultObject();
		resultObject = this.readSecurityContextFromSession(resultObject);
		if (!"0".equals(resultObject.getCode())) {
			return resultObject;
		}

		try {

			String loginPartyId = this.getLoginPartyId();
			Party party = this.partyService.cachePartyBy(loginPartyId, false);
			SecUser secUser = this.secUserService.findUserByPartyId(loginPartyId);
			Kyc kyc = this.kycService.get(party.getId().toString());
			KycHighLevel kycHighLevel = this.kycHighLevelService.get(party.getId().toString());

			Map<String, Object> map = new HashMap<String, Object>();

			// 十进制个位表示系统级别：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证；4/用户高级认证；
			// 十进制十位表示自定义级别：对应在前端显示为如VIP1 VIP2等级、黄金 白银等级；
			// 如：级别11表示：新注册的前端显示为VIP1；
			map.put("user_level", (int) (party.getUser_level() % 10));
			map.put("user_level_custom", (int) Math.floor(party.getUser_level() / 10));	
			
			String projectType = this.sysparaService.find("project_type").getValue();
			if (StringUtils.isEmptyString(projectType)) {
				throw new BusinessException("系统参数错误");
			}
			if (projectType.equals("DAPP_EXCHANGE_BINANCE")
					|| projectType.equals("EXCHANGE_EASYCRYPTO")
					|| projectType.equals("DAPP_EXCHANGE_DAPPDEFIUSDT")) {
				map.put("user_level_custom_display", map.get("user_level_custom"));
			} else {
				map.put("user_level_custom_display", "VIP");
				String user_level_custom_config = this.sysparaService.find("user_level_custom_config").getValue();
				String[] levelArray = user_level_custom_config.split(",");
				for (int i = 0; i < levelArray.length; i++) {
					String[] level = levelArray[i].split("-");
					if (level[0].equals(map.get("user_level_custom").toString())) {
						map.put("user_level_custom_display", level[1]);	
						break;
					}
				}
			}

			map.put("username", party.getUsername());
			map.put("userrole", party.getRolename());
			map.put("usercode", party.getUsercode());
			map.put("phone", party.getPhone());
			map.put("phoneverif", party.getPhone_authority());
			map.put("email", party.getEmail());
			map.put("emailverif", party.getEmail_authority());
			map.put("google_auth_secret", secUser.getGoogle_auth_secret());
			map.put("googleverif", secUser.isGoogle_auth_bind());
			map.put("identityverif", party.getKyc_authority());
			map.put("advancedverif", party.isKyc_highlevel_authority());
			map.put("lastlogintime", party.getLast_loginTime());
			map.put("lastloginip", party.getLogin_ip());

			// 实名认证通过返回真实姓名
			if (party.getKyc_authority()) {
				map.put("name", kyc.getName());
			}
			
			if (null != kyc) {
				map.put("nationality", kyc.getNationality());
				map.put("kyc_status", kyc.getStatus());
			}
			
			if (null != kycHighLevel) {
				map.put("kyc_high_level_status", kycHighLevel.getStatus());
			}

			if (Constants.SECURITY_ROLE_TEST.equals(party.getRolename())) {
				map.put("test", true);
			} else {

				// 关闭后，正式用户进入推广页面的时候，接口就不返回内容
				boolean member_promote_button = this.sysparaService.find("member_promote_button").getBoolean();

				if (Constants.SECURITY_ROLE_MEMBER.equals(party.getRolename()) && !member_promote_button) {
					map.put("url", "");
					map.put("usercode_qr", "");
				} else {
					map.put("url", Constants.WEB_URL + "/register.html?usercode=" + party.getUsercode());
					// 生成二维码图片
					qRGenerateService.generate(party.getUsercode());
					map.put("usercode_qr", Constants.WEB_URL + "/public/showimg!showImg.action?imagePath=/qr/" + party.getUsercode() + ".png");
				}
			}
			
			UserRecom userRecom = this.userRecomService.findByPartyId(party.getId());
			if (null == userRecom || null == userRecom.getReco_id()) {
				map.put("usercode_parent", "");
			} else {
				Party party_reco = this.partyService.cachePartyBy(userRecom.getReco_id(), false);
				if (null == party_reco || null == party_reco.getUsercode() || StringUtils.isEmptyString(party_reco.getUsercode().toString())) {
					map.put("usercode_parent", "");
				} else {
					map.put("usercode_parent", party_reco.getUsercode());
				}
			}

			// 时间分隔点：新用户需要注册后填手机号和邀请码
			map.put("register_need_phone_usercode", false);
			String register_need_phone_usercode_time = this.sysparaService.find("register_need_phone_usercode_time").getValue();
			if (!StringUtils.isEmptyString(register_need_phone_usercode_time)) {
				
				// 结合盘：只有新用户需要注册后填手机号和邀请码
				Date dateFixed = DateUtils.toDate(register_need_phone_usercode_time, DateUtils.NORMAL_DATE_FORMAT);
				if (party.getCreateTime().getTime() > dateFixed.getTime()) {
					map.put("register_need_phone_usercode", true);
				} else {
					map.put("register_need_phone_usercode", false);
				}
			}
			
			// 承兑商类型：0不是承兑商/1后台承兑商/2用户承兑商
			map.put("c2c_user_type", party.getC2cUserType());
			
			resultObject.setData(map);
			
		} catch (BusinessException e) {
			resultObject.setCode("1");
			resultObject.setMsg(e.getMessage());
		} catch (Throwable t) {
			resultObject.setCode("1");
			resultObject.setMsg("程序错误");
			logger.error("error:", t);
		}

		return resultObject;
	}
	
	/**
	 * Geetest二次验证：返回验证结果, request表单中必须包含challenge, validate, seccode
	 */
	public HashMap<String, String> geetestVerif(String challenge, String validate, String seccode, String gt_server_status) throws UnsupportedEncodingException {
			
		if (StringUtils.isEmptyString(challenge) || StringUtils.isEmptyString(validate) 
				|| StringUtils.isEmptyString(seccode) || StringUtils.isEmptyString(gt_server_status)) {
			logger.info("ip:{" + this.getIp() + "},图形验证错误: "
					+ "challenge:{" + challenge + "},validate:{" + validate + "},seccode:{" + seccode + "},gt_server_status:{" + gt_server_status + "}");
			throw new BusinessException("图形验证错误，请重新再试");
		}
		
		// 自定义参数，可选择添加
		HashMap<String, String> param = new HashMap<String, String>();
		
		// 网站用户id
		param.put("user_id", "test");
		
		param.put("challenge", challenge);
		param.put("validate", validate);
		param.put("seccode", seccode);
		
		String geetest_id = this.sysparaService.find("geetest_id").getValue();
		String geetest_key = this.sysparaService.find("geetest_key").getValue();
		String new_failback = this.sysparaService.find("geetest_new_failback").getValue();
		if(StringUtils.isEmptyString(geetest_id) || StringUtils.isEmptyString(geetest_key) || StringUtils.isEmptyString(new_failback)) {
			throw new BusinessException("系统参数错误");
		}
		
		param.put("geetest_id", geetest_id);
		param.put("geetest_key", geetest_key);
		param.put("new_failback", new_failback);
		
		int gtResult = 0;
		if ("1".equals(gt_server_status)) {
			// gt-server正常，向gt-server进行二次验证	
			gtResult = this.geetestService.enhencedValidateRequest(param);
			System.out.println(gtResult);
		} else {
			// gt-server非正常情况下，进行failback模式验证					
			System.out.println("failback:use your own server captcha validate");
			gtResult = this.geetestService.failbackValidateRequest(param);
			System.out.println(gtResult);
		}
		
		HashMap<String, String> retMap = this.geetestService.preProcess(param);

		if (1 == gtResult) {
			// 验证成功
			retMap.put("status", "success");
			retMap.put("version", this.geetestService.getVersionInfo());
		} else {
			// 验证失败
			retMap.put("status", "fail");
			retMap.put("version", this.geetestService.getVersionInfo());
		}
		
		return retMap;
	}
	
	private String validateParamUsername(String username, String password) {

		if (StringUtils.isNullOrEmpty(username)) {
			return "用户名不能为空";
		}

		if (StringUtils.isNullOrEmpty(password)) {
			return "登录密码不能为空";
		}
		if (!RegexUtil.isUSername(username)) {
			return "用户名必须由数字和英文字母组成";
		}

		int min = 6;
		int max = 12;
		int max_name = 24;
		if (!RegexUtil.length(username, min, max_name)) {
			return "用户名不符合设定";
		}
		if (!RegexUtil.length(password, min, max)) {
			return "登陆密码长度不符合设定";
		}
//		if (!RegexUtil.isDigits(this.password)) {
//			// 只能输入数字
//			return "登陆密码不符合设定";
//		}
//		if (StringUtils.isEmptyString(this.safeword)) {
//			return "资金密码不能为空";
//		}
//		if (!StringUtils.isEmptyString(this.safeword) && !RegexUtil.length(this.safeword, min, max)) {
//			// return "资金密码长度限制" + min + "-" + max + "个字符";
//			return "资金密码长度不符合设定";
//		}
//		if (StringUtils.isEmptyString(this.safeword) && !RegexUtil.isDigits(this.safeword)) {
//			// 只能输入数字
//			return "资金密码不符合设定";
//		}

		return null;
	}
	
	// 手机号校验
	private boolean isValidPhone(String username) {
        Pattern p = Pattern.compile("[0-9]*");
        return p.matcher(username).matches();
	}
	
	// 邮箱校验
	private boolean isValidEmail(String username) {
        String regexPattern = "^(?=.{1,64}@)[A-Za-z0-9_-]+(\\.[A-Za-z0-9_-]+)*@"
                + "[^-][A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$";
        return Pattern.compile(regexPattern)
                .matcher(username)
                .matches();
	}
	
	// 用户名校验
	private boolean isValidUsername(String username) {
		String regex = "^[A-Za-z]\\w{5,29}";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(username);
        return m.matches();
	}
	
	private String validateParam(String username, String verifcode, String password, String type) {

		if (StringUtils.isEmptyString(username)) {
			return "用户名不能为空";
		}

//		if (StringUtils.isEmptyString(verifcode)) {
//			return "验证码不能为空";
//		}
		if (StringUtils.isEmptyString(password)) {
			return "登录密码不能为空";
		}
		int min = 6;
		int max = 12;
		if (!RegexUtil.length(password, min, max)) {
			return "登陆密码长度不符合设定";
		}
//		if (!RegexUtil.isDigits(this.password)) {
//			// 只能输入数字
//			return "登陆密码不符合设定";
//		}

//		if (StringUtils.isEmptyString(this.usercode)) {
//			return "推荐码不能为空";
//		}
		
		if (StringUtils.isEmptyString(type) || !Arrays.asList("1", "2").contains(type)) {
			return "类型不能为空";
		}
		
		return null;
	}
	
}