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

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.google.gson.Gson;
import com.qcloud.cos.model.COSObjectSummary;
import com.qcloud.cos.model.ObjectListing;
import com.yeshi.fanli.dao.mybatis.AccountDetailsMapper;
import com.yeshi.fanli.dao.mybatis.AccountMessageMapper;
import com.yeshi.fanli.dao.mybatis.BindingAccountMapper;
import com.yeshi.fanli.dao.mybatis.MoneyRecordMapper;
import com.yeshi.fanli.dao.mybatis.PidOrderMapper;
import com.yeshi.fanli.dao.mybatis.ThreeSaleMapper;
import com.yeshi.fanli.dao.mybatis.UserConnectHistoryMapper;
import com.yeshi.fanli.dao.mybatis.UserInfoMapper;
import com.yeshi.fanli.dao.mybatis.hongbao.HongBaoMapper;
import com.yeshi.fanli.dao.mybatis.order.OrderItemMapper;
import com.yeshi.fanli.dao.mybatis.order.OrderMapper;
import com.yeshi.fanli.entity.bus.user.AccountDetails;
import com.yeshi.fanli.entity.bus.user.AccountMessage;
import com.yeshi.fanli.entity.bus.user.BindingAccount;
import com.yeshi.fanli.entity.bus.user.HongBao;
import com.yeshi.fanli.entity.bus.user.LoginResult;
import com.yeshi.fanli.entity.bus.user.MoneyRecord;
import com.yeshi.fanli.entity.bus.user.Order;
import com.yeshi.fanli.entity.bus.user.OrderItem;
import com.yeshi.fanli.entity.bus.user.ThreeSale;
import com.yeshi.fanli.entity.bus.user.UserConnectHistory;
import com.yeshi.fanli.entity.bus.user.UserInfo;
import com.yeshi.fanli.entity.bus.user.WeiXinUser;
import com.yeshi.fanli.entity.taobao.PidOrder;
import com.yeshi.fanli.exception.UserAccountException;
import com.yeshi.fanli.log.LogHelper;
import com.yeshi.fanli.service.inter.hongbao.HongBaoService;
import com.yeshi.fanli.service.inter.msg.UserAccountMsgNotificationService;
import com.yeshi.fanli.service.inter.user.SpreadUserImgService;
import com.yeshi.fanli.service.inter.user.UserAccountService;
import com.yeshi.fanli.util.Constant;
import com.yeshi.fanli.util.FileUtil;
import com.yeshi.fanli.util.StringUtil;
import com.yeshi.fanli.util.TimeUtil;
import com.yeshi.fanli.util.factory.AccountDetailsFactory;
import com.yeshi.fanli.util.factory.msg.MsgAccountDetailFactory;
import com.yeshi.fanli.util.wx.WXLoginUtil;

import net.sf.json.JSONObject;

import org.yeshi.utils.JsonUtil;
import org.yeshi.utils.tencentcloud.COSManager;

@Service
public class UserAccountServiceImpl implements UserAccountService {

	@Resource
	private UserInfoMapper userInfoMapper;

	@Resource
	private BindingAccountMapper bindingAccountMapper;

	@Resource
	private UserConnectHistoryMapper userConnectHistoryMapper;

	@Resource
	private AccountDetailsMapper accountDetailsMapper;

	@Resource
	private HongBaoMapper hongBaoMapper;

	@Resource
	private OrderMapper orderMapper;

	@Resource
	private OrderItemMapper orderItemMapper;

	@Resource
	private ThreeSaleMapper threeSaleMapper;

	@Resource
	private PidOrderMapper pidOrderMapper;

	@Resource
	private HongBaoService hongBaoService;

	@Resource
	private AccountMessageMapper accountMessageMapper;
	@Resource
	private MoneyRecordMapper moneyRecordMapper;

	@Resource
	private SpreadUserImgService spreadUserImgService;

	@Resource
	private UserAccountMsgNotificationService userAccountMsgNotificationService;

	@Transactional
	@Override
	public LoginResult login(HttpServletRequest request, Boolean first, String appId, String code, String phone,
			UserInfo tbUserInfo, boolean wxinstall, int loginType) throws UserAccountException {

		JSONObject logInfo = new JSONObject();
		logInfo.put("appId", appId);
		logInfo.put("code", code);
		logInfo.put("phone", phone);
		if (tbUserInfo != null)
			logInfo.put("tbUserInfo", tbUserInfo.getId());
		logInfo.put("loginType", loginType);
		LogHelper.lgoinInfo(logInfo.toString());

		HttpSession session = request.getSession();
		if (first != null && first == true)
			session.removeAttribute("LAST_LOGIN_USER");
		// 会话中上次登录的用户
		if (wxinstall) {// 安装了微信的状态
			UserInfo lastUser = (UserInfo) session.getAttribute("LAST_LOGIN_USER");
			UserInfo userInfo = null;
			WeiXinUser weiXinUser = null;
			switch (loginType) {
			case 1:// 淘宝
				userInfo = getUserInfoByTaoBaoOpenId(appId, tbUserInfo.getOpenid());
				if (userInfo == null) {// 原先的账号不存在
					userInfo = new UserInfo();
					userInfo.setAppId(appId);
					userInfo.setTbName(tbUserInfo.getTbName());
					userInfo.setOpenid(tbUserInfo.getOpenid());
					userInfo.setTbPic(tbUserInfo.getTbPic());
					userInfo.setNickName(tbUserInfo.getNickName());
					userInfo.setPortrait(tbUserInfo.getPortrait());
					userInfo.setLoginType(loginType);
					session.setAttribute("LAST_LOGIN_USER", userInfo);
					// 需要微信登录
					return new LoginResult(LoginResult.TYPE_WX, userInfo);
				} else {// 原先的账号存在
					// 判定是否绑定了微信
					if (StringUtil.isNullOrEmpty(userInfo.getWxUnionId())) {// 没有绑定微信
						userInfo.setLoginType(loginType);
						session.setAttribute("LAST_LOGIN_USER", userInfo);
						// 需要微信登录
						return new LoginResult(LoginResult.TYPE_WX, userInfo);
					} else {// 绑定了微信
						updateLatestLoginTime(userInfo.getId());
						return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
					}
				}

			case 2:// 微信
					// 通过Code换取信息
				weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
				if (weiXinUser == null)
					throw new UserAccountException(1001, "无法获取到微信个人信息");
				LogHelper.test("微信授权用户信息：" + new Gson().toJson(weiXinUser));
				userInfo = getUserInfoByWXUnionId(appId, weiXinUser.getUnionid());
				// 直接用的微信登录
				if (lastUser == null) {
					if (userInfo != null) {
						// 使分销关系生效
						threeSaleMapper.effectThreeSale(userInfo.getId());
						// 更新头像与昵称
						UserInfo updateUserInfo = new UserInfo(userInfo.getId());
						updateUserInfo.setNickName(weiXinUser.getNickname());
						if (!StringUtil.isNullOrEmpty(weiXinUser.getHeadimgurl()))
							updateUserInfo.setPortrait(weiXinUser.getHeadimgurl());
						updateUserInfo.setWxPic(weiXinUser.getHeadimgurl());
						updateUserInfo.setWxName(weiXinUser.getNickname());
						// 设置登录时间与登录类型
						updateUserInfo.setLastLoginTime(System.currentTimeMillis());
						updateUserInfo.setLoginType(loginType);
						updateUserInfo.setLastLoginIp(request.getRemoteHost());

						userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
						// 删除邀请图片
						spreadUserImgService.deleteImgUrl(userInfo.getId());
						return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
					}
					userInfo = new UserInfo();
					userInfo.setPortrait(weiXinUser.getHeadimgurl());
					userInfo.setAppId(appId);
					userInfo.setNickName(weiXinUser.getNickname());
					userInfo.setWxName(weiXinUser.getNickname());
					userInfo.setWxOpenId(weiXinUser.getOpenid());
					userInfo.setWxUnionId(weiXinUser.getUnionid());
					userInfo.setWxPic(weiXinUser.getHeadimgurl());
					userInfo.setLastLoginTime(System.currentTimeMillis());
					userInfo.setLoginType(loginType);
					userInfo.setLastLoginIp(request.getRemoteHost());
					addUser(userInfo);

					return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
				} else {
					// 本会话采用过其他账号登录
					if (userInfo != null)// 微信账号存在
					{
						if (lastUser.getLoginType() == 2) {
							session.removeAttribute("LAST_LOGIN_USER");
							throw new UserAccountException(1002, "微信不能绑定微信");
						}
						if (lastUser.getLoginType() == 1 && !StringUtil.isNullOrEmpty(userInfo.getOpenid())) {
							session.removeAttribute("LAST_LOGIN_USER");
							throw new UserAccountException(1003, "该微信已经绑定了淘宝账号，请先解绑");
						}
						if (lastUser.getLoginType() == 3 && !StringUtil.isNullOrEmpty(userInfo.getPhone())) {
							session.removeAttribute("LAST_LOGIN_USER");
							throw new UserAccountException(1003, "该微信已经绑定了电话号码，请先解绑");
						}

						// 删除邀请图片
						spreadUserImgService.deleteImgUrl(userInfo.getId());
						// 还没有绑定同类型的账号

						// 两个账号没有同时有独立的UID
						if (lastUser.getId() == null || lastUser.getId() == 0
								|| lastUser.getId() == userInfo.getId().longValue()) {
							// 绑定关系
							UserInfo updateUserInfo = new UserInfo(userInfo.getId());

							if (!StringUtil.isNullOrEmpty(lastUser.getPhone())) {
								updateUserInfo.setPhone(lastUser.getPhone());
								userAccountMsgNotificationService.bindingSuccess(userInfo.getId(),
										MsgAccountDetailFactory.TYPE_PHONE);
							}
							if (!StringUtil.isNullOrEmpty(lastUser.getOpenid())) {
								updateUserInfo.setOpenid(lastUser.getOpenid());
								updateUserInfo.setTbName(lastUser.getTbName());
								updateUserInfo.setTbPic(lastUser.getTbPic());
								userAccountMsgNotificationService.bindingSuccess(userInfo.getId(),
										MsgAccountDetailFactory.TYPE_TB);
							}
							updateUserInfo.setLastLoginTime(System.currentTimeMillis());
							userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
							session.removeAttribute("LAST_LOGIN_USER");

							// 使分销关系生效
							threeSaleMapper.effectThreeSale(userInfo.getId());

							return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
						} else {// 两个账号拥有不同的UID
							// 询问是否打通
							// 暂存微信账号
							// session.setAttribute("WEIXIN_USERINFO",
							// userInfo);
							session.removeAttribute("LAST_LOGIN_USER");
							LoginResult result = new LoginResult(LoginResult.TYPE_CONNECT, lastUser);
							result.setMainUser(userInfo);
							result.setLessUser(lastUser);

							// 使分销关系生效
							threeSaleMapper.effectThreeSale(userInfo.getId());
							return result;
						}

					} else {// 微信账号不存在
						// 创建账号,绑定账号
						userInfo = new UserInfo();
						userInfo.setPortrait(weiXinUser.getHeadimgurl());
						userInfo.setAppId(appId);
						userInfo.setNickName(weiXinUser.getNickname());
						userInfo.setWxName(weiXinUser.getNickname());
						userInfo.setWxOpenId(weiXinUser.getOpenid());
						userInfo.setWxUnionId(weiXinUser.getUnionid());
						userInfo.setWxPic(weiXinUser.getHeadimgurl());
						if (!StringUtil.isNullOrEmpty(lastUser.getPhone()))
							userInfo.setPhone(lastUser.getPhone());

						if (!StringUtil.isNullOrEmpty(lastUser.getOpenid())) {
							userInfo.setOpenid(lastUser.getOpenid());
							userInfo.setTbName(lastUser.getTbName());
							userInfo.setTbPic(lastUser.getTbPic());
						}
						userInfo.setLastLoginTime(System.currentTimeMillis());
						userInfo.setLoginType(loginType);
						userInfo.setLastLoginIp(request.getRemoteHost());
						addUser(userInfo);
						session.removeAttribute("LAST_LOGIN_USER");
						return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
					}
				}
			case 3:// 手机号码
				userInfo = getUserInfoByPhone(appId, phone);
				if (userInfo == null) {// 原先的账号不存在
					userInfo = new UserInfo();
					userInfo.setAppId(appId);
					userInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
					userInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
					userInfo.setPhone(phone);
					userInfo.setLoginType(loginType);
					session.setAttribute("LAST_LOGIN_USER", userInfo);
					// 询问是否绑定微信
					return new LoginResult(LoginResult.TYPE_WX, userInfo);
				} else {// 原先的账号存在
					// 判定是否绑定了微信
					if (StringUtil.isNullOrEmpty(userInfo.getWxUnionId())) {// 没有绑定微信
						userInfo.setLoginType(loginType);
						session.setAttribute("LAST_LOGIN_USER", userInfo);
						// 需要微信登录
						return new LoginResult(LoginResult.TYPE_WX, userInfo);
					} else {// 绑定了微信
						updateLatestLoginTime(userInfo.getId());
						return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
					}
				}
			default:
				return null;
			}

		} else {// 没有安装微信
			LoginResult result = loginNoInstallWX(appId, code, phone, tbUserInfo, loginType);
			if (result.getType() == LoginResult.TYPE_CREATE)
				session.setAttribute("LAST_LOGIN_USER", result.getUser());
			return result;
		}
	}

	@Transactional
	@Override
	public LoginResult loginNoInstallWX(String appId, String code, String phone, UserInfo tbUserInfo, int loginType)
			throws UserAccountException {
		JSONObject logInfo = new JSONObject();
		logInfo.put("appId", appId);
		logInfo.put("code", code);
		logInfo.put("phone", phone);
		if (tbUserInfo != null)
			logInfo.put("tbUserInfo", tbUserInfo.getId());
		logInfo.put("loginType", loginType);
		LogHelper.lgoinInfo(logInfo.toString());

		UserInfo userInfo = null;
		WeiXinUser weiXinUser = null;
		switch (loginType) {
		case 1:// 淘宝
			userInfo = getUserInfoByTaoBaoOpenId(appId, tbUserInfo.getOpenid());
			break;
		case 2:// 微信
				// 通过Code换取信息
			weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
			if (weiXinUser == null)
				throw new UserAccountException(1001, "无法获取到微信个人信息");
			userInfo = getUserInfoByWXUnionId(appId, weiXinUser.getUnionid());
			break;
		case 3:// 手机号码
			userInfo = getUserInfoByPhone(appId, phone);
			break;
		}

		if (userInfo != null) {
			UserInfo updateUserInfo = new UserInfo(userInfo.getId());
			updateUserInfo.setLastLoginTime(System.currentTimeMillis());
			userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
			return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
		} else {// 询问是否创建用户
			userInfo = new UserInfo();
			userInfo.setAppId(appId);
			switch (loginType) {
			case 1:// 淘宝
				userInfo.setTbName(tbUserInfo.getNickName());
				userInfo.setTbPic(tbUserInfo.getPortrait());
				userInfo.setNickName(tbUserInfo.getNickName());
				userInfo.setPortrait(tbUserInfo.getPortrait());
				break;
			case 2:// 微信
				userInfo.setPortrait(weiXinUser.getHeadimgurl());
				userInfo.setNickName(weiXinUser.getNickname());
				userInfo.setWxName(weiXinUser.getNickname());
				userInfo.setWxOpenId(weiXinUser.getOpenid());
				userInfo.setWxUnionId(weiXinUser.getUnionid());
				userInfo.setWxPic(weiXinUser.getHeadimgurl());
				break;
			case 3:// 手机号码
					// 默认头像与昵称
				userInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
				userInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
				userInfo.setPhone(phone);
				break;
			}
			return new LoginResult(LoginResult.TYPE_CREATE, userInfo);
		}
	}

	@Override
	public void connectUsers(HttpSession session) throws UserAccountException {
		UserInfo mainUser = (UserInfo) session.getAttribute("WEIXIN_USERINFO");
		UserInfo lessUser = (UserInfo) session.getAttribute("LAST_LOGIN_USER");

		int lessUserLoginType = lessUser.getLoginType();

		if (mainUser == null || lessUser == null || mainUser.getId() == null || lessUser.getId() == null)
			throw new UserAccountException(30001, "缺少打通账号");

		mainUser = userInfoMapper.selectByPrimaryKeyForUpdate(mainUser.getId());
		lessUser = userInfoMapper.selectByPrimaryKeyForUpdate(lessUser.getId());

		session.removeAttribute("WEIXIN_USERINFO");
		session.removeAttribute("LAST_LOGIN_USER");

		if (mainUser == null || lessUser == null)
			throw new UserAccountException(30002, "缺少打通账号");

		// 判断是否有绑定相同类型的账号
		if (lessUserLoginType == 1) {// 次账号以淘宝登录
			if (!StringUtil.isNullOrEmpty(mainUser.getPhone()) && !StringUtil.isNullOrEmpty(lessUser.getPhone())
					&& !lessUser.getPhone().equalsIgnoreCase(mainUser.getPhone()))
				throw new UserAccountException(30003, "请先解除其中一个账号的手机绑定");

		} else if (lessUserLoginType == 3) {// 次账号以手机号登录
			if (!StringUtil.isNullOrEmpty(mainUser.getOpenid()) && !StringUtil.isNullOrEmpty(lessUser.getOpenid())
					&& !lessUser.getOpenid().equalsIgnoreCase(mainUser.getOpenid()))
				throw new UserAccountException(30003, "请先解除其中一个账号的淘宝绑定");
		}
		connectUsers(mainUser, lessUser);
	}

	@Transactional
	@Override
	public void connectUsers(UserInfo mainUser, UserInfo lessUser) throws UserAccountException {
		mainUser = userInfoMapper.selectByPrimaryKeyForUpdate(mainUser.getId());
		lessUser = userInfoMapper.selectByPrimaryKeyForUpdate(lessUser.getId());

		if (!StringUtil.isNullOrEmpty(mainUser.getOpenid()) && !StringUtil.isNullOrEmpty(lessUser.getOpenid()))
			throw new UserAccountException(9, "两个账号都绑定了淘宝，请解绑其中一个");

		if (!StringUtil.isNullOrEmpty(mainUser.getPhone()) && !StringUtil.isNullOrEmpty(lessUser.getPhone()))
			throw new UserAccountException(9, "两个账号都绑定了手机号码，请解绑其中一个");

		if (lessUser.getMyHongBao().compareTo(new BigDecimal("20")) >= 0
				&& mainUser.getMyHongBao().compareTo(new BigDecimal("20")) > 0)
			throw new UserAccountException(10, String.format("账户ID:%s 的资金超过20元，为保证资金安全请联系客服打通", lessUser.getId() + ""));

		// 判定是否绑定了同一支付宝
		List<BindingAccount> mainUserAccountList = bindingAccountMapper.selectByUid(mainUser.getId());
		if (mainUserAccountList != null)
			for (int i = 0; i < mainUserAccountList.size(); i++) {
				if (mainUserAccountList.get(i).getType() == BindingAccount.TYPE_WXPAY) {
					mainUserAccountList.remove(i);
					i--;
				}
			}
		List<BindingAccount> lessUserAccountList = bindingAccountMapper.selectByUid(lessUser.getId());
		if (lessUserAccountList != null)
			for (int i = 0; i < lessUserAccountList.size(); i++) {
				if (lessUserAccountList.get(i).getType() == BindingAccount.TYPE_WXPAY) {
					lessUserAccountList.remove(i);
					i--;
				}
			}
		// 有不同的支付宝账号
		boolean hasDiffrentAlipayAccount = false;
		if (mainUserAccountList != null && mainUserAccountList.size() > 0 && lessUserAccountList != null
				&& lessUserAccountList.size() > 0) {
			if (!mainUserAccountList.get(0).getAccount().equalsIgnoreCase(lessUserAccountList.get(0).getAccount()))
				hasDiffrentAlipayAccount = true;
		}

		if (hasDiffrentAlipayAccount)
			throw new UserAccountException(10, "两个账户都绑定了支付宝，请先解绑其中一个");

		// 判定是否有重叠的账号
		UserInfo updateUser = new UserInfo(mainUser.getId());
		if (!StringUtil.isNullOrEmpty(lessUser.getOpenid())) {
			updateUser.setOpenid(lessUser.getOpenid());
			updateUser.setTbName(lessUser.getTbName());
			updateUser.setTbPic(lessUser.getTbPic());
		}

		if (!StringUtil.isNullOrEmpty(lessUser.getPhone())) {
			updateUser.setPhone(lessUser.getPhone());
		}

		// 备份原来的用户信息
		String logUrl = backupUserImportantInfo(lessUser.getId());

		// 添加打通记录
		UserConnectHistory userConnectHistory = new UserConnectHistory();
		userConnectHistory.setCreateTime(new Date());
		userConnectHistory.setLessUser(lessUser);
		userConnectHistory.setMainUser(mainUser);
		userConnectHistory.setLogUrl(logUrl);
		userConnectHistoryMapper.insertSelective(userConnectHistory);

		userInfoMapper.updateByPrimaryKeySelective(updateUser);
		// 删除原来的账号
		UserInfo updateLessUser = new UserInfo(lessUser.getId());
		updateLessUser.setState(UserInfo.STATE_DELETE);
		updateLessUser.setStateDesc("账号被打通删除");
		userInfoMapper.updateByPrimaryKeySelective(updateLessUser);
		// 融合业务
		userInfoMapper.connectUser(mainUser.getId(), lessUser.getId());

		// 查询是否有多余的新人红包
		List<HongBao> list = hongBaoMapper.selectByUidAndType(mainUser.getId(), HongBao.TYPE_XINREN);
		int subCount = 0;
		int addCount = 0;
		for (HongBao hb : list) {
			if (hb.getMoney().compareTo(new BigDecimal(0)) > 0)
				addCount++;
			if (hb.getMoney().compareTo(new BigDecimal(0)) < 0)
				subCount++;
		}

		// 有2个或者2个以上的新人红包
		if (addCount - subCount > 1) {
			// 扣除一个新人红包
			AccountDetails accountDetails = new AccountDetails();
			accountDetails.setCreateTime(TimeUtil.getGernalTime(System.currentTimeMillis(), "yyyy-MM-dd HH:mm:ss"));
			accountDetails.setExtract(null);
			accountDetails.setMoney("-" + list.get(1).getMoney().toString());
			accountDetails.setOrderItem(null);
			accountDetails.setTitle(" 账号合并扣除重复新人红包");
			accountDetails.setType(AccountDetailsFactory.TUIKUAN);
			accountDetails.setUserInfo(mainUser);
			accountDetailsMapper.insertSelective(accountDetails);

			AccountMessage accountMessage = new AccountMessage();
			accountMessage.setContent(" 账号合并扣除重复新人红包" + list.get(1).getMoney().toString() + "元");
			accountMessage.setCreateTime(System.currentTimeMillis());
			accountMessage.setIsOpen(false);
			accountMessage.setSystemMsgId(0);
			accountMessage.setTitle(" 账号合并扣除重复新人红包");
			accountMessage.setUserInfo(mainUser);
			accountMessageMapper.insertSelective(accountMessage);

			userInfoMapper.subHongBaoByUid(mainUser.getId(), list.get(1).getMoney());

			HongBao hongBao = new HongBao(mainUser, new BigDecimal(0).subtract(list.get(1).getMoney()), null,
					HongBao.TYPE_XINREN, HongBao.STATE_YILINGQU, System.currentTimeMillis(), System.currentTimeMillis(),
					System.currentTimeMillis(), null, "账号合并扣除");

			hongBaoMapper.insertSelective(hongBao);

			MoneyRecord moneyRecord = new MoneyRecord(mainUser, hongBao, list.get(1).getMoney(), "账号合并扣除重复新人红包", "账号合并",
					System.currentTimeMillis(), 2);
			moneyRecordMapper.insertSelective(moneyRecord);
		}

		userAccountMsgNotificationService.connectSuccess(mainUser.getId(), lessUser.getId());
	}

	/**
	 * 根据系统与unionid寻找用户
	 * 
	 * @param appId
	 * @param unionId
	 * @return
	 */
	public UserInfo getUserInfoByWXUnionId(String appId, String unionId) throws UserAccountException {
		if (StringUtil.isNullOrEmpty(appId))
			throw new UserAccountException(1, "appId为空");
		if (StringUtil.isNullOrEmpty(unionId))
			throw new UserAccountException(2, "unionId为空");

		return userInfoMapper.getUserInfoByAppIdAndWXUnionId(appId, unionId);
	}

	/**
	 * 根据系统和淘宝的Openid寻找用户
	 * 
	 * @param appId
	 * @param openId
	 * @return
	 */
	public UserInfo getUserInfoByTaoBaoOpenId(String appId, String openId) throws UserAccountException {
		if (StringUtil.isNullOrEmpty(appId))
			throw new UserAccountException(1, "appId为空");
		if (StringUtil.isNullOrEmpty(openId))
			throw new UserAccountException(2, "openId为空");
		return userInfoMapper.getUserInfoByAppIdAndTaoBaoOpenId(appId, openId);
	}

	/**
	 * 根据系统和电话号码寻找用户
	 * 
	 * @param appId
	 * @param phone
	 * @return
	 */
	public UserInfo getUserInfoByPhone(String appId, String phone) throws UserAccountException {
		if (StringUtil.isNullOrEmpty(appId))
			throw new UserAccountException(1, "appId为空");
		if (StringUtil.isNullOrEmpty(phone))
			throw new UserAccountException(2, "phone为空");
		return userInfoMapper.getUserInfoByAppIdAndPhone(appId, phone);
	}

	private void updateLatestLoginTime(Long uid) {
		UserInfo userInfo = new UserInfo(uid);
		userInfo.setLastLoginTime(System.currentTimeMillis());
		userInfoMapper.updateByPrimaryKeySelective(userInfo);
	}

	@Override
	public void register(UserInfo userInfo) throws UserAccountException {
		if (!StringUtil.isNullOrEmpty(userInfo.getPhone())) {
			UserInfo user = getUserInfoByPhone(userInfo.getAppId(), userInfo.getPhone());
			if (user != null)
				throw new UserAccountException(50001, "电话号码已经被绑定");
		}

		if (!StringUtil.isNullOrEmpty(userInfo.getOpenid())) {
			UserInfo user = getUserInfoByTaoBaoOpenId(userInfo.getAppId(), userInfo.getOpenid());
			if (user != null)
				throw new UserAccountException(50002, "淘宝号已经被绑定");
		}

		if (!StringUtil.isNullOrEmpty(userInfo.getWxUnionId())) {
			UserInfo user = getUserInfoByWXUnionId(userInfo.getAppId(), userInfo.getWxUnionId());
			if (user != null)
				throw new UserAccountException(50003, "微信号已经被注册");
		}

		addUser(userInfo);
	}

	@Override
	public void addUser(UserInfo user) {
		Long maxUid = userInfoMapper.getMaxUid();
		if (maxUid == null)
			maxUid = 100000L;
		long dd = (long) (Math.random() * 100);
		if (dd == 0) {
			dd = 1;
		}
		long uid = maxUid + dd;
		user.setId(uid);
		user.setCreatetime(System.currentTimeMillis());
		user.setRank(0);
		if (StringUtil.isNullOrEmpty(user.getPortrait()))
			user.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());

		userInfoMapper.insertSelective(user);
		if (StringUtil.isNullOrEmpty(user.getNickName())) {
			UserInfo updateUserInfo = new UserInfo(user.getId());
			updateUserInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName() + user.getId());
			userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
		}

		// 添加新人红包
		hongBaoService.setNewUserHongBaoMyBatis(user, 1);
	}

	@Override
	public void updateUserSelective(UserInfo user) {
		userInfoMapper.updateByPrimaryKeySelective(user);
	}

	@Override
	public void bindPhone(Long uid, String phone) throws UserAccountException {
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		if (user == null)
			throw new UserAccountException(4, "用户不存在");

		if (!StringUtil.isNullOrEmpty(user.getPhone()))
			throw new UserAccountException(5, "当前账号已经绑定了手机号，请先解绑");

		UserInfo phoneUser = getUserInfoByPhone(user.getAppId(), phone);
		if (phoneUser != null)
			throw new UserAccountException(6, "当前电话号码已经被绑定");

		UserInfo update = new UserInfo(user.getId());
		update.setPhone(phone);
		userInfoMapper.updateByPrimaryKeySelective(update);
		userAccountMsgNotificationService.bindingSuccess(uid, MsgAccountDetailFactory.TYPE_PHONE);
	}

	@Override
	public void unBindPhone(Long uid, String phone) throws UserAccountException {
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		if (user == null)
			throw new UserAccountException(4, "用户不存在");

		if (StringUtil.isNullOrEmpty(user.getPhone()))
			throw new UserAccountException(4, "尚未绑定电话号码");

		if (!user.getPhone().equalsIgnoreCase(phone))
			throw new UserAccountException(4, "原绑定手机号输入错误");

		if (StringUtil.isNullOrEmpty(user.getWxUnionId()) && StringUtil.isNullOrEmpty(user.getOpenid()))
			throw new UserAccountException(5, "不能解除绑定");

		UserInfo updateUserInfo = new UserInfo(uid);
		updateUserInfo.setPhone("");
		userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
		userAccountMsgNotificationService.unBindingSuccess(uid, MsgAccountDetailFactory.TYPE_PHONE);
	}

	@Override
	public void bindTaoBao(Long uid, String tbOpenId, String tbNickName, String tbPortrait)
			throws UserAccountException {
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		if (user == null)
			throw new UserAccountException(4, "用户不存在");

		if (!StringUtil.isNullOrEmpty(user.getOpenid()))
			throw new UserAccountException(5, "当前账号已经绑定了淘宝，请先解绑");

		UserInfo taoBaoUser = getUserInfoByTaoBaoOpenId(user.getAppId(), tbOpenId);
		if (taoBaoUser != null)
			throw new UserAccountException(6, "当前淘宝号已经被绑定");
		UserInfo update = new UserInfo(user.getId());
		update.setOpenid(tbOpenId);
		update.setTbName(tbNickName);
		update.setTbPic(tbPortrait);
		// 如果没有绑定微信就以淘宝的头像和昵称作为用户的头像与昵称
		if (StringUtil.isNullOrEmpty(user.getWxUnionId())) {
			update.setNickName(tbNickName);
			update.setPortrait(tbPortrait);
		}
		userInfoMapper.updateByPrimaryKeySelective(update);

		userAccountMsgNotificationService.bindingSuccess(uid, MsgAccountDetailFactory.TYPE_TB);
	}

	@Override
	public void unBindTaoBao(Long uid) throws UserAccountException {
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		if (user == null)
			throw new UserAccountException(4, "用户不存在");
		if (StringUtil.isNullOrEmpty(user.getOpenid()))
			throw new UserAccountException(5, "当前账号尚未绑定淘宝");

		if (StringUtil.isNullOrEmpty(user.getWxUnionId()) && StringUtil.isNullOrEmpty(user.getPhone()))
			throw new UserAccountException(5, "不能接触绑定");

		UserInfo update = new UserInfo(user.getId());
		update.setOpenid("");
		update.setTbName("");
		update.setTbPic("");
		// 判断是否有微信绑定
		if (StringUtil.isNullOrEmpty(user.getWxUnionId())) {
			update.setNickName(Constant.systemCommonConfig.getDefaultNickName() + user.getId());
			update.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
		}

		userInfoMapper.updateByPrimaryKeySelective(update);

		userAccountMsgNotificationService.unBindingSuccess(uid, MsgAccountDetailFactory.TYPE_TB);
	}

	@Override
	public void changeWXBind(Long uid, String code) throws UserAccountException {
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		if (user == null)
			throw new UserAccountException(4, "用户不存在");
		WeiXinUser weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
		if (weiXinUser == null)
			throw new UserAccountException(10, "获取微信用户信息失败");
		if (weiXinUser.getUnionid().equalsIgnoreCase(user.getWxUnionId()))
			throw new UserAccountException(12, "亲，请登录其它微信号进行更换绑定");

		UserInfo newUser = getUserInfoByWXUnionId(user.getAppId(), weiXinUser.getUnionid());
		if (newUser != null)
			throw new UserAccountException(13, "亲，你要更换绑定的微信号已被其他账号绑定");

		UserInfo updateUserInfo = new UserInfo(uid);
		updateUserInfo.setWxName(weiXinUser.getNickname());
		updateUserInfo.setWxOpenId(weiXinUser.getOpenid());
		updateUserInfo.setWxPic(weiXinUser.getHeadimgurl());
		updateUserInfo.setWxUnionId(weiXinUser.getUnionid());
		updateUserInfo.setNickName(weiXinUser.getNickname());
		updateUserInfo.setPortrait(weiXinUser.getHeadimgurl());
		if (StringUtil.isNullOrEmpty(weiXinUser.getNickname())) {
			updateUserInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
		}

		if (StringUtil.isNullOrEmpty(weiXinUser.getHeadimgurl())) {
			updateUserInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
		}
		userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);

		userAccountMsgNotificationService.changeBindingSuccess(uid, MsgAccountDetailFactory.TYPE_WX);
	}

	@Override
	public String backupUserImportantInfo(Long uid) {

		String logPath = String.format(FileUtil.getCacheDir() + "/benfen_%s_" + uid + ".log",
				TimeUtil.getGernalTime(System.currentTimeMillis(), "yyyyMMddHHmmss"));

		// 备份用户信息
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);

		// 备份资金明细
		List<AccountDetails> accountDetailsList = accountDetailsMapper.selectByUid(uid);
		// 备份红包信息
		List<HongBao> hongBaoList = hongBaoMapper.selectByUid(uid);
		// 备份订单，子订单信息
		List<Order> orderList = orderMapper.selectByUid(uid);
		List<OrderItem> orderItemList = orderItemMapper.selectByUid(uid);

		// 备份邀请关系
		List<ThreeSale> threeSaleList = threeSaleMapper.selectByUid(uid);

		// 备份分享赚
		List<PidOrder> pidOrderList = pidOrderMapper.selectByUid(uid);

		FileWriter fw = null;
		try {
			// 设置为:True,表示写入的时候追加数据
			fw = new FileWriter(new File(logPath), true);

			fw.write("#UserInfo" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(user) + "\r\n");

			fw.write("#AccountDetails" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(accountDetailsList) + "\r\n");

			fw.write("#HongBao" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(hongBaoList) + "\r\n");

			fw.write("#Order" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(orderList) + "\r\n");

			fw.write("#OrderItem" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(orderItemList) + "\r\n");

			fw.write("#ThreeSale" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(threeSaleList) + "\r\n");

			fw.write("#PidOrder" + "\r\n");
			fw.write(JsonUtil.getSimpleGsonWithDate().toJson(pidOrderList) + "\r\n");

			fw.close();

			String logUrl = COSManager.getInstance()
					.uploadFile(new File(logPath), "beifen/" + new File(logPath).getName()).getUrl();
			return logUrl;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (new File(logPath).exists())
				new File(logPath).delete();
		}

		return null;
	}

	@Override
	public void clearUserPortrait(Long uid) {
		if (uid == null)
			return;
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		String prefix = String.format("/portrait/wx/%s_", user.getWxUnionId());
		ObjectListing list = COSManager.getInstance().getObjectList(prefix, null, 30);
		if (list != null && list.getObjectSummaries() != null)
			for (COSObjectSummary object : list.getObjectSummaries()) {
				if (user.getWxPic() != null && !user.getWxPic().contains(object.getKey())) {
					COSManager.getInstance().deleteFile(object.getKey());
				}
			}
	}

	@Override
	public String repairPortrait(Long uid) {
		if (uid == null)
			return null;
		UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
		if (user == null)
			return null;
		String prefix = String.format("/portrait/wx/%s_", user.getWxUnionId());
		ObjectListing list = COSManager.getInstance().getObjectList(prefix, null, 30);
		// 查询头像文件是否还存在
		boolean exist = false;
		if (list != null && list.getObjectSummaries() != null)
			for (COSObjectSummary object : list.getObjectSummaries()) {
				if (user.getPortrait().contains(object.getKey())) {
					exist = true;
					break;
				}
			}

		if (!exist && list.getObjectSummaries() != null && list.getObjectSummaries().size() > 0) {
			COSObjectSummary object = list.getObjectSummaries().get(list.getObjectSummaries().size() - 1);
			String portrait = String.format("https://%s.file.myqcloud.com/%s", object.getBucketName(), object.getKey());
			if (!StringUtil.isNullOrEmpty(portrait)) {
				UserInfo updateUser = new UserInfo(uid);
				updateUser.setPortrait(portrait);
				userInfoMapper.updateByPrimaryKeySelective(updateUser);
				return portrait;
			}
		}

		return user.getPortrait();
	}

}