package com.cloud.user.service.impl;

//import com.cloud.common.utils.AppUserUtil;
import com.cloud.common.utils.MD5Util;
import com.cloud.common.utils.PageUtil;
import com.cloud.common.utils.PhoneUtil;
import com.cloud.model.common.Page;
import com.cloud.model.sys.*;
import com.cloud.model.sys.constants.CredentialType;
import com.cloud.model.sys.constants.UserType;
import com.cloud.user.constants.EmpTypeConstant;
import com.cloud.user.dao.AppUserDao;
import com.cloud.user.dao.UserCredentialsDao;
import com.cloud.user.dao.UserOrgDao;
import com.cloud.user.dao.UserRoleDao;
import com.cloud.user.model.OrgNameAppUser;
import com.cloud.user.service.AppUserService;
import com.cloud.user.service.SysMenuService;
import com.cloud.user.service.SysPermissionService;
import com.cloud.user.service.TokenService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
public class AppUserServiceImpl implements AppUserService {

	@Autowired
	private AppUserDao appUserDao;
/*	@Autowired
	private BCryptPasswordEncoder passwordEncoder;*/
	@Autowired
	private SysPermissionService sysPermissionService;
	@Autowired
	private UserRoleDao userRoleDao;
	@Autowired
	private UserCredentialsDao userCredentialsDao;
	@Autowired
	private UserOrgDao userOrgDao;
	@Autowired
	private SysMenuService sysMenuService;
	@Autowired
	private TokenService tokenService;

	@Transactional(rollbackFor = Exception.class)
	@Override
	public void addAppUser(AppUser appUser) {
		String username = appUser.getUsername();
		if (StringUtils.isBlank(username)) {
			throw new IllegalArgumentException("用户名不能为空");
		}

		if (PhoneUtil.checkPhone(username)) {
			// 防止用手机号直接当用户名，手机号要发短信验证
			throw new IllegalArgumentException("用户名要包含英文字符");
		}

		if (username.contains("@")) {
			// 防止用邮箱直接当用户名，邮箱也要发送验证（暂未开发）
			throw new IllegalArgumentException("用户名不能包含@");
		}

		if (username.contains("|")) {
			throw new IllegalArgumentException("用户名不能包含|字符");
		}

		if (StringUtils.isBlank(appUser.getPassword())) {
			throw new IllegalArgumentException("密码不能为空");
		}

		if (StringUtils.isBlank(appUser.getNickname())) {
			appUser.setNickname(username);
		}

		if (StringUtils.isBlank(appUser.getType())) {
			appUser.setType(UserType.APP.name());
		}

		UserCredential userCredential = userCredentialsDao.findByUsername(appUser.getUsername(),0l);
		if (userCredential != null ){
			throw new IllegalArgumentException("用户名已存在");
		}
		appUser.setPassword(MD5Util.encode(appUser.getPassword()));
		appUser.setEnabled(Boolean.TRUE);
		appUser.setCreateTime(new Date());
		appUser.setUpdateTime(appUser.getCreateTime());

		appUserDao.save(appUser);
//		Long id = appUserDao.findUserId(appUser.getUsername(),appUser.getOrgId());
		Long id = appUser.getId();
		userCredentialsDao
				.save(new UserCredential(appUser.getUsername(), CredentialType.USERNAME.name(), id,appUser.getOrgId()));
		log.info("添加用户：{}", appUser);
	}


	public Long registerAdmin(Map<String,Object> params) {
		AppUser appUser = (AppUser)params.get("appUser");
		UserCredentialsDao userDao = (UserCredentialsDao)params.get("userDao");
		AppUserDao appDao = (AppUserDao)params.get("appDao");
		//PasswordEncoder passCoder = (PasswordEncoder)params.get("passCoder");
		UserCredential userCredential = userDao.findByUsername(appUser.getUsername(),0l);
		if (userCredential != null) {
			throw new IllegalArgumentException("用户名已存在");
		}
		appUser.setType(UserType.APP.name());
		appUser.setPassword(MD5Util.encode(appUser.getPassword()));
		appUser.setEnabled(Boolean.TRUE);
		appUser.setCreateTime(new Date());
		appUser.setUpdateTime(appUser.getCreateTime());

		appDao.save(appUser);
		Long id = appDao.findUserId(appUser.getUsername(),appUser.getOrgId());
		userDao.save(new UserCredential(appUser.getUsername(), CredentialType.USERNAME.name(), id,appUser.getOrgId()));
		return id;
	}

	@Override
	public Map<String, Object> deleteAppUser(Map<String, Object> params) {
		Map<String,Object> map = new HashMap<>();
		try {
			Integer status = appUserDao.deleteAppUser(params);
			if(status > 0){
				userCredentialsDao.deleteAppUser(params);
				map.put("code",0);
				map.put("message","删除成功！！！");
			}
		}catch (Exception e){
			map.put("code",1);
			map.put("message","删除失败！！！");
		}
		return map;
	}

	@Override
	public void updateAppUser(AppUser appUser) {
		appUser.setUpdateTime(new Date());
		appUser.setEnabled(Boolean.TRUE);
		appUserDao.update(appUser);
		log.info("修改用户：{}", appUser);
	}

	@Override
	public void setPassWord(AppUser appUser) {
		appUser.setPassword(MD5Util.encode(EmpTypeConstant.RESET_PASSWORD));
		appUser.setEnabled(Boolean.TRUE);
		appUser.preUpdate(tokenService.currentUser());
		appUserDao.update(appUser);
	}

	@Transactional
	@Override
	public LoginAppUser findByUsername(String username) {

			AppUser appUser = userCredentialsDao.findLoginUser(username);
			if (appUser != null) {

				LoginAppUser loginAppUser = new LoginAppUser();
				BeanUtils.copyProperties(appUser, loginAppUser);

				Set<SysRole> sysRoles = userRoleDao.findRolesByUserId(appUser.getId(),appUser.getOrgId());
				loginAppUser.setSysRoles(sysRoles);// 设置角色

				Set<SysOrganization> sysOrgs= userOrgDao.findUserOrgsName(appUser.getOrgId());
				loginAppUser.setSysOrgs(sysOrgs);//设置组织信息

				if (!CollectionUtils.isEmpty(sysRoles)) {
					Set<Long> roleIds = sysRoles.parallelStream().map(r -> r.getId()).collect(Collectors.toSet());
					Set<SysMenu> sysMenus = sysMenuService.findByRoleIds(roleIds,null);
					if (!CollectionUtils.isEmpty(sysMenus)) {
						Set<String> menus = sysMenus.parallelStream().filter(p -> StringUtils.isNotEmpty(p.getPermission())).map(p -> p.getPermission())
								.collect(Collectors.toSet());


						/*Set<SysMenu> menuss = sysMenus.parallelStream().map(p -> p)
								.collect(Collectors.toSet());*/

						loginAppUser.setSysMenus(sysMenus);// 设置菜单集合
						loginAppUser.setPermissions(menus);// 设置权限集合
					}

					//Set<SysPermission> sysPermissions = sysPermissionService.findByRoleIds(roleIds);
					//if (!CollectionUtils.isEmpty(sysPermissions)) {
					//	Set<String> permissions = sysPermissions.parallelStream().map(p -> p.getPermission())
					//			.collect(Collectors.toSet());
					//	loginAppUser.setPermissions(permissions);// 设置权限集合
					//}
				}
				return loginAppUser;
			}

		return null;
	}

	@Override
	public AppUser findById(Map<String,Object> params) {
		return appUserDao.findById(params);
	}

	@Override
	public AppUser login(Map<String,Object> params) {
		return appUserDao.login(params);
	}

	/**
	 * 给用户设置角色
	 */
	@Override
	@Transactional
	public int setRoleToUser(Map<String,Object> params) {
		int status = 0;
		AppUser appUser = appUserDao.findById(params);
		if (appUser == null) {
			throw new IllegalArgumentException("用户不存在");
		}
		try{
			if(!params.get("roleIds").toString().equals("")){
				Set<Long> roleIds = new HashSet<>();
				String[] ids = params.get("roleIds").toString().split(",");
				for(int i=0;i<ids.length;i++){
					roleIds.add(Long.parseLong(ids[i]));
				}

				userRoleDao.deleteUserRole(params);
				if (!CollectionUtils.isEmpty(roleIds)) {
					for (Long roleId:roleIds) {
						params.put("roleId",roleId);
						//前台传的是id，后台的要的是userId，别的地方已经改了，这里强行把id改一波儿userId
						params.put("userId", Integer.parseInt(params.get("id").toString()));
						userRoleDao.saveUserRoles(params);
					}
				}
				log.info("修改用户：{}的角色，{}", appUser.getUsername(), roleIds);
			}else {
				userRoleDao.deleteUserRole(params);
			}
			status = 1;
			return status;
		}catch (Exception e){
			e.printStackTrace();
			return status;
		}
	}

	/**
	 * 给用户设置角色
	 */
	@Transactional
	public void setRoleToAdmin(Map<String,Object> params) {
		AppUserDao appDao = (AppUserDao) params.get("appDao");
		UserRoleDao roleDao = (UserRoleDao)params.get("roleDao");
		AppUser appUser = appDao.findById(params);
		if (appUser == null) {
			throw new IllegalArgumentException("用户不存在");
		}
		Set<Long> roleIds = new HashSet<>();
		String[] ids = params.get("roleIds").toString().split(",");
		for(int i=0;i<ids.length;i++){
			roleIds.add(Long.parseLong(ids[i]));
		}

		roleDao.deleteUserRole(params);
		if (!CollectionUtils.isEmpty(roleIds)) {
			roleIds.forEach(roleId -> {
				params.put("roleId",roleId);
				params.put("orgId",appUser.getOrgId());
				roleDao.saveUserRoles(params);
			});
		}
	}

	@Override
	public void updatePassword(Map<String,Object> params) {
		AppUser appUser = appUserDao.findById(params);
		if (StringUtils.isNoneBlank(params.get("oldPassword").toString())) {
			if (!MD5Util.encode(params.get("oldPassword").toString()).equals(appUser.getPassword())) {
				throw new IllegalArgumentException("旧密码错误");
			}
		}
		AppUser user = new AppUser();
		user.setId(Long.parseLong(params.get("id").toString()));
		user.setEnabled(appUser.isEnabled());
		user.setPassword(MD5Util.encode(params.get("newPassword").toString()));
		updateAppUser(user);
		log.info("修改密码：{}", user);
	}

	@Override
	public Page<OrgNameAppUser> findUsers(Map<String, Object> params) {

		//前台传参是否查全部
		if(params.containsKey("isAll")){
			if(params.get("isAll").toString().equals("0")){
				params.remove("orgId");
			}
		}
		int total = appUserDao.count(params);
		List<OrgNameAppUser> list = Collections.emptyList();
		if (total > 0) {
			PageUtil.pageParamConver(params, true);

			list = appUserDao.findData(params);
		}
		return new Page<OrgNameAppUser>(total, list);
	}

	@Override
	public Set<SysRole> findRolesByUserId(Long userId,Long orgId) {
		return userRoleDao.findRolesByUserId(userId, orgId);
	}

	/**
	 * 绑定手机号
	 */
	@Override
	public void bindingPhone(Long userId, String phone,Long orgId) {
		UserCredential userCredential = userCredentialsDao.findByUsername(phone,userId);
		if (userCredential != null) {
			throw new IllegalArgumentException("手机号已被绑定");
		}
		Map<String,Object> map = new HashMap<>();
		map.put("userId",userId);
		map.put("orgId",orgId);
		AppUser appUser = appUserDao.findById(map);
		appUser.setPhone(phone);

		updateAppUser(appUser);
		log.info("绑定手机号成功,username:{}，phone:{}", appUser.getUsername(), phone);

		// 绑定成功后，将手机号存到用户凭证表，后续可通过手机号+密码或者手机号+短信验证码登陆
		userCredentialsDao.save(new UserCredential(phone, CredentialType.PHONE.name(), userId,orgId));
	}

	@Override
	public Map<String, Object> findRolesIdsByUserId(Map<String, Object> params) {
		List<Integer> data = userRoleDao.findRolesIdsByUserId(params);
		Map<String,Object> map = new HashMap<>();
		if(data.size() > 0){
			map.put("data",data);
			map.put("message","查询成功！！！");
			map.put("code","0");
		}else{
			map.put("data","");
			map.put("message","暂无数据！！！");
			map.put("code","1");
		}
		return map;
	}

	@Override
	public int updateOfficeId(Map<String, Object> params) {
		return appUserDao.updateOfficeId(params);
	}
}