package com.xiaopeng.account.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.common.core.constant.UserConstants;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.common.security.service.TokenService;
import com.xiaopeng.account.mapper.SysUserMapper;
import com.xiaopeng.account.mapper.SysUserRoleMapper;
import com.xiaopeng.account.service.ISysUserService;
import com.xiaopeng.account.model.query.SysUserListQuery;
import com.xiaopeng.api.model.account.SysUser;
import com.xiaopeng.api.model.account.SysUserRole;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 用户 业务层处理
 *
 * @author ruoyi
 */
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements ISysUserService {
	private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
	
	@Resource
	private SysUserMapper userMapper;
	
	@Resource
	private SysUserRoleMapper userRoleMapper;
	
	@Resource
	private TokenService tokenService;


	/**
	 * 通过用户名查询用户
	 *
	 * @param userName 用户名
	 * @return 用户对象信息
	 */
	@Override
	public SysUser selectUserByUserName(String userName)
	{
		return userMapper.selectUserByUserName(userName);
	}

	/**
	 * 根据条件分页查询已分配用户角色列表
	 *
	 * @param user 用户信息
	 * @return 用户信息集合信息
	 */
	@Override
	public List<SysUser> selectAllocatedList(SysUser user) {
		return userMapper.selectAllocatedList(user);
	}

	/**
	 * 根据条件分页查询未分配用户角色列表
	 *
	 * @param user 用户信息
	 * @return 用户信息集合信息
	 */
	@Override
	public List<SysUser> selectUnallocatedList(SysUser user) {
		return userMapper.selectUnallocatedList(user);
	}


	/**
	 * 通过用户ID查询用户
	 *
	 * @param userId 用户ID
	 * @return 用户对象信息
	 */
	@Override
	public SysUser selectUserById(Long userId) {
		return userMapper.selectUserById(userId);
	}

	/**
	 * 校验用户名称是否唯一
	 *
	 * @param user 用户信息
	 * @return 结果
	 */
	@Override
	public boolean checkUserNameUnique(SysUser user) {
		Long userId = StringUtils.isNull(user.getId()) ? -1L : user.getId();
		SysUser info = userMapper.checkUserNameUnique(user.getUserName());
		if (StringUtils.isNotNull(info) && info.getId().longValue() != userId.longValue()) {
			return UserConstants.NOT_UNIQUE;
		}
		return UserConstants.UNIQUE;
	}

	/**
	 * 校验手机号码是否唯一
	 *
	 * @param user 用户信息
	 * @return
	 */
	@Override
	public boolean checkPhoneUnique(SysUser user) {
		Long userId = StringUtils.isNull(user.getId()) ? -1L : user.getId();
		SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
		if (StringUtils.isNotNull(info)) {
			return UserConstants.NOT_UNIQUE;
		}
		return UserConstants.UNIQUE;
	}

	/**
	 * 校验用户是否允许操作
	 *
	 * @param user 用户信息
	 */
	@Override
	public void checkUserAllowed(SysUser user) {
		Long userid = tokenService.getLoginUser().getUserid();
		if (StringUtils.isNotNull(user.getId()) && !userid.equals(user.getId()) && user.isAdmin()) {
			throw new ServiceException("不允许操作超级管理员用户");
		}
	}

	/**
	 * 校验用户是否有数据权限
	 *
	 * @param userId 用户id
	 */
	@Override
	public void checkUserDataScope(Long userId) {
		if (!SysUser.isAdmin(tokenService.getLoginUser().getUserid())) {
			SysUser user = new SysUser();
			user.setId(userId);
			List<SysUser> users = this.baseMapper.selectUserList(user);
			if (StringUtils.isEmpty(users)) {
				throw new ServiceException("没有权限访问用户数据！");
			}
		}
	}

	/**
	 * 新增保存用户信息
	 *
	 * @param user 用户信息
	 * @return 结果
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public int insertUser(SysUser user) {
		// 新增用户信息
//		int rows = userMapper.insertUser(user);
//        // 新增用户岗位关联
//        insertUserPost(user);
//        // 新增用户与角色管理
//        insertUserRole(user);
		user.setCreateBy(tokenService.getLoginUser().getUsername());
		user.setUpdateBy(tokenService.getLoginUser().getUsername());
		return userMapper.insert(user);
	}

	/**
	 * 修改保存用户信息
	 *
	 * @param user 用户信息
	 * @return 结果
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public int updateUser(SysUser user) {
		return userMapper.updateUser(user);
	}

	/**
	 * 用户授权角色
	 *
	 * @param userId  用户ID
	 * @param roleIds 角色组
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void insertUserAuth(Long userId, Long[] roleIds) {
		userRoleMapper.deleteUserRoleByUserId(userId);
		insertUserRole(userId, roleIds);
	}

	/**
	 * 修改用户状态
	 *
	 * @param user 用户信息
	 * @return 结果
	 */
	@Override
	public int updateUserStatus(SysUser user) {
		return userMapper.updateUser(user);
	}

	/**
	 * 重置用户密码
	 *
	 * @param user 用户信息
	 * @return 结果
	 */
	@Override
	public int resetPwd(SysUser user) {
		return userMapper.updateUser(user);
	}

	/**
	 * 新增用户角色信息
	 *
	 * @param userId  用户ID
	 * @param roleIds 角色组
	 */
	public void insertUserRole(Long userId, Long[] roleIds) {
		if (StringUtils.isNotEmpty(roleIds)) {
			// 新增用户与角色管理
			List<SysUserRole> list = new ArrayList<SysUserRole>();
			for (Long roleId : roleIds) {
				SysUserRole ur = new SysUserRole();
				ur.setUserId(userId);
				ur.setRoleId(roleId);
				list.add(ur);
			}
			userRoleMapper.batchUserRole(list);
		}
	}

	/**
	 * 批量删除用户信息
	 *
	 * @param userIds 需要删除的用户ID
	 * @return 结果
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public int deleteUserByIds(Long[] userIds) {
		for (Long userId : userIds) {
			SysUser sysUser = new SysUser();
			sysUser.setId(userId);
			checkUserAllowed(sysUser);
		}
		return userMapper.deleteUserByIds(userIds);
	}


    @Override
    public PageInfo<SysUser> getList(PageInfo<SysUser> pageInfo, SysUserListQuery sysUserListQuery) {
        return userMapper.getList(pageInfo, sysUserListQuery);
    }

}