/*------------------------------------
    * Kaamelot - 2006
    * ------------------------------------
    * @author Kaamelot
    * Projet  : Myrddin
    * Fichier : AAdminProjectManager.java
    * Description :
    * This Class implements and Abstracion of AdminProjectManager contracts.  
    */
  package com.atlassian.jira.project;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.log4j.Category;
  import org.ofbiz.core.entity.GenericEntityException;
  import org.ofbiz.core.entity.GenericValue;
  
  import com.atlassian.core.user.GroupUtils;
  import com.atlassian.core.user.UserUtils;
  import com.atlassian.core.util.ClassLoaderUtils;
  import com.atlassian.jira.ManagerFactory;
  import com.atlassian.jira.event.user.UserEventDispatcher;
  import com.atlassian.jira.event.user.UserEventType;
  import com.atlassian.jira.exception.PermissionException;
  import com.atlassian.jira.permission.PermissionSchemeManager;
  import com.atlassian.jira.security.GlobalPermissionManager;
  import com.atlassian.jira.security.PermissionManager;
  import com.atlassian.jira.security.Permissions;
  import com.atlassian.jira.user.util.UserUtil;
  import com.atlassian.jira.util.JiraUtils;
  import com.atlassian.jira.util.map.EasyMap;
  import com.atlassian.plugin.PluginParseException;
  import com.atlassian.plugin.web.Condition;
  import com.opensymphony.user.DuplicateEntityException;
  import com.opensymphony.user.EntityNotFoundException;
  import com.opensymphony.user.Group;
  import com.opensymphony.user.User;
  
  /**
   * ------------------------------------ � Kaamelot - 2006 ------------------------------------
   * 
   * @author Kaamelot Projet : Myrddin Fichier : AAdminProjectManager.java Description : This Class provides information concerning Users and Groups for the Project Administration
   */
  public abstract class AAdminProjectManager implements AdminProjectManager {
  
  	private static final Category log = Category.getInstance(AAdminProjectManager.class);
  
  	protected AdminProjectManagerDirectory adminProjectManagerDirectory;
  
  	protected PermissionManager permissionManager;
  
  	protected PermissionSchemeManager permissionSchemeManager;
  
  	protected ProjectManager projectManager;
  
  	protected UserUtil userUtil;
  
  	protected Condition defaultActivationCondition;
  
  	/**
  	 * @param permissionManager
  	 */
  	public AAdminProjectManager(final PermissionManager _permissionManager, final PermissionSchemeManager _permissionSchemeManager, final ProjectManager _projectManager, final UserUtil _userUtil,
  				final AdminProjectManagerDirectory _adminProjectManagerDirectory) {
  		this.permissionManager = _permissionManager;
  		this.permissionSchemeManager = _permissionSchemeManager;
  		this.projectManager = _projectManager;
  		this.userUtil = _userUtil;
  		this.adminProjectManagerDirectory = _adminProjectManagerDirectory;
  		adminProjectManagerDirectory.addAdminProjectManager(this);
  	}
  
  	public String getId() {
  		return this.getClass().getName();
  	}
  
  	public Condition getDefaultActivationCondition() {
  		if (defaultActivationCondition == null) {
  			String conditionFQCN = getDefaultActivationConditionFQCN();
  			if (conditionFQCN != null) {
  				try {
  					Class clazz = ClassLoaderUtils.loadClass(conditionFQCN, this.getClass());
  					if (Condition.class.isAssignableFrom(clazz)) {
  						defaultActivationCondition = (Condition) JiraUtils.loadComponent(conditionFQCN, this.getClass());
  					} else {
  						log.warn("Condition [" + conditionFQCN + "] is not valid ...");
  					}
  				} catch (ClassNotFoundException e) {
  					log.warn("Condition class [" + conditionFQCN + "] not found.", e);
  				}
  			}
  			if (defaultActivationCondition == null) {
  				log.warn("True Condition assumed ...");
  				defaultActivationCondition = new Condition() {
  					public void init(Map params) throws PluginParseException {
 					}
 
 					public boolean shouldDisplay(Map context) {
 						return true;
 					}
 				};
 			}
 		}
 		return defaultActivationCondition;
 	}
 
 	/**
 	 * @param _project
 	 *           Concerned Project
 	 * @param _user
 	 *           Concerned User
 	 * @return A list of Rule given the permission to administrate the Project
 	 */
 	public Collection getAuthorizingGroups(final GenericValue _project, final User _user) {
 		Collection list = new ArrayList();
 		try {
 			if (isAdmin(_user))
 				list.add("jira-administrator");
 			if (isProjectLead(_project, _user))
 				list.add("project-lead");
 			if (isProjectAdmin(_project, _user))
 				list.add("project-administrator");
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return list;
 	}
 
 	/**
 	 * @param _project
 	 *           Concerned Project
 	 * @param _user
 	 *           Concerned User
 	 * @return A list of Rule given the permission to create User
 	 */
 	public Collection getCreateUserAuthorizingGroups(final GenericValue _project, final User _user) {
 		Collection list = new ArrayList();
 		try {
 			if (isAdmin(_user))
 				list.add("jira-administrator");
 			if (isAllowToCreateUser(_user))
 				list.add("user-creator");
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return list;
 	}
 
 	/**
 	 * @param _project
 	 *           Concerned Project
 	 * @param _params
 	 *           List of Parameters required to defined the list of Groups
 	 * @return List of Groups identified as authorized to access the Project
 	 */
 	public abstract Collection getAuthorizedGroups(final GenericValue _project, final Map _params);
 
 	/**
 	 * @param _project
 	 *           Concerned Project
 	 * @param _params
 	 *           List of Parameters required to defined the list of Groups
 	 * @return List of Groups Manageable in Project by Current User
 	 */
 	public Collection getManageableGroups(final GenericValue _project, final Map _params, final User _user) {
 		// GlobalPermissionManager gpm = ManagerFactory.getGlobalPermissionManager();
 		Collection authorizedGroups = getAuthorizedGroups(_project, _params);
 		Collection administerGroups = getAdministerGroups();
 		List manageableGroups = new ArrayList();
 		for (Iterator iter = authorizedGroups.iterator(); iter.hasNext();) {
 			Group group = (Group) iter.next();
 			// if (!gpm.hasPermission(Permissions.ADMINISTER, group.getName())) {
 			if (!administerGroups.contains(group)) {
 				manageableGroups.add(group);
 			}
 		}
 		return manageableGroups;
 	}
 
 	/**
 	 */
 	public Collection getWorkableGroups(GenericValue _project) {
 		int permission = Permissions.WORK_ISSUE;
 		Collection list = new ArrayList();
 		List schemes;
 		try {
 			schemes = permissionSchemeManager.getSchemes(_project);
 			for (Iterator si = schemes.iterator(); si.hasNext();) {
 				GenericValue scheme = (GenericValue) si.next();
 				List l = permissionSchemeManager.getEntities(scheme);
 				for (int n = 0; n < l.size(); n++) {
 					GenericValue schemePermission = (GenericValue) l.get(n);
 					int pid = schemePermission.getLong("permission").intValue();
 					if (pid == permission && schemePermission.getString("type").equals("group")) {
 						String groupName = schemePermission.getString("parameter");
 						list.add(GroupUtils.getGroup(groupName));
 					}
 				}
 			}
 		} catch (GenericEntityException e) {
 			e.printStackTrace();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return list;
 	}
 
 	protected Collection getAdministerGroups() {
 		GlobalPermissionManager gpm = ManagerFactory.getGlobalPermissionManager();
 		return gpm.getGroups(Permissions.ADMINISTER);
 	}
 
 	/**
 	 * Evaluate if the current user can Administer Group for its project
 	 * 
 	 * @return True, if current has required Permission or Rule
 	 * @throws Exception
 	 */
 	public boolean isHasManagerPermission(final Long _projectId, final User _user) {
 		return isHasManagerPermission(projectManager.getProject(_projectId), _user);
 	}
 
 	/**
 	 * Evaluate if the current user can Administrate Group for its project
 	 * 
 	 * @return True, if current has required Permission or Rule
 	 * @throws Exception
 	 */
 	public boolean isHasManagerPermission(final GenericValue _project, final User _user) {
 		return isAdmin(_user) || isProjectLead(_project, _user) || isProjectAdmin(_project, _user);
 	}
 
 	public boolean isHasUserCreatePermission(Long _projectId, User _user) {
 		return isHasUserCreatePermission(projectManager.getProject(_projectId), _user);
 	}
 
 	public boolean isHasUserCreatePermission(final GenericValue _project, final User _user) {
 		return isAdmin(_user) || isAllowToCreateUser(_user);
 	}
 
 	/**
 	 * Evaluate if the current user is a Project Leader
 	 * 
 	 * @param _project
 	 *           Concerned Project
 	 * @param _user
 	 *           Concerned User
 	 * @return True, if current has the mentionned Rule
 	 * @throws Exception
 	 */
 	public boolean isProjectLead(final GenericValue project, final User _user) {
 		String lead = project.getString("lead");
 		return lead != null && _user != null && lead.equals(_user.getName());
 	}
 
 	/**
 	 * Evaluate if the current user is a JIRA Administrateur
 	 * 
 	 * @param _project
 	 *           Concerned Project
 	 * @param _user
 	 *           Concerned User
 	 * @return True, if current has the mentionned Permission
 	 * @throws Exception
 	 */
 	public boolean isAdmin(final User _user) {
 		return permissionManager.hasPermission(Permissions.ADMINISTER, _user);
 	}
 
 	/**
 	 * Evaluate if the current user has the Permission of Administrate the Project
 	 * 
 	 * @param _project
 	 *           Concerned Project
 	 * @param _user
 	 *           Concerned User
 	 * @return True, if current has the mentionned Permission
 	 * @throws Exception
 	 */
 	public boolean isProjectAdmin(final GenericValue _project, final User _user) {
 		return permissionManager.hasPermission(Permissions.PROJECT_ADMIN, _project, _user);
 	}
 
 	/**
 	 * Evaluate if the current user has the Permission of Administrate the Project
 	 * 
 	 * @param _project
 	 *           Concerned Project
 	 * @param _user
 	 *           Concerned User
 	 * @return True, if current has the mentionned Permission
 	 * @throws Exception
 	 */
 	public boolean isAllowToCreateUser(final User _user) {
 		return permissionManager.hasPermission(Permissions.ADMINISTER, _user);
 	}
 
 	/**
 	 * No Filter implemented
 	 */
 	public String getFilteringGroupName() {
 		// return "jira-users";
 		return "";
 	}
 
 	/** 
 	 */
 	public User createUser(Long _projectId, String _userName, String _fullName, String _email) throws PermissionException {
 		User user = null;
 		try {
 			user = userUtil.createJiraUser(_userName, null, _email, _fullName);
 			String password = UserUtils.resetPassword(user);
 
 			// Send always password if the user has not disabled when creating.
 			dispatchEvent(user, EasyMap.build("username", _userName, "password.new", password, "email", _email, "fullname", _fullName));
 		} catch (Exception e) {
 			throw new PermissionException(e);
 		}
 		return user;
 	}
 
 	protected void dispatchEvent(User user, Map args) {
 		UserEventDispatcher.dispatchEvent(UserEventType.USER_CREATED, user, args);
 	}
 
 	public void addUserToGroup(final Group _groupToAdd, final User _user) {
 		try {
 			userUtil.addUserToGroup(_groupToAdd, _user);
 			// } catch (IndexException e) {
 			// e.printStackTrace();
 			// } catch (GenericEntityException e) {
 			// e.printStackTrace();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 
 	public User getUser(final String _user) throws EntityNotFoundException {
 		return UserUtils.getUser(_user);
 	}
 
 	public User addUserToGroup(final Long _projectId, final String _group, final String _user) throws EntityNotFoundException, PermissionException, DuplicateEntityException {
 		User user;
 		try {
 			user = getUser(_user);
 			Group groupToAdd = GroupUtils.getGroup(_group);
 			if (groupToAdd.containsUser(user)) {
 				throw new DuplicateEntityException("User already member ...");
 			}
 			addUserToGroup(groupToAdd, user);
 		} catch (EntityNotFoundException enfe) {
 			log.warn(enfe.getMessage());
 			throw enfe;
 		}
 		return user;
 	}
 
 	public void removeUserFromGroup(final Group _groupToRemove, final User _user) {
 		try {
 			userUtil.removeUserFromGroup(_groupToRemove, _user);
 			// } catch (IndexException e) {
 			// e.printStackTrace();
 			// } catch (GenericEntityException e) {
 			// e.printStackTrace();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 
 	public void removeUserFromGroup(final Long _projectId, final String _group, final String _user) throws EntityNotFoundException, PermissionException {
 		User user;
 		try {
 			user = UserUtils.getUser(_user);
 			Group groupToRemove = GroupUtils.getGroup(_group);
 			removeUserFromGroup(groupToRemove, user);
 		} catch (EntityNotFoundException enfe) {
 			log.warn(enfe.getMessage());
 			throw enfe;
 		}
 	}
 
 }