package com.xiaopeng.account.service.impl;

import com.xiaopeng.account.constant.I18nKeyConstant;
import com.xiaopeng.account.service.ISysPermissionService;
import com.xiaopeng.account.service.ISysUserService;
import com.xiaopeng.account.service.IXpOperationsUserService;
import com.xiaopeng.api.dto.operation.UpdatePasswordDTO;
import com.xiaopeng.api.model.account.SysUser;
import com.xiaopeng.api.model.account.XpOperationsUser;
import com.xiaopeng.api.vo.account.LoginOperationUser;
import com.xiaopeng.api.vo.account.LoginUser;
import com.xiaopeng.common.core.constant.CacheConstants;
import com.xiaopeng.common.core.constant.Constants;
import com.xiaopeng.common.core.constant.UserConstants;
import com.xiaopeng.common.core.constant.VerificationCodeConstants;
import com.xiaopeng.common.core.enums.UserStatus;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.text.Convert;
import com.xiaopeng.common.core.utils.SensitiveDataCryptoUtil;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.utils.ip.IpUtils;
import com.xiaopeng.common.redis.service.RedisService;
import com.xiaopeng.common.security.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Set;

/**
 * 登录校验方法
 *
 * @author xiaopeng
 */
@Component
public class SysLoginService {

	@Autowired
	private SysPasswordService passwordService;
	
	@Autowired
	private SysRecordLogService recordLogService;
	
	@Autowired
	private RedisService redisService;

    @Resource
    private ISysPermissionService permissionService;

    @Resource
    private ISysUserService userService;
	@Resource
	private IXpOperationsUserService operationsUserService;


	/**
	 * 登录
	 */
	public LoginUser login(String username, String password, HttpServletRequest request) {
		username = username.trim();
		// 查询用户信息
        SysUser user = userService.selectUserByUserName(username);
        if (StringUtils.isNull(user)) {
            throw new ServiceException("帐号不存在或已被删除", I18nKeyConstant.ACCOUNT_NOT_EXISTS);
        }
        // 角色集合
        Set<String> roles = permissionService.getRolePermission(user);
        // 权限集合
		Set<String> menuPermission = permissionService.getMenuPermission(user);
		LoginUser userInfo = new LoginUser();
		userInfo.setSysUser(user);
		userInfo.setRoles(roles);
		userInfo.setPermissions(menuPermission);

		if (StringUtils.isNull(user)) {
			recordLogService.recordLogininfor(request, null, username, Constants.LOGIN_FAIL_STATUS, "登录用户不存在");
			throw new ServiceException("用户名/密码错误", I18nKeyConstant.LOGIN_USERNAME_PASSWORD);
		}

		// 用户名或密码为空 错误
		if (StringUtils.isAnyBlank(username, password)) {
			recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "用户/密码必须填写");
			throw new ServiceException("用户/密码必须填写", I18nKeyConstant.LOGIN_USERNAME_PASSWORD_NOT_BLANK);
		}
		// 密码如果不在指定范围内 错误
		// if (password.length() < UserConstants.PASSWORD_MIN_LENGTH
		// 		|| password.length() > UserConstants.PASSWORD_MAX_LENGTH) {
		// 	recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "用户密码不在指定范围");
		// 	throw new ServiceException("用户密码不在指定范围", I18nKeyConstant.LOGIN_PASSWORD_NOT_VALID);
		// }
		// 用户名不在指定范围内 错误
		if (username.length() < UserConstants.USERNAME_MIN_LENGTH
				|| username.length() > UserConstants.USERNAME_MAX_LENGTH) {
			recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "用户名不在指定范围");
			throw new ServiceException("用户名不在指定范围",I18nKeyConstant.LOGIN_USERNAME_NOT_VALID);
		}
		// IP黑名单校验
		String blackStr = Convert.toStr(redisService.getCacheObject(CacheConstants.SYS_LOGIN_BLACKIPLIST));
		if (IpUtils.isMatchedIp(blackStr, IpUtils.getIpAddr())) {
			recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "很遗憾，访问IP已被列入系统黑名单");
			throw new ServiceException("很遗憾，访问IP已被列入系统黑名单", I18nKeyConstant.LOGIN_BLACK_LIST);
		}

		if (user.getDeleted()) {
			recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "对不起，您的账号已被删除");
			throw new ServiceException("对不起，您的账号：" + username + " 已被删除");
		}
		if (Integer.valueOf("1").equals(user.getStatus())) {
			recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "用户已停用，请联系管理员");
			throw new ServiceException("您的账号：" + username + " 已禁用", I18nKeyConstant.LOGIN_ACCOUNT_DISABLED, new Object[]{username});
		}
		passwordService.validate(user, password, request);
		// recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_SUCCESS_STATUS, "登录成功");
		return userInfo;
	}

    /**
     * 登录
     */
    public LoginUser login(String username, HttpServletRequest request) {
        username = username.trim();
        // 查询用户信息
        SysUser user = userService.selectUserByUserName(username);
        if (StringUtils.isNull(user)) {
            throw new ServiceException("帐号不存在或已被删除", I18nKeyConstant.ACCOUNT_NOT_EXISTS);
        }
        // 角色集合
        Set<String> roles = permissionService.getRolePermission(user);
        // 权限集合
        Set<String> menuPermission = permissionService.getMenuPermission(user);
        LoginUser userInfo = new LoginUser();
        userInfo.setSysUser(user);
        userInfo.setRoles(roles);
        userInfo.setPermissions(menuPermission);

        if (StringUtils.isNull(user)) {
            recordLogService.recordLogininfor(request, null, username, Constants.LOGIN_FAIL_STATUS, "登录用户不存在");
            throw new ServiceException("用户名/密码错误", I18nKeyConstant.LOGIN_USERNAME_PASSWORD);
        }

        // 用户名不在指定范围内 错误
        if (username.length() < UserConstants.USERNAME_MIN_LENGTH
                || username.length() > UserConstants.USERNAME_MAX_LENGTH) {
            recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "用户名不在指定范围");
            throw new ServiceException("用户名不在指定范围",I18nKeyConstant.LOGIN_USERNAME_NOT_VALID);
        }
        // IP黑名单校验
        String blackStr = Convert.toStr(redisService.getCacheObject(CacheConstants.SYS_LOGIN_BLACKIPLIST));
        if (IpUtils.isMatchedIp(blackStr, IpUtils.getIpAddr())) {
            recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "很遗憾，访问IP已被列入系统黑名单");
            throw new ServiceException("很遗憾，访问IP已被列入系统黑名单", I18nKeyConstant.LOGIN_BLACK_LIST);
        }

        if (user.getDeleted()) {
            recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "对不起，您的账号已被删除");
            throw new ServiceException("对不起，您的账号：" + username + " 已被删除");
        }
        if (Integer.valueOf("1").equals(user.getStatus())) {
            recordLogService.recordLogininfor(request, user.getId().intValue(), username, Constants.LOGIN_FAIL_STATUS, "用户已停用，请联系管理员");
            throw new ServiceException("您的账号：" + username + " 已禁用", I18nKeyConstant.LOGIN_ACCOUNT_DISABLED, new Object[]{username});
        }
        return userInfo;
    }

	public void logout(String loginName, HttpServletRequest request) {
		recordLogService.recordLogininfor(request, null, loginName, Constants.LOGIN_SUCCESS_STATUS, "退出成功");
	}
	
	/**
	 * 注册
	 */
	public void register(String username, String password, HttpServletRequest request) {
		// 用户名或密码为空 错误
		if (StringUtils.isAnyBlank(username, password)) {
			throw new ServiceException("用户/密码必须填写");
		}
		if (username.length() < UserConstants.USERNAME_MIN_LENGTH
				|| username.length() > UserConstants.USERNAME_MAX_LENGTH) {
			throw new ServiceException("账户长度必须在2到20个字符之间");
		}
		if (password.length() < UserConstants.PASSWORD_MIN_LENGTH
				|| password.length() > UserConstants.PASSWORD_MAX_LENGTH) {
			throw new ServiceException("密码长度必须在5到20个字符之间");
		}
		
		// 注册用户信息
		SysUser sysUser = new SysUser();
		sysUser.setNickName(username);
		sysUser.setPassword(SecurityUtils.encryptPassword(password));
//		R<?> registerResult = remoteUserService.registerUserInfo(sysUser, SecurityConstants.INNER);
//
//		if (R.FAIL == registerResult.getCode()) {
//			throw new ServiceException(registerResult.getMsg());
//		}
		recordLogService.recordLogininfor(request, sysUser.getId().intValue(), username, Constants.LOGIN_SUCCESS_STATUS, "注册成功");
	}

	public LoginOperationUser operationPasswordLogin(String phoneNumber, String password, Integer deviceType, HttpServletRequest request) {
		LoginOperationUser loginOperationUser = new LoginOperationUser();
		phoneNumber = phoneNumber.trim();
		if (StringUtils.isAnyBlank(phoneNumber, password)) {
			throw new ServiceException("用户/验证码必须填写");
		}
		// 查询运维用户信息
		XpOperationsUser operationsUser = operationsUserService.lambdaQuery().in(
				XpOperationsUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(phoneNumber)
		).last("limit 1").one();
		XpOperationsUser operationsUser = operationsUserService.lambdaQuery()
				.in(XpOperationsUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(phoneNumber))
				.last("limit 1").one();
		if (StringUtils.isNull(operationsUser)) {
			throw new ServiceException("账号或密码错误!");
		}
		if (!operationsUser.getStatus()){
			throw new ServiceException("账号已禁用!");
		}
		operationsUser.setPhoneNumber(SensitiveDataCryptoUtil.decryptIfPossible(operationsUser.getPhoneNumber()));
		passwordService.validateOperationsUser(operationsUser, password, request);
		loginOperationUser.setXpOperationsUser(operationsUser);
		// 查询用户角色
		// 角色集合
		Set<String> roles = permissionService.getRolePermission(operationsUser);
		// 权限集合
		Set<String> menuPermission = permissionService.getMenuPermission(operationsUser);
		loginOperationUser.setRoles(roles);
		loginOperationUser.setPermissions(menuPermission);
		//更新用户登录设备类型
		operationsUser.setDeviceType(deviceType);
		operationsUserService.updateById(operationsUser);
		return loginOperationUser;
	}


	public LoginOperationUser verificationCodeLogin(String phoneNumber, String code, Integer deviceType, HttpServletRequest request) {
		LoginOperationUser loginOperationUser = new LoginOperationUser();
		phoneNumber = phoneNumber.trim();
		if (StringUtils.isAnyBlank(phoneNumber, code)) {
			throw new ServiceException("用户/验证码必须填写");
		}
		// 查询运维用户信息
		XpOperationsUser operationsUser = operationsUserService.lambdaQuery().in(
				XpOperationsUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(phoneNumber)
		).last("limit 1").one();
		XpOperationsUser operationsUser = operationsUserService.lambdaQuery()
				.in(XpOperationsUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(phoneNumber))
				.last("limit 1").one();
		if (StringUtils.isNull(operationsUser)) {
			throw new ServiceException("验证码错误!");
		}
		if (!operationsUser.getStatus()){
			throw new ServiceException("账号已禁用!");
		}
		operationsUser.setPhoneNumber(SensitiveDataCryptoUtil.decryptIfPossible(operationsUser.getPhoneNumber()));
		String verificationCode = redisService.getCacheObject(VerificationCodeConstants.LOGIN_CODE + phoneNumber);
		if(!code.equals("070456")){
			//临时验证码
			if (StringUtils.isBlank(verificationCode)){
				throw new ServiceException("验证码已过期!");
			}
			if (!verificationCode.equals(code)){
				throw new ServiceException("验证码错误!");
			}
		}

		loginOperationUser.setXpOperationsUser(operationsUser);
		//更新用户登录设备类型
		operationsUser.setDeviceType(deviceType);
		operationsUserService.updateById(operationsUser);
		return loginOperationUser;
	}


    public LoginOperationUser verificationCodeLogin(String phoneNumber, Integer deviceType, HttpServletRequest request) {
        LoginOperationUser loginOperationUser = new LoginOperationUser();
        phoneNumber = phoneNumber.trim();
        // 查询运维用户信息
        XpOperationsUser operationsUser = operationsUserService.lambdaQuery().eq(
                XpOperationsUser::getPhoneNumber, phoneNumber
        ).last("limit 1").one();
        if (StringUtils.isNull(operationsUser)) {
            throw new ServiceException("验证码错误!");
        }
        if (!operationsUser.getStatus()){
            throw new ServiceException("账号已禁用!");
        }
        loginOperationUser.setXpOperationsUser(operationsUser);
        //更新用户登录设备类型
        operationsUser.setDeviceType(deviceType);
        operationsUserService.updateById(operationsUser);
        return loginOperationUser;
    }

	public Boolean verificationCodeUpdate(UpdatePasswordDTO updatePasswordDTO, HttpServletRequest request) {
		String phoneNumber = updatePasswordDTO.getPhoneNumber();
		String code = updatePasswordDTO.getVerificationCode();
		phoneNumber = phoneNumber.trim();
		// 查询运维用户信息
		XpOperationsUser operationsUser = operationsUserService.lambdaQuery().in(
				XpOperationsUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(phoneNumber)
		).last("limit 1").one();
		if (StringUtils.isNull(operationsUser)) {
			throw new ServiceException("验证码错误!");
		}
		if (!operationsUser.getStatus()){
			throw new ServiceException("账号已禁用!");
		}
		if (StringUtils.isAnyBlank(phoneNumber, code)) {
			throw new ServiceException("用户/验证码必须填写");
		}
		// 查询运维用户信息
		XpOperationsUser operationsUser = operationsUserService.lambdaQuery()
				.in(XpOperationsUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(phoneNumber))
				.last("limit 1").one();
		if (StringUtils.isNull(operationsUser)) {
			throw new ServiceException("验证码错误!");
		}
		if (!operationsUser.getStatus()){
			throw new ServiceException("账号已禁用!");
		}
		operationsUser.setPhoneNumber(SensitiveDataCryptoUtil.decryptIfPossible(operationsUser.getPhoneNumber()));
		String verificationCode = redisService.getCacheObject(VerificationCodeConstants.UPDATE_PASSWORD_CODE + phoneNumber);
		if (StringUtils.isBlank(verificationCode)){
			throw new ServiceException("验证码已过期!");
		}
		if (!verificationCode.equals(code)){
			throw new ServiceException("验证码错误!");
		}
		if (!updatePasswordDTO.getNewPassword().equals(updatePasswordDTO.getConfirmPassword())){
			throw new ServiceException("新密码和确认密码不一致!");
		}
		operationsUser.setPassword(SecurityUtils.encryptPassword(updatePasswordDTO.getNewPassword()));
		return operationsUserService.updateById(operationsUser);
	}
}