package gboat2.web.service.impl;
   
   import gboat2.web.Constants;
   import gboat2.web.business.IGroupBusiness;
   import gboat2.web.business.IRoleBusiness;
   import gboat2.web.business.IUserBusiness;
   import gboat2.web.model.Group;
   import gboat2.web.model.Profile;
   import gboat2.web.model.Role;
  import gboat2.web.model.User;
  import gboat2.web.model.UserGroupOrganMapper;
  import gboat2.web.model.UserRoleGroupOrganVO;
  import gboat2.web.service.IUserService;
  import gboat2.web.service.UserException;
  
  import java.util.List;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  
  /**
   * 对外提供新增用户接口
   * @author zhaop
   *
   */
  public class UserServiceImpl implements IUserService {
  	private static Logger logger = LoggerFactory.getLogger(IUserService.class);
  	
  	@Autowired
  	private IUserBusiness userService;
  	@Autowired
  	private IRoleBusiness roleService;
  	@Autowired
  	private IGroupBusiness groupService;
  	
  	@Override
  	public void addUser(User user, String roleCode, String groupCode, String organId, String organName) 
  		throws UserException{
  		if(StringUtils.isEmpty(user.getLoginId())){
  			throw new UserException("loginId cannot be null");
  		}
  		User currentUser = userService.getUserByLoginId(user.getLoginId());
  		if(currentUser==null){
  			//添加用户
  			userService.save(user);
  			//初始化用户信息
  			Profile profile = new Profile();
  			profile.setUserId(user.getUserId());
  			profile.setTheme(Constants.DEFAULT_THEME);
  			profile.setWallPaper(Constants.DEFAULT_THEME);
  			profile.setStretch("0");
  			userService.save(profile);
  		}else{
  			userService.update(user);
  			logger.info("user["+user.getLoginId()+"] is added before,update......");
  		}
  		
  		//添加用户身份
  		Role role = roleService.findRoleByRoleCode(roleCode);
  		if(role==null){
  			throw new UserException("role["+roleCode+"] is invalid.");
  		}
  		Group group = groupService.findGroupByGroupCode(groupCode);
  		if(group==null){
  			throw new UserException("group["+groupCode+"] is invalid.");
  		}
  		UserGroupOrganMapper urgo = userService.getURGOMapper(user.getUserId(), role.getRoleId(), group.getGroupId(), organId);
  		if(urgo==null){
  			UserGroupOrganMapper mapper = new UserGroupOrganMapper();
  			mapper.setUserId(user.getUserId());
  			mapper.setGroupId(group.getGroupId());
  			mapper.setRoleId(role.getRoleId());
  			mapper.setOrganId(organId);
  			mapper.setOrganName(organName);
  			userService.save(mapper);
  			logger.info("add user["+user.getLoginId()+","+roleCode+","+groupCode+"]");
  		}else{
  			if(!urgo.getOrganName().equals(organName)){
  				urgo.setOrganName(organName);
  				userService.update(urgo);
  			}
  		}
  	}
  	
  	@Override
  	public String addUserAndReturnUserId(User user, String roleCode, String groupCode, String organId, String organName) 
  		throws UserException{
  		this.addUser(user, roleCode, groupCode, organId, organName);
  		return user.getUserId();
  	}
  	
  
  	@Override
  	public void updateUser(String loginId, User user) throws UserException {
  		User currentUser = userService.getUserByLoginId(loginId);
  		if(currentUser==null){
  			throw new UserException("user "+loginId+" isn't exist.");
 		}else{
 			currentUser.setLoginId(user.getLoginId());
 			currentUser.setUserNameEn(user.getUserNameEn());
 			currentUser.setUserNameZh(user.getUserNameZh());
 			userService.update(currentUser);
 		}
 	}
 
 	@Override
 	public void updatePassword(String loginId, String newPwd) throws UserException {
 		User currentUser = userService.getUserByLoginId(loginId);
 		if(currentUser==null){
 			throw new UserException("user "+loginId+" isn't exist.");
 		}else{
 			currentUser.setPassword(newPwd);
 			userService.update(currentUser);
 		}
 	}
 	
 	/**
 	 * 更新user
 	 * @param user
 	 */
 	@Override
 	public void updateUser(User user){
 		if(user==null || StringUtils.isEmpty(user.getUserId())){
 			logger.info("user isn't exist.");
 			return;
 		}
 		userService.update(user);
 	}
 	
 	@Override
 	public void updateLoginIdAndUserNameZH(String loginId,String enterpriseId) throws UserException {
 		User currentUser = userService.getUserByEnterpriseId(enterpriseId);
 		if(currentUser==null){
 			throw new UserException("user "+enterpriseId+" isn't exist.");
 		}else{
 			currentUser.setLoginId(loginId);
 			currentUser.setUserNameZh(loginId);
 			userService.update(currentUser);
 		}
 		this.updateOrganNameOfUserGroupOrganMapper(loginId, enterpriseId);
 	}
 
 	@Override
 	public User getUserByLoginId(String loginId) {
 		return userService.getUserByLoginId(loginId);
 	}
 	
 	@Override
 	public User getUserByUserId(String userId) {
 		return userService.getUserByUserId(userId);
 	}
 
 	@Override
 	public List<UserGroupOrganMapper> getURGOMapperByUserId(String userId) {
 		return userService.getURGOMapperByUserId(userId);
 	}
 	
 	@Override
 	public List<UserGroupOrganMapper> getURGOMapperByOrganId(String organId) {
 		return userService.getURGOMapperByOrganId(organId);
 	}
 	
 	@Override
     public List<UserRoleGroupOrganVO> getMapperVOByUserId(String userId) {
 		return userService.getMapperVOByUserId(userId);
     }
 
 	@Override
 	public UserGroupOrganMapper getUserGroupOrganMapperById(String mapperId) {
 		return userService.getUserGroupOrganMapperById(mapperId);
 	}
 	
 	/**
 	 * 更新用户组织企业关联表中的企业名称
 	 * @param loginId
 	 * @param enterpriseId
 	 * @throws UserException
 	 */
 	private void updateOrganNameOfUserGroupOrganMapper(String loginId,String enterpriseId) throws UserException {
 		 List<UserGroupOrganMapper> userGroupOrganList =  ( List<UserGroupOrganMapper>) userService.getURGOMapperByOrganId(enterpriseId);
 		 UserGroupOrganMapper userGroupOrgan;
 		 if(userGroupOrganList == null || userGroupOrganList.size()!=1){
 			 throw new UserException("userGroupOrgan isn't exist.");
 		 }else{
 			 userGroupOrgan = userGroupOrganList.get(0);
 			 userGroupOrgan.setOrganName(loginId);
 			 userService.update(userGroupOrgan);
 		 }
 	}
 
 	@Override
 	public void deleteURGOMapperBy(String userId, String roleId, String groupId, String organId) {
 		userService.deleteURGOMapperBy(userId, roleId, groupId, organId);
 	}
 	
 	@Override
 	public void deleteURGOMapperByUserId(String userId) {
 		userService.deleteURGOMapperByUserId(userId);
 	}
 	
 	@Override
 	public void deleteUserRoleGroupOrganByUserId(String userId) {
 		User user = userService.getUserByUserId(userId);
 		userService.delete(user);
 		userService.deleteURGOMapperByUserId(userId);
 	}
 	
 	@Override
 	public void deleteUserByOrganId(String organId){
 		userService.deleteUserByOrganId(organId);
 	}
 	
 }