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.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.CKanUtilsFactory;
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.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);

	/**
	 * Retrieve the list of organizations in which the user can publish
	 * @param owner
	 * @return
	 */
	private List<String> getUserOrganizationsList(String owner) {

		logger.debug("Request for user " + owner + " organizations list");

		try{

			String currentScope = ScopeProvider.instance.get();
			return CKanUtilsFactory.getInstance().getCkanUtilsForScope(currentScope).getOrganizationsNamesByUser(owner);

		}catch(Exception e){
			logger.error("Failed to retrieve user's organizations", e);
		}

		return null;
	}

	/**
	 * 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) {

		String currentScope = ScopeProvider.instance.get();
		try {
			return CKanUtilsFactory.getInstance().getCkanUtilsForScope(currentScope).findLicenseIdByLicense(chosenLicense);
		} catch (Exception e) {
			logger.error("Failed to retrieve license id", e);
		}

		return null;
	}

	/**
	 * 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 {
			String currentScope = ScopeProvider.instance.get();
			List<String> titlesLicenses;
			titlesLicenses = CKanUtilsFactory.getInstance().getCkanUtilsForScope(currentScope).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(fromOwnerToCKanOwner(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(fromOwnerToCKanOwner(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{
			
			String currentScope = ScopeProvider.instance.get();

			// get the owner
			String username = fromOwnerToCKanOwner(toCreate.getOwnerIdentifier());
			CKanUtilsImpl utilityInstance = CKanUtilsFactory.getInstance().getCkanUtilsForScope(currentScope);

			// 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 = utilityInstance.createCKanDataset(username, 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 = utilityInstance.getUrlFromDatasetIdOrName(username, 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;
	}

	/**
	 * Ckan username has _ instead of . (that is, costantino.perciante -> costantino_perciante)
	 * @param owner
	 * @return
	 */
	private String fromOwnerToCKanOwner(String owner){
		return owner.replaceAll("\\.", "_");
	}

	@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{

			String currentScope = ScopeProvider.instance.get();

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

			String resourceId = CKanUtilsFactory.getInstance().
					getCkanUtilsForScope(currentScope).
					addResourceToDataset(resourceBean);

			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{
			String currentScope = ScopeProvider.instance.get();

			deleted = CKanUtilsFactory.getInstance().
					getCkanUtilsForScope(currentScope).
					deleteResourceFromDataset(fromOwnerToCKanOwner(owner), resource.getId());

			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;
	}

}