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

import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.gcube.application.framework.core.session.ASLSession;
import org.gcube.application.framework.core.session.SessionManager;
import org.gcube.common.homelibrary.home.HomeLibrary;
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
import org.gcube.common.homelibrary.home.workspace.Workspace;
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
import org.gcube.common.homelibrary.home.workspace.folder.FolderItem;
import org.gcube.common.homelibrary.home.workspace.folder.items.GCubeItem;
import org.gcube.common.scope.api.ScopeProvider;
import org.gcube.datacatalogue.ckanutillibrary.CKanUtilsImpl;
import org.gcube.datacatalogue.ckanutillibrary.models.ResourceBean;
import org.gcube.datacatalogue.metadatadiscovery.DataCalogueMetadataFormatReader;
import org.gcube.datacatalogue.metadatadiscovery.bean.MetadataType;
import org.gcube.datacatalogue.metadatadiscovery.bean.jaxb.MetadataField;
import org.gcube.datacatalogue.metadatadiscovery.bean.jaxb.MetadataFormat;
import org.gcube.datacatalogue.metadatadiscovery.bean.jaxb.MetadataValidator;
import org.gcube.datacatalogue.metadatadiscovery.bean.jaxb.MetadataVocabulary;
import org.gcube.portal.custom.scopemanager.scopehelper.ScopeHelper;
import org.gcube.portlets.widgets.ckandatapublisherwidget.client.CKanPublisherService;
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.DatasetMetadataBean;
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.LicensesBean;
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.MetaDataProfileBean;
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.MetaDataTypeWrapper;
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.MetadataFieldWrapper;
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.ResourceBeanWrapper;
import org.gcube.vomanagement.usermanagement.UserManager;
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayUserManager;
import org.gcube.vomanagement.usermanagement.model.UserModel;
import org.slf4j.LoggerFactory;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.liferay.portal.service.UserLocalServiceUtil;

/**
 * Server side of the data publisher.
 * @author Costantino Perciante at ISTI-CNR (costantino.perciante@isti.cnr.it)
 */
@SuppressWarnings("serial")
public class CKANPublisherServicesImpl extends RemoteServiceServlet implements CKanPublisherService{

	// Logger
	private static final org.slf4j.Logger logger = LoggerFactory.getLogger(CKANPublisherServicesImpl.class);
	
	public static final String TEST_SCOPE = "/gcube/devsec/devVRE";

	public static final String CKAN_TOKEN_KEY = "ckanToken";
	
	// library util instance
	private CKanUtilsImpl instance;
	
	@Override
	public void init(){
		// discover the library
		try {
			logger.debug("Creating ckan utility lib object");
			instance =  new CKanUtilsImpl(ScopeProvider.instance.get());
			logger.debug("Created");
		} catch (Exception e) {
			logger.error("Failed to find ckan information", e);
		}
	}

	/**
	 * the current ASLSession
	 * @return the session
	 */
	private ASLSession getASLSession() {
		String sessionID = this.getThreadLocalRequest().getSession().getId();
		String user = (String) this.getThreadLocalRequest().getSession().getAttribute(ScopeHelper.USERNAME_ATTRIBUTE);

		if (user == null) {
			logger.warn("USER IS NULL setting testing user and Running OUTSIDE PORTAL");
			user = getDevelopmentUser();
			SessionManager.getInstance().getASLSession(sessionID, user).setScope(TEST_SCOPE);
		}		
		return SessionManager.getInstance().getASLSession(sessionID, user);
	}

	/**
	 * when packaging test will fail if the user is not set to test.user
	 * @return .
	 */
	public String getDevelopmentUser() {
		String user = "test.user";
		//		user = "costantino.perciante";
		return user;
	}

	/**
	 * Get current user's token
	 * @return String the ckan user's token
	 */
	private String getUserCKanTokenFromSession(){

		ASLSession session = getASLSession();
		String username = session.getUsername();
		logger.debug("User in session is " + username);
		
		String token = null;
		if(this.getThreadLocalRequest().getSession().getAttribute("") != null)
			token = (String)this.getThreadLocalRequest().getSession().getAttribute(CKAN_TOKEN_KEY);
		else{
			
			token = instance.getApiKeyFromUsername(username);
			this.getThreadLocalRequest().getSession().setAttribute(CKAN_TOKEN_KEY, token);
			logger.debug("Ckan token has been set for user " + username);
		}
		
		logger.debug("Found ckan token " + token + " for user " + username);
		return token;

	}

	/**
	 * Retrieve the list of organizations in which the user can publish
	 * @param username
	 * @return the list of organizations
	 */
	private List<String> getUserOrganizationsList(String username) {
		logger.debug("Request for user " + username + " organizations list");
		return instance.getOrganizationsNamesByUser(username);
	}

	/**
	 * Online or in development mode?
	 * @return true if you're running into the portal, false if in development
	 */
	private boolean isWithinPortal() {
		try {
			UserLocalServiceUtil.getService();
			return true;
		} 
		catch (com.liferay.portal.kernel.bean.BeanLocatorException ex) {			
			logger.trace("Development Mode ON");
			return false;
		}			
	}

	/**
	 * Find a license id given the license text.
	 * @param chosenLicense
	 * @return
	 */
	private String findLicenseIdByLicense(String chosenLicense) {
		return instance.findLicenseIdByLicense(chosenLicense);
	}

	/**
	 * Retrieve the list of metadata beans
	 * @return
	 */
	private List<MetaDataProfileBean> getMetadataProfilesList() {

		List<MetaDataProfileBean> beans = new ArrayList<MetaDataProfileBean>();

		try {

			DataCalogueMetadataFormatReader reader = new DataCalogueMetadataFormatReader();

			for (MetadataType mt : reader.getListOfMetadataTypes()) {
				MetadataFormat metadata = reader.getMetadataFormatForMetadataType(mt);

				// we need to wrap the list of metadata
				List<MetadataFieldWrapper> wrapperList = new ArrayList<MetadataFieldWrapper>();
				List<MetadataField> toWrap = metadata.getMetadataFields();
				for(MetadataField metadataField: toWrap){

					MetadataFieldWrapper wrapperObj = new MetadataFieldWrapper();
					wrapperObj.setDefaulValue(metadataField.getDefaulValue());
					wrapperObj.setFieldName(metadataField.getFieldName());
					wrapperObj.setIsBoolean(metadataField.getIsBoolean());
					wrapperObj.setMandatory(metadataField.getMandatory());
					wrapperObj.setNote(metadataField.getNote());

					MetadataValidator validator = metadataField.getValidator();
					if(validator != null)
						wrapperObj.setValidator(validator.getRegularExpression());

					MetadataVocabulary vocabulary = metadataField.getVocabulary();
					if(vocabulary != null)
						wrapperObj.setVocabulary(vocabulary.getVocabularyFields());

					// add to the list
					wrapperList.add(wrapperObj);

				}

				// wrap the mt as well
				MetaDataTypeWrapper typeWrapper = new MetaDataTypeWrapper();
				typeWrapper.setDescription(mt.getDescription());
				typeWrapper.setId(mt.getId());
				typeWrapper.setName(mt.getName());
				MetaDataProfileBean bean = new MetaDataProfileBean(typeWrapper, wrapperList);
				beans.add(bean);
			}

			logger.debug("List of beans is " + beans);
			return beans;

		} catch (Exception e) {
			logger.error("Error while retrieving metadata beans ", e);
		}

		return null;
	}

	@Override
	public LicensesBean getLicenses() {

		logger.info("Request for CKAN licenses");
		try {
			List<String> titlesLicenses = instance.getLicenseTitles();
			// return the bean
			return new LicensesBean(titlesLicenses);
		} catch (Exception e) {
			logger.error("Failed to retrieve licenses", e);
		}
		return null;
	}

	@Override
	public DatasetMetadataBean getDatasetBean(String folderId, String owner){

		DatasetMetadataBean bean = null;

		logger.info("DatasetBean request for " + folderId + " and " + owner);

		if(isWithinPortal()){
			try{

				logger.debug("Request dataset metadata bean for folder with id " + folderId
						+ " whose owner is " + owner);
				// get usermanager (liferay)
				UserManager liferUserManager = new LiferayUserManager();
				UserModel userOwner = liferUserManager.getUserByScreenName(owner);

				// build bean
				logger.debug("Building bean");
				bean = new DatasetMetadataBean();

				bean.setId(folderId);
				bean.setOwnerIdentifier(owner);
				bean.setVersion(1);
				bean.setAuthor(userOwner.getFullname());
				bean.setAuthorEmail(userOwner.getEmail());
				bean.setMaintainer(userOwner.getFullname());
				bean.setMaintainerEmail(userOwner.getEmail());
				bean.setOrganizationList(getUserOrganizationsList(owner));

				// if the request comes from the workspace
				if(folderId != null && !folderId.isEmpty()){

					Workspace ws = HomeLibrary
							.getHomeManagerFactory()
							.getHomeManager()
							.getHome(owner).getWorkspace();

					WorkspaceItem retrievedItem = ws.getItem(folderId);

					// set some info
					bean.setTitle(retrievedItem.getName());
					bean.setDescription(retrievedItem.getDescription());

					// retrieve gcube items of the folder
					Map<String, String> folderItems = getGcubeItemProperties(retrievedItem);
					bean.setCustomFields(folderItems);

					// check the resources within the folder (skip subdirectories)
					List<String> childrenIds = new ArrayList<String>();

					for (WorkspaceItem file : retrievedItem.getChildren()) {
						if(!file.isFolder()) // ok, it's a file
							childrenIds.add(file.getId());
					}

					bean.setResourcesIds(childrenIds);

				}

				// retrieve the metadata
				List<MetaDataProfileBean> metadataBeans = getMetadataProfilesList();
				bean.setMetadataList(metadataBeans);

			}catch(Exception e){
				logger.error("Error while retrieving folder information", e);
			}
		}else{

			try{

				bean = new DatasetMetadataBean();
				bean.setId(folderId);
				bean.setDescription("This is a fantastic description");
				bean.setVersion(1);
				bean.setTitle("dataset-" + Calendar.getInstance().getTimeInMillis());
				bean.setAuthor("Costantino Perciante");
				bean.setAuthorEmail("costantino.perciante@isti.cnr.it");
				bean.setMaintainer("Costantino Perciante");
				bean.setMaintainerEmail("costantino.perciante@isti.cnr.it");
				bean.setOrganizationList(getUserOrganizationsList(owner));
				bean.setOwnerIdentifier(owner);

				if(folderId != null && !folderId.isEmpty()){

					Workspace ws = HomeLibrary
							.getHomeManagerFactory()
							.getHomeManager()
							.getHome(owner).getWorkspace();

					WorkspaceItem retrievedItem = ws.getItem(folderId);

					// retrieve gcube items of the folder
					Map<String, String> folderItems = getGcubeItemProperties(retrievedItem);
					bean.setCustomFields(folderItems);

					// check the resources within the folder (skip subdirectories)
					List<String> childrenIds = new ArrayList<String>();

					for (WorkspaceItem file : retrievedItem.getChildren()) {
						if(!file.isFolder()) // ok, it's a file
							childrenIds.add(file.getId());
					}

					bean.setResourcesIds(childrenIds);
				}

				// retrieve the metadata
				List<MetaDataProfileBean> metadataBeans = getMetadataProfilesList();
				bean.setMetadataList(metadataBeans);

			}catch(Exception e){
				logger.error("Error while building bean into dev mode", e);
			}
		}

		return bean;
	}

	/** Gets the gcube item properties.
	 *
	 * @param item the item
	 * @return the gcube item properties
	 */
	private Map<String, String> getGcubeItemProperties(WorkspaceItem item) {

		if(item instanceof GCubeItem){
			GCubeItem gItem = (GCubeItem) item;
			try {
				if(gItem.getProperties()!=null){
					Map<String, String> map = gItem.getProperties().getProperties();
					HashMap<String, String> properties = new HashMap<String, String>(map.size()); //TO PREVENT GWT SERIALIZATION ERROR
					for (String key : map.keySet())
						properties.put(key, map.get(key));

					return properties;
				}
			} catch (InternalErrorException e) {
				logger.error("Error in server getItemProperties: ", e);
				return null;
			}
		}
		return null;
	}

	@Override
	public DatasetMetadataBean createCKanDataset(DatasetMetadataBean toCreate, boolean isWorkspaceRequest) {

		logger.debug("Request for creating a dataset with these information " + toCreate);

		try{
			// get the owner
			String username = toCreate.getOwnerIdentifier();

			// set dataset info (same id as the folder, if the request comes from the workspace)
			String withId = null;
			if(isWorkspaceRequest)
				withId = toCreate.getId();

			String title = toCreate.getTitle();
			String organizationNameOrId = toCreate.getSelectedOrganization();
			String author = toCreate.getAuthor();
			String authorMail = toCreate.getAuthorEmail();
			String maintainer = toCreate.getMaintainer();
			String maintainerMail = toCreate.getMaintainerEmail();
			long version = toCreate.getVersion();
			String description = toCreate.getDescription();
			String chosenLicense = toCreate.getLicense();
			String licenseId = findLicenseIdByLicense(chosenLicense);
			List<String> listOfTags = toCreate.getTags();
			Map<String, String> customFields = toCreate.getCustomFields();
			boolean setPublic = toCreate.getVisibility();
			List<ResourceBean> resources = new ArrayList<ResourceBean>();

			// build the resource (if it is a workspaceRequest type)
			if(toCreate.isAddResources() && isWorkspaceRequest){

				logger.debug("We need to add resources to the dataset");

				try{

					Workspace ws = HomeLibrary
							.getHomeManagerFactory()
							.getHomeManager()
							.getHome(toCreate.getOwnerIdentifier()).getWorkspace();

					for(String resourceId: toCreate.getResourcesIds()){

						FolderItem item = (FolderItem)ws.getItem(resourceId);
						ResourceBean newResource = new ResourceBean();
						newResource.setDescription(item.getDescription());
						newResource.setId(item.getId());
						newResource.setUrl(item.getPublicLink(false));
						newResource.setName(item.getName());
						newResource.setMimeType(item.getMimeType());
						newResource.setOwner(username);
						resources.add(newResource);

					}

				}catch(Exception e){
					logger.error("Unable to add those resources to the dataset", e);
				}
			}


			String datasetId = instance.createCKanDataset(getUserCKanTokenFromSession(), withId, title, organizationNameOrId,  author,
					authorMail,  maintainer,  maintainerMail,  version, description, licenseId,
					listOfTags, customFields, resources, setPublic);

			if(datasetId != null){

				logger.debug("Dataset created!");
				toCreate.setId(datasetId);

				// retrieve the url
				String datasetUrl = instance.getUrlFromDatasetIdOrName(getUserCKanTokenFromSession(), datasetId);

				toCreate.setSource(datasetUrl);
				return toCreate;

			}else{

				logger.error("Failed to create the dataset");

			}

		}catch(Exception e){
			logger.error("Unable to create the dataset", e);
		}

		return null;
	}

	@Override
	public ResourceBeanWrapper addResourceToDataset(ResourceBeanWrapper resource, String datasetId, String owner) {

		logger.debug("Incoming request for creating new resource for dataset with id " + datasetId);
		logger.debug("Owner is " + owner + " and resource is " + resource);

		try{

			ResourceBean resourceBean = new ResourceBean(
					resource.getUrl(), 
					resource.getName(), 
					resource.getDescription(), 
					null, 
					owner, 
					datasetId,
					null);

			String resourceId = instance.addResourceToDataset(resourceBean, getUserCKanTokenFromSession());

			if(resourceId != null){

				logger.debug("Resource  " + resource.getName() + " is now available");

				// set its id and turn it to the client
				resource.setId(resourceId);
				return resource;

			}

		}catch(Exception e){
			logger.error("Unable to create new resource", e);
		}

		logger.debug("No resource created");

		return null;
	}

	@Override
	public boolean deleteResourceFromDataset(ResourceBeanWrapper resource,
			String owner) {
		logger.debug("Request for deleting resource " + resource);

		boolean deleted = false;

		try{

			deleted = instance.
					deleteResourceFromDataset(resource.getId(), getUserCKanTokenFromSession());

			if(deleted){
				logger.debug("Resource described by " + resource + " deleted");
			}else
				logger.error("Resource described by " + resource + " NOT deleted");

		}catch(Exception e){
			logger.error("Error while trying to delete resource described by " + resource, e);
		}

		return deleted;
	}

}