package org.gcube.portlets.widgets.workspacesharingwidget.server;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.gcube.application.framework.core.session.ASLSession;
import org.gcube.common.homelibrary.home.HomeLibrary;
import org.gcube.common.homelibrary.home.exceptions.HomeNotFoundException;
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
import org.gcube.common.homelibrary.home.workspace.Workspace;
import org.gcube.common.homelibrary.home.workspace.WorkspaceFolder;
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
import org.gcube.common.homelibrary.home.workspace.WorkspaceItemType;
import org.gcube.common.homelibrary.home.workspace.WorkspaceSharedFolder;
import org.gcube.common.homelibrary.home.workspace.accessmanager.ACLType;
import org.gcube.common.homelibrary.home.workspace.exceptions.InsufficientPrivilegesException;
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemAlreadyExistException;
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemNotFoundException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WorkspaceFolderNotFoundException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WrongDestinationException;
import org.gcube.common.homelibrary.home.workspace.usermanager.GCubeGroup;
import org.gcube.common.portal.PortalContext;
import org.gcube.portlets.widgets.workspacesharingwidget.client.ConstantsSharing;
import org.gcube.portlets.widgets.workspacesharingwidget.client.rpc.WorkspaceSharingService;
import org.gcube.portlets.widgets.workspacesharingwidget.server.notifications.NotificationsProducer;
import org.gcube.portlets.widgets.workspacesharingwidget.server.util.ScopeUtility;
import org.gcube.portlets.widgets.workspacesharingwidget.server.util.UserUtil;
import org.gcube.portlets.widgets.workspacesharingwidget.server.util.WsUtil;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.CredentialModel;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.FileModel;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.InfoContactModel;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.SessionExpiredException;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.WorkspaceACL;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.system.VO;
import org.gcube.portlets.widgets.workspacesharingwidget.shared.system.VRE;
import org.gcube.vomanagement.usermanagement.GroupManager;
import org.gcube.vomanagement.usermanagement.UserManager;
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayGroupManager;
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayUserManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

/**
 * The server side implementation of the RPC service.
 */
@SuppressWarnings("serial")
public class WorkspaceSharingServiceImpl extends RemoteServiceServlet implements
    WorkspaceSharingService {

	protected static Logger logger = LoggerFactory.getLogger(WorkspaceSharingServiceImpl.class);
	
	
	protected GWTWorkspaceSharingBuilder getGWTWorkspaceBuilder()
	{
		return WsUtil.getGWTWorkspaceSharingBuilder(this.getThreadLocalRequest().getSession());
	}

	protected Workspace getWorkspace() throws InternalErrorException, HomeNotFoundException, WorkspaceFolderNotFoundException
	{
		return WsUtil.getWorkspace(this.getThreadLocalRequest().getSession());
	}
	
	protected NotificationsProducer getNotificationProducer(){
		
		return WsUtil.getNotificationProducer(WsUtil.getAslSession(this.getThreadLocalRequest().getSession()));
	}
	
	protected ScopeUtility getScopeUtilFilter(){
		
		return WsUtil.getScopeUtilFilter(this.getThreadLocalRequest().getSession());
	}
	
	protected boolean isTestMode(){
		return !WsUtil.isWithinPortal(); //IS NOT INTO PORTAL
	}
	
	@Override
	public List<InfoContactModel> getAllContacts(boolean readGroupsFromHL, boolean readGroupsFromPortal) throws Exception {
		
		try {
			ASLSession aslSession = WsUtil.getAslSession(this.getThreadLocalRequest().getSession()); //THIS FORCE THE SESSION CREATION
			logger.info("Get all contacts");
		
//			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
//			workspace.getAllScope();

			GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
			
			if(isTestMode()){
				logger.warn("WORKSPACE PORTLET IS IN TEST MODE - RETURN TEST USERS AND GROUPS");
				GWTWorkspaceSharingBuilder.getHashTestUsers();
				List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
				for (String key : GWTWorkspaceSharingBuilder.getHashTestUsers().keySet()) {
					InfoContactModel contact = GWTWorkspaceSharingBuilder.getHashTestUsers().get(key);
					listContactsModel.add(contact);
				}
				
//			
//				listContactsModel.add(new InfoContactModel("antonio.gioia", "antonio.gioia", "Antonio Gioia", false));
//				listContactsModel.add(new InfoContactModel("fabio.sinibaldi", "fabio.sinibaldi", "Fabio Sinibaldi", false));
//				listContactsModel.add(new InfoContactModel("pasquale.pagano", "pasquale.pagano", "Pasquale Pagano", false));
////				listContactsModel.add(new InfoContactModel(WsUtil.TEST_USER, WsUtil.TEST_USER, WsUtil.TEST_USER_FULL_NAME));
//				listContactsModel.add(new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa", false));
//				listContactsModel.add(new InfoContactModel("massimiliano.assante", "massimiliano.assante", "Massimiliano Assante", false));
//				listContactsModel.add(new InfoContactModel("valentina.marioli", "valentina.marioli", "Valentina Marioli", false));
//				listContactsModel.add(new InfoContactModel("leonardo.candela", "leonardo.candela", "Leonardo Candela", false));
//				
//				listContactsModel.add(new InfoContactModel("/gube/devsec/devVRE", "/gube/devsec/devVRE", "devVRE", true));
				
//				listContactsModel.addAll(getFakeGroups());
				
				return listContactsModel;
				
			}

			UserManager userManag = new LiferayUserManager();
			GroupManager gm = new LiferayGroupManager();
			String groupId = gm.getRootVO().getGroupId();
	
			logger.trace("Liferay User Manager getting list users by group: "+groupId);
			List<InfoContactModel> listContactsModel = builder.buildGXTListContactsModelFromUserModel(userManag.listUsersByGroup(groupId));
			
			if(readGroupsFromHL){
				logger.info("Reading group names from HL..");
				org.gcube.common.homelibrary.home.workspace.usermanager.UserManager hlUserManager = HomeLibrary.getHomeManagerFactory().getUserManager();
				logger.trace("Home Library User Manager getting list Gcube Group");
				List<GCubeGroup> groups = hlUserManager.getGroups();
				if(groups!=null){
					logger.info("Read group names from HL, return "+groups.size()+" groups, converting");
					listContactsModel.addAll(builder.buildGXTListContactsModelFromGcubeGroup(groups));
				}else
					logger.warn("Read group names from HL, return list null, skipping");
			}	
			
			if(readGroupsFromPortal){
				logger.info("Reading group names as scopes from Infrastructure..");
	
				PortalContext context = PortalContext.getConfiguration();
				logger.info("context.getInfrastructureName(): "+context.getInfrastructureName());
				logger.info("aslSession.getGroupName(): "+ aslSession.getGroupName());
				logger.info("aslSession.getScope().toString(): "+ aslSession.getScope());
				try{
					ScopeUtility scopeUtility = new ScopeUtility(aslSession.getScope());
					
					if(scopeUtility.getVoName()!=null){
						logger.info("VO name is not null, trying to calculate List VO");
						List<VO> lsVOs = WsUtil.getVresFromInfrastructure(context.getInfrastructureName(), scopeUtility.getVoName());
//						String voPath = ConstantsSharing.PATH_SEPARATOR+context.getInfrastructureName() + ConstantsSharing.PATH_SEPARATOR + aslSession.getGroupName() + ConstantsSharing.PATH_SEPARATOR;
						listContactsModel.addAll(builder.buildGXTListContactsModelFromVOs(lsVOs, scopeUtility.getVo()));
					}else
						logger.warn("VO name is null, skipping list VO "+ aslSession.getGroupName());
					
				}catch(Exception e){
					logger.warn("An error occurred on recovering vo name, skipping list VO "+ aslSession.getGroupName());
				}
			}
			
			logger.info("Get all contacts returning a list having size: "+listContactsModel.size());
			return listContactsModel;
			
		} catch (Exception e) {
			logger.error("Error in server get all contacts ", e);
//			return new ArrayList<InfoContactModel>();
			throw new Exception(e.getMessage());
		}
	}
	
	

	@Override
	public List<InfoContactModel> getListUserSharedByFolderSharedId(String folderSharedId) throws Exception{
		
		logger.info("getListUserSharedByFolderSharedId "+ folderSharedId);

		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(folderSharedId);
			
			//TODO CHANGE TO READ ACL FROM SHARED SUBFOLDER
			if(isASharedFolder(wsItem, true)){
				
				WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;

				GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();

				List<String> listPortalLogin = wsFolder.getUsers();

				logger.info("getListUserSharedByFolderSharedId return "+ listPortalLogin.size() + " user");

				if(isTestMode())
					return builder.buildGxtInfoContactFromPortalLoginTestMode(listPortalLogin);
				
				return builder.buildGxtInfoContactsFromPortalLogins(listPortalLogin);
				
			}
			else{
				logger.info("the item with id: "+folderSharedId+ " is not  "+WorkspaceItemType.SHARED_FOLDER);
				
				//DEBUG
				//System.out.println("the item with id: "+folderSharedId+ " is not  "+WorkspaceItemType.SHARED_FOLDER);
			}
			return new ArrayList<InfoContactModel>();
		}catch (ItemNotFoundException e){
			logger.error("Error in server during item retrieving, getListUserSharedByFolderSharedId", e);
			throw new Exception("The Item id "+folderSharedId+" not found in workspace or is not a shared folder");
		} catch (Exception e) {
			logger.error("Error in getListUserSharedByItemId ", e);
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public InfoContactModel getOwnerByItemId(String itemId) throws Exception {
		
		logger.info("get Owner By ItemId "+ itemId);
		try {
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(itemId);

			GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTInfoContactModel(wsItem.getOwner());
			
		} catch (Exception e) {
			logger.error("Error in getOwnerByItemId ", e);
			throw new Exception(e.getMessage());
		}
	}
	
	/**
	 * 
	 * @return
	 * @throws Exception
	 */
	@Override
	public List<WorkspaceACL> getACLs() throws Exception{
		try {

			GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
			return builder.getWorkspaceACLFromACLs(Arrays.asList(ACLType.values()));
		} catch (Exception e) {
			logger.error("Error in server get ACLs", e);
			String error = ConstantsSharing.SERVER_ERROR +" get ACL rules. "+e.getMessage();
			throw new Exception(error);
		}
	}
	
	@Override
	public String getMyLogin(){
		ASLSession asl = WsUtil.getAslSession(this.getThreadLocalRequest().getSession());
		return asl.getUsername();
	}
	
	@Override
	public FileModel getFileModelByWorkpaceItemId(String itemId) throws Exception {

		try {
			
//			System.out.println("Get file model by itemId: "+itemId);
			
			if(itemId == null || itemId.isEmpty())
				throw new Exception("Identifier is null or empty");	
			
			Workspace workspace = getWorkspace();
			
			logger.info("Get file model by itemId: "+itemId);
			
			WorkspaceItem wsItem =  workspace.getItem(itemId);
			
			GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();

//			Long startTime =  System.currentTimeMillis();
//		
//			Long endTime = System.currentTimeMillis() - startTime;
//			String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
//			logger.debug("get child for Grid by id returning element in " + time);
			
			logger.info("Getting folder parent");
			
			WorkspaceFolder folderParent = null;
			if(wsItem!=null)
				folderParent = wsItem.getParent(); 	//BUILD PARENT
			else
				throw new Exception("Workspace item not found");
			
	
			FileModel parent = null;
			if(folderParent!=null){
				logger.info("Folder parent has id: "+folderParent.getId() + " and name: "+folderParent.getName());
				parent = builder.buildGXTFileModelItem(folderParent, null);
			}
			else
				logger.info("Folder parent for item: "+wsItem.getId() +" is null");
		
			//BUILD ITEM
			return builder.buildGXTFileModelItem(wsItem, parent);
		}catch (ItemNotFoundException e){
			logger.error("Error in server during item retrieving, getFileModelByWorkpaceItemId", e);
			throw new Exception("The Item id "+itemId+" not found in workspace");
		} catch (Exception e) {
			logger.error("Error in server during item retrieving, getFileModelByWorkpaceItemId", e);
			String error =  ConstantsSharing.SERVER_ERROR + " retrieving the item from workspace, "+e.getMessage();
			throw new Exception(error);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService#isSessionExpired()
	 */
	@Override
	public boolean isSessionExpired() throws Exception {
		return WsUtil.isSessionExpired(this.getThreadLocalRequest().getSession());
	}

	
	// DEBUG
	private void printContacts(List<InfoContactModel> listContacts) {

		boolean testMode = isTestMode();
		if (testMode)
			System.out.println("Contacts: ");
		else
			logger.debug("Contacts:");

		for (InfoContactModel infoContactModel : listContacts) {
			if (testMode)
				System.out.println("User: " + infoContactModel);
			else
				logger.debug("User: " + infoContactModel);
		}
	}

	
	@Override
	public boolean shareFolder(FileModel folder, List<InfoContactModel> listContacts, boolean isNewFolder, WorkspaceACL acl) throws Exception {
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {

			Workspace workspace = getWorkspace();
			
			logger.info("sharing item id: "+ folder.getIdentifier() 
					+ " name: "+ folder.getName() 
//					+ " parent name: " + folder.getParentFileModel().getName()
					+ " listContacts size: " + listContacts.size());
			
//			//DEBUG
			//System.out.println("shareFolder "+ folder.getIdentifier() + " name: "+ folder.getName() + " parent name: " + folder.getParentFileModel().getName() + " listContacts size: " + listContacts.size());
//			for (InfoContactModel infoContactModel : listContacts) {
//				System.out.println("share with "+ infoContactModel.getLogin());
//			}
//			printContacts(listContacts);

			List<String> listLogin = UserUtil.getListLoginByInfoContactModel(listContacts);
			
			WorkspaceSharedFolder sharedFolder = null;
			
			List<InfoContactModel> listSharedContact = null;
			
			boolean sourceFolderIsShared = folder.isShared();
			
			if(sourceFolderIsShared){ //if source folder is already share... retrieve old list of sharing to notify
				listSharedContact = getListUserSharedByFolderSharedId(folder.getIdentifier());
			}

			if(listLogin.size()>0){
				
				if(!isNewFolder){
					sharedFolder = workspace.shareFolder(listLogin, folder.getIdentifier());
					sharedFolder.setDescription(folder.getDescription()); //SET NEW DESCRIPTION
				}
				else
					sharedFolder = workspace.createSharedFolder(folder.getName(), folder.getDescription(), listLogin, folder.getParentFileModel().getIdentifier());
			}
			
			boolean created = sharedFolder==null?false:true;

			if(acl!=null)
				setACLs(sharedFolder.getId(), listLogin, acl.getId().toString());
			
			if(created){
				NotificationsProducer np = getNotificationProducer();
				if(!sourceFolderIsShared) {//if source folder is not already shared
					
					//TODO ADD NOTIFICATION
//					np.notifyFolderSharing(listContacts, sharedFolder);
				
				}else{
					/*System.out.println("SHARED CONTACS: ");
					printContacts(listSharedContact);
					System.out.println("NEW CONTACS: ");
					printContacts(listContacts);*/
					
					//TODO ADD NOTIFICATION
//					np.notifyAddedUsersToSharing(listSharedContact, listContacts, sharedFolder);
				}
			}
				
			return created;

		} catch (InsufficientPrivilegesException e) {
			logger.error("Error in shareFolder ", e);
			String error = "An error occurred on creating shared folder. "+ e.getMessage();
			throw new Exception(error);
			
		} catch (ItemAlreadyExistException e) {
			logger.error("Error in shareFolder ", e);
			String error = "An error occurred on creating shared folder. "+ e.getMessage();
			throw new Exception(error);
			
		} catch (WrongDestinationException e) {
			logger.error("Error in shareFolder ", e);
			String error = "An error occurred on creating shared folder. "+ e.getMessage();
			throw new Exception(error);

		} catch (Exception e) {
			logger.error("Error in shareFolder ", e);
			e.printStackTrace();
			String error = ConstantsSharing.SERVER_ERROR+" sharing item.";
			throw new Exception(error);
		}
	}
	

	public void setACLs(String folderId, List<String> listLogins, String aclType) throws Exception{
		try {

			if(folderId == null)
				throw new Exception("Folder id is null");	
				
			if(listLogins==null || listLogins.size()==0)
				throw new Exception("List Logins is null or empty");
			
			logger.info("Setting ACL for folder id: "+folderId);
			logger.info("ACL type is: "+aclType);
				
			Workspace workspace = getWorkspace();
			WorkspaceItem wsItem = workspace.getItem(folderId);
			
			if(wsItem.isShared() && (wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER))){
				WorkspaceSharedFolder ite = (WorkspaceSharedFolder) workspace.getItemByPath(wsItem.getPath());
				ite.setACL(listLogins, ACLType.valueOf(aclType));
			}else
				throw new Exception("Source item is not shared or shared folder");
			
			logger.info("Setting ACL completed, retuning");
		} catch (Exception e) {
			logger.info("Error in set ACLs", e);
			String error = ConstantsSharing.SERVER_ERROR +" setting permissions. "+e.getMessage();
			throw new Exception(error);
		}
	}

	/* (non-Javadoc)
	 * @see org.gcube.portlets.widgets.workspacesharingwidget.client.rpc.WorkspaceSharingService#getInfoContactModelsFromCredential(java.util.List)
	 */
	@Override
	public List<InfoContactModel> getInfoContactModelsFromCredential(List<CredentialModel> listAlreadySharedContact) throws Exception {
		
		if(listAlreadySharedContact==null || listAlreadySharedContact.size()==0)
			throw new Exception("Credentials list is null or empty");
		
		
		GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
		List<InfoContactModel> listContacts = new ArrayList<InfoContactModel>(listAlreadySharedContact.size());
		for (CredentialModel credentialModel : listAlreadySharedContact) {
			
			if(!credentialModel.isGroup()){
				InfoContactModel contact = builder.buildGxtInfoContactFromPortalLogin(credentialModel.getLogin());
				contact.setReferenceCredential(credentialModel);
				listContacts.add(contact);
			}
		}
		
		return listContacts;
	}
	
	/* (non-Javadoc)
	 * @see org.gcube.portlets.widgets.workspacesharingwidget.client.rpc.WorkspaceSharingService#getAdministratorsByFolderId(java.lang.String)
	 */
	@Override
	public List<InfoContactModel> getAdministratorsByFolderId(String sharedFolderId) throws Exception {
	
		if(sharedFolderId==null || sharedFolderId.isEmpty())
			throw new Exception("Shared Folder id is null or empty");

		try {
			
			Workspace workspace = getWorkspace();
			WorkspaceItem item = workspace.getItem(sharedFolderId);
			logger.info("Getting administator/s to folder: "+sharedFolderId);
			
			if(item!=null && item.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
				WorkspaceSharedFolder sharedFolder = (WorkspaceSharedFolder) item;
				GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
				List<String> admins = sharedFolder.getAdministrators();
				logger.info("Converting "+admins.size()+" administator/s List<InfoContactModel>");
				
				if(isTestMode())
					return builder.buildGxtInfoContactFromPortalLoginTestMode(admins);
				
				return builder.buildGxtInfoContactsFromPortalLogins(admins);
			}else
				throw new Exception("The item is null or not instanceof "+WorkspaceItemType.SHARED_FOLDER);
		} catch (ItemNotFoundException e){
			logger.error("Error in server getAdministratorsByFolderId", e);
			throw new Exception("The Item id "+sharedFolderId+" not found in workspace or is not a shared folder");
		} catch (Exception e) {
			logger.error("Error in server getAdministratorsByFolderId", e);
			String error = "Sorry an error occurred on getting Administrators";
			throw new Exception(error);
		}
	}
	
	
	/**
	 * DEBUG
	 * @return
	 */
	private List<InfoContactModel> getFakeGroups(){
		
		List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
		
		PortalContext context = PortalContext.getConfiguration();
		System.out.println("context.getInfrastructureName(): "+context.getInfrastructureName());
//		System.out.println("context.getVOsAsString(): "+context.getVOsAsString());
		List<VO> vos = WsUtil.getVresFromInfrastructure(context.getInfrastructureName(), "devsec");
		
		for (VO vo : vos) {
			System.out.println("vo name "+vo.getName());
			
			for (VRE vre : vo.getVres()) {
				System.out.println("vre name "+vre.getName());
				listContactsModel.add(new InfoContactModel(vre.getName(), vre.getName(), vre.getName(), true));
			}
		}
		
		return listContactsModel;
	}
	
	public static void main(String[] args) {
		
		WorkspaceSharingServiceImpl impl = new WorkspaceSharingServiceImpl();
		
		PortalContext context = PortalContext.getConfiguration();
		
		try {
		
			String nameVO = "devsec";
			String vrePath = ConstantsSharing.PATH_SEPARATOR+context.getInfrastructureName() + ConstantsSharing.PATH_SEPARATOR + nameVO + ConstantsSharing.PATH_SEPARATOR;
			
			List<VO> lsVOs = WsUtil.getVresFromInfrastructure(context.getInfrastructureName(), nameVO);
			GWTWorkspaceSharingBuilder builder = new GWTWorkspaceSharingBuilder();
			List<InfoContactModel> groups = builder.buildGXTListContactsModelFromVOs(lsVOs, vrePath);
			
			for (VO vo : lsVOs) {
				System.out.println(vo.getName());
				
				for (VRE vre : vo.getVres()) {
					System.out.println("VRE: "+vre.getName());
				}
			}
			
			for (InfoContactModel infoContactModel : groups) {
				System.out.println(infoContactModel);
			}
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/* (non-Javadoc)
	 * @see org.gcube.portlets.widgets.workspacesharingwidget.client.rpc.WorkspaceSharingService#getACLForSharedItemId(java.lang.String)
	 * 
	 * return the WorkspaceACL of shared folder, null otherwise
	 */
	@Override
	public WorkspaceACL getACLForSharedItemId(String itemID) throws Exception{
		logger.info("Getting ACLBySharedFolderId: "+itemID);
		if(itemID==null || itemID.isEmpty()){
			logger.warn("Getting ACLBySharedFolderId identifier is null or empty, returning null");
			return null;
		}
		try {
			
			Workspace workspace = getWorkspace();
			WorkspaceItem item = workspace.getItem(itemID);
			
			if(isASharedFolder(item, false)){ //IS A SHARED FOLDER
				
				//TODO REMOVE PARENT SHARED FOLDER
				WorkspaceSharedFolder parentSharedFolder = (WorkspaceSharedFolder) workspace.getItem(item.getIdSharedFolder());
				GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
				
				logger.info("Read getPrivilege from HL: "+parentSharedFolder.getACLUser());
				List<WorkspaceACL> wsAcls = builder.getWorkspaceACLFromACLs(Arrays.asList(parentSharedFolder.getPrivilege()));
				
				if(wsAcls==null || wsAcls.isEmpty()){
					logger.info("Converted ACLBySharedFolderId is null or empty, returning null");
					return null;
				}
				
				logger.info("Returning first acl with id: "+wsAcls.get(0).getId());
				return wsAcls.get(0);
				
			}else
				throw new Exception("The item is null or not a shared folder");
			
		} catch (Exception e) {
			logger.error("Error in server getACLForSharedItemId", e);
			String error = "Sorry an error occurred when getting ACL for item: "+itemID;
			throw new Exception(error);
		}
	}
	
	/**
	 * 
	 * @return Formatted HTML DIV containing ACLs description for folderId
	 * @throws Exception
	 */
	@Override
	public String getACLsDescriptionForSharedFolderId(String folderId) throws Exception{
		try {
			
			WorkspaceSharedFolder wsFolder = getSharedFolderForId(folderId);
			GWTWorkspaceSharingBuilder builder = getGWTWorkspaceBuilder();
			return builder.getFormattedHtmlACLFromACLs(wsFolder.getACLOwner());
		} catch (Exception e) {
			logger.error("Error in server get getACLForFolderId", e);
			String error = "Sorry an error occurred when getting ACL rules for selected folder. "+e.getMessage();
			throw new Exception(error);
		}
	}
	
	private WorkspaceSharedFolder getSharedFolderForId(String folderId) throws Exception{
		
		if(folderId == null)
			throw new Exception("Folder id is null");	
			
		logger.trace("Get ACLsDescriptionForFolderId folder id: "+folderId);
			
		Workspace workspace = getWorkspace();
		WorkspaceItem wsItem = workspace.getItem(folderId);
		
		if(isASharedFolder(wsItem, false)){
			logger.trace("Get SharedFolderForId: folder id "+folderId+" is shared");
			
			//TODO REMOVE wsItem.getIdSharedFolder()
			WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) workspace.getItem(wsItem.getIdSharedFolder());
			
			if(wsFolder!=null){
				logger.trace("Get ACLsDescriptionForFolderId shared folder name is: "+wsFolder.getName());
				return wsFolder;
				
			//TODO USE THIS
//			return (WorkspaceFolder) wsItem;
				
			}else{
				logger.trace("Source item is not a shared folder, throw exception");
				throw new Exception("Source item is not a shared folder");
			}
		}else{
			logger.trace("Source item is null or not shared, throw exception");
			throw new Exception("Source item is null or not shared");
		}
	}
	
	/**
	 * 
	 * @param itemID
	 * @param asRoot true check if itemID is root, not otherwise
	 * @return
	 */
	
	public boolean isASharedFolder(String itemID, boolean asRoot){
		try {
			
			if(itemID==null)
				throw new Exception("ItemId is null");
			
			Workspace workspace = getWorkspace();
			WorkspaceItem item = workspace.getItem(itemID);

			return isASharedFolder(item, asRoot);
			
		}catch(Exception e){
			logger.error("Error in server isASharedFolder", e);
			return false;
		}
	}
	
	public boolean isASharedFolder(WorkspaceItem item, boolean asRoot){
		try {
			
			if(item!=null && item.isFolder() && item.isShared()){ //IS A SHARED SUB-FOLDER
				if(asRoot)
					return item.getType().equals(WorkspaceItemType.SHARED_FOLDER); //IS ROOT?
				
				return true;
			}
			
			return false;
		}catch(Exception e){
			logger.error("Error in server isASharedFolder", e);
			return false;
		}
	}
}