/*******************************************************************************
 * Copyright (c) 2011-2014 EclipseSource Muenchen GmbH and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Pascal - initial API and implementation
 ******************************************************************************/
package org.eclipse.emf.emfstore.jax.client;

import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.BRANCHES_PATH_AFTER_PROJECTID;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.BRANCHES_PATH_BEFORE_PROJECTID;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.DELETE_FILES_QUERY_PARAM;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.FILE_SIZE_QUERY_PARAM;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.HISTORIES_PATH;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PACKAGES_PATH;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH_CHANGES;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH_FILES;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH_PROPERTIES;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH_RESOLVE_VERSION_SPEC;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH_TAGS;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.PROJECTS_PATH_VERSIONS;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.SOURCE_VERSION_SPEC_QUERY_PARAM;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.TARGET_VERSION_SPEC_QUERY_PARAM;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.USERS_PATH;
import static org.eclipse.emf.emfstore.jax.common.CallParamStrings.VERSION_SPEC_QUERY_PARAM;
import static org.eclipse.emf.emfstore.jax.common.TransferUtil.convertSerializableIntoStreamingOutput;
import static org.eclipse.emf.emfstore.jax.common.TransferUtil.getEObjectFromResponse;
import static org.eclipse.emf.emfstore.jax.common.TransferUtil.getExceptionFromExceptionResponse;
import static org.eclipse.emf.emfstore.jax.common.TransferUtil.getFileChunkFromResponse;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import javax.ws.rs.ProcessingException;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.Invocation.Builder;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.StreamingOutput;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.emfstore.client.exceptions.ESCertificateException;
import org.eclipse.emf.emfstore.internal.client.model.ServerInfo;
import org.eclipse.emf.emfstore.internal.client.model.connectionmanager.AbstractConnectionManager;
import org.eclipse.emf.emfstore.internal.client.model.connectionmanager.ConnectionManager;
import org.eclipse.emf.emfstore.internal.common.model.EMFStoreProperty;
import org.eclipse.emf.emfstore.internal.common.model.Project;
import org.eclipse.emf.emfstore.internal.server.filetransfer.FileChunk;
import org.eclipse.emf.emfstore.internal.server.filetransfer.FileTransferInformation;
import org.eclipse.emf.emfstore.internal.server.model.AuthenticationInformation;
import org.eclipse.emf.emfstore.internal.server.model.ClientVersionInfo;
import org.eclipse.emf.emfstore.internal.server.model.ModelFactory;
import org.eclipse.emf.emfstore.internal.server.model.ProjectHistory;
import org.eclipse.emf.emfstore.internal.server.model.ProjectId;
import org.eclipse.emf.emfstore.internal.server.model.ProjectInfo;
import org.eclipse.emf.emfstore.internal.server.model.SessionId;
import org.eclipse.emf.emfstore.internal.server.model.accesscontrol.ACOrgUnitId;
import org.eclipse.emf.emfstore.internal.server.model.accesscontrol.ACUser;
import org.eclipse.emf.emfstore.internal.server.model.accesscontrol.OrgUnitProperty;
import org.eclipse.emf.emfstore.internal.server.model.versioning.BranchInfo;
import org.eclipse.emf.emfstore.internal.server.model.versioning.BranchVersionSpec;
import org.eclipse.emf.emfstore.internal.server.model.versioning.ChangePackage;
import org.eclipse.emf.emfstore.internal.server.model.versioning.HistoryInfo;
import org.eclipse.emf.emfstore.internal.server.model.versioning.HistoryQuery;
import org.eclipse.emf.emfstore.internal.server.model.versioning.LogMessage;
import org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec;
import org.eclipse.emf.emfstore.internal.server.model.versioning.TagVersionSpec;
import org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec;
import org.eclipse.emf.emfstore.jax.common.TransferUtil;
import org.eclipse.emf.emfstore.server.exceptions.ESException;

/**
 * JAX-RS based Implementation of ConnectionManager
 *
 * @author Pascal Schliski
 *
 */
@SuppressWarnings("restriction")
public class JaxrsConnectionManager extends AbstractConnectionManager<JaxrsClientManager> implements ConnectionManager {

	public JaxrsConnectionManager() {

	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#getProjectList(org.eclipse.emf.emfstore.internal.server.model.SessionId)
	 */
	public List<ProjectInfo> getProjectList(SessionId sessionId) throws ESException {

		final Builder builder = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.request(MediaType.APPLICATION_XML);
		final Response response = builder.get();

		checkResponseStatus(response);

		final List<ProjectInfo> projectInfoList = TransferUtil
			.<ProjectInfo> getEObjectListFromResponse(response);

		return projectInfoList;
	}

	/**
	 * checks if the status of the response is OK, if not it will throw an ESException if there is an entity with an
	 * ESException Message
	 *
	 * @param response
	 * @throws ESException
	 */
	private void checkResponseStatus(Response response) throws ESException {

		final int status = response.getStatus();

		if (isStatusNotSuccessful(status)) {

			if (response.hasEntity()) {

				String entity;
				try {
					entity = response.readEntity(String.class);
					final ESException exception = getExceptionFromExceptionResponse(entity);
					if (exception == null) {
						throw new ESException(String.valueOf(status));
					}
					throw exception;
				} catch (final ProcessingException ex) {
					throw new ESException(String.valueOf(status));
				} catch (final IllegalStateException ex) {
					throw new ESException(String.valueOf(status));
				}
			}
			throw new ESException(String.valueOf(status) + response.getStatusInfo().getReasonPhrase());
		}
	}

	/**
	 * @param status
	 * @return
	 */
	private boolean isStatusNotSuccessful(final int status) {

		return status / 100 != 2;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#getProject(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec)
	 */
	public Project getProject(SessionId sessionId, ProjectId projectId, VersionSpec versionSpec) throws ESException {

		PrimaryVersionSpec primaryVersionSpec;
		if (versionSpec instanceof PrimaryVersionSpec) {
			primaryVersionSpec = (PrimaryVersionSpec) versionSpec;
		}
		else {
			primaryVersionSpec = resolveVersionSpec(sessionId, projectId, versionSpec);
		}

		final String subpath = projectId.getId();
		final String versionSpecQueryParam = String.valueOf(primaryVersionSpec.getIdentifier());

		// make the http call and get the input stream and extract the Project
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(subpath).queryParam(VERSION_SPEC_QUERY_PARAM, versionSpecQueryParam)
			.request(MediaType.APPLICATION_XML).get();

		checkResponseStatus(response);

		// read the entity
		final Project project = getEObjectFromResponse(response);

		return project;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#createProject(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      java.lang.String, java.lang.String, org.eclipse.emf.emfstore.internal.server.model.versioning.LogMessage,
	 *      org.eclipse.emf.emfstore.internal.common.model.Project)
	 */
	public ProjectInfo createProject(SessionId sessionId, String name, String description,
		LogMessage logMessage, Project project) throws ESException {

		final List<EObject> eObjects = new ArrayList<EObject>();

		final ProjectInfo projectInfo = ModelFactory.eINSTANCE.createProjectInfo();
		projectInfo.setName(name);
		projectInfo.setDescription(description);
		eObjects.add(projectInfo);
		if (logMessage != null) {
			eObjects.add(logMessage);
		}
		if (project != null) {
			eObjects.add(project);
		}

		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(eObjects);

		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		// read the entity
		return getEObjectFromResponse(response);
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#deleteProject(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId, boolean)
	 */
	public void deleteProject(SessionId sessionId, ProjectId projectId, boolean deleteFiles)
		throws ESException {

		final String subpath = projectId.getId();

		// make the http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(subpath).queryParam(DELETE_FILES_QUERY_PARAM, deleteFiles).request()
			.delete();

		checkResponseStatus(response);

	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#importProjectHistoryToServer(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectHistory)
	 */
	public ProjectId importProjectHistoryToServer(SessionId sessionId, ProjectHistory projectHistory)
		throws ESException {

		// create StreamingOutput
		final List<ProjectHistory> projectHistoryList = new ArrayList<ProjectHistory>();
		projectHistoryList.add(projectHistory);
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(projectHistoryList);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(HISTORIES_PATH)
			.request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		return getEObjectFromResponse(response);
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#exportProjectHistoryFromServer(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId)
	 */
	public ProjectHistory exportProjectHistoryFromServer(SessionId sessionId, ProjectId projectId) throws ESException {

		final String projectIdPathParam = projectId.getId();

		final Response response = getConnectionProxy(sessionId).getTarget().path(HISTORIES_PATH)
			.path(projectIdPathParam).request(MediaType.APPLICATION_XML).get();

		checkResponseStatus(response);

		final ProjectHistory projectHistory = getEObjectFromResponse(response);

		return projectHistory;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#getBranches(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId)
	 */
	public List<BranchInfo> getBranches(SessionId sessionId, ProjectId projectId) throws ESException {

		final String projectIdPathParam = projectId.getId();

		// make the http call
		final Response response = getConnectionProxy(sessionId).getTarget()
			.path(BRANCHES_PATH_BEFORE_PROJECTID)
			.path(projectIdPathParam)
			.path(BRANCHES_PATH_AFTER_PROJECTID)
			.request(MediaType.APPLICATION_XML).get();

		checkResponseStatus(response);

		final List<BranchInfo> branchInfoList = TransferUtil
			.<BranchInfo> getEObjectListFromResponse(response);

		return branchInfoList;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#createVersion(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.ChangePackage,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.BranchVersionSpec,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.LogMessage)
	 */
	public PrimaryVersionSpec createVersion(SessionId sessionId, ProjectId projectId,
		PrimaryVersionSpec baseVersionSpec, ChangePackage changePackage,
		BranchVersionSpec targetBranch, PrimaryVersionSpec sourceVersion,
		LogMessage logMessage) throws ESException {

		// create path param as String
		final String projectIdPathParam = projectId.getId();

		final List<EObject> eObjects = new ArrayList<EObject>();
		if (baseVersionSpec != null) {
			eObjects.add(baseVersionSpec);
		}
		if (changePackage != null) {
			eObjects.add(changePackage);
		}
		if (sourceVersion != null) {
			eObjects.add(sourceVersion);
		}
		if (logMessage != null) {
			eObjects.add(logMessage);
		}
		if (targetBranch != null) {
			eObjects.add(targetBranch);
		}

		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(eObjects);

		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdPathParam).request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		final PrimaryVersionSpec baseVersionSpecResult = getEObjectFromResponse(response);

		return baseVersionSpecResult;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#getChanges(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec)
	 */
	public List<ChangePackage> getChanges(SessionId sessionId, ProjectId projectId,
		final VersionSpec sourceSpec, final VersionSpec targetSpec) throws ESException {

		PrimaryVersionSpec source;
		PrimaryVersionSpec target;
		// convert params to Strings
		final String projectIdAsString = projectId.getId();

		if (sourceSpec instanceof PrimaryVersionSpec) {
			source = (PrimaryVersionSpec) sourceSpec;
		} else {
			source = resolveVersionSpec(sessionId, projectId, sourceSpec);
		}
		if (targetSpec instanceof PrimaryVersionSpec) {
			target = (PrimaryVersionSpec) targetSpec;
		} else {
			target = resolveVersionSpec(sessionId, projectId, targetSpec);
		}

		final String sourceAsString = String
			.valueOf(source.getIdentifier());
		final String targetAsString = String
			.valueOf(target.getIdentifier());

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_CHANGES)
			.queryParam(SOURCE_VERSION_SPEC_QUERY_PARAM, sourceAsString)
			.queryParam(TARGET_VERSION_SPEC_QUERY_PARAM, targetAsString)
			.request(MediaType.APPLICATION_XML).get();

		checkResponseStatus(response);

		final List<ChangePackage> changes = TransferUtil
			.<ChangePackage> getEObjectListFromResponse(response);

		return changes;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#resolveVersionSpec(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec)
	 */
	public PrimaryVersionSpec resolveVersionSpec(SessionId sessionId, ProjectId projectId,
		VersionSpec versionSpec) throws ESException {

		// convert params
		final String projectIdAsString = projectId.getId();
		final List<VersionSpec> versionSpecList = new ArrayList<VersionSpec>();
		versionSpecList.add(versionSpec);
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(versionSpecList);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_RESOLVE_VERSION_SPEC)
			.request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		return getEObjectFromResponse(response);
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#getHistoryInfo(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.HistoryQuery)
	 */
	public List<HistoryInfo> getHistoryInfo(SessionId sessionId, ProjectId projectId,
		HistoryQuery<?> historyQuery) throws ESException {

		// convert params
		final String projectIdAsString = projectId.getId();
		@SuppressWarnings("rawtypes")
		final List<HistoryQuery> historyQueryList = new ArrayList<HistoryQuery>();
		historyQueryList.add(historyQuery);
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(historyQueryList);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_VERSIONS)
			.request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		final List<HistoryInfo> historyInfoList = TransferUtil
			.<HistoryInfo> getEObjectListFromResponse(response);

		return historyInfoList;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#addTag(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.TagVersionSpec)
	 */
	public void addTag(SessionId sessionId, ProjectId projectId, PrimaryVersionSpec versionSpec,
		TagVersionSpec tag) throws ESException {

		// convert params
		final String projectIdAsString = projectId.getId();
		final List<VersionSpec> versionSpecList = new ArrayList<VersionSpec>();
		versionSpecList.add(versionSpec);
		versionSpecList.add(tag);
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(versionSpecList);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_TAGS)
			.request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#removeTag(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec,
	 *      org.eclipse.emf.emfstore.internal.server.model.versioning.TagVersionSpec)
	 */
	public void removeTag(SessionId sessionId, ProjectId projectId, PrimaryVersionSpec versionSpec,
		TagVersionSpec tag) throws ESException {

		// convert params
		// TODO: ensure that it is compatible to all kinds of versionSpecs including the branch info!!!
		final String projectIdAsString = projectId.getId();
		final String primaryVersionSpecAsString = String.valueOf(versionSpec.getIdentifier());
		final String tagVersionSpecAsString = tag.getName(); // this is unique for identifying a TagVersionSpec

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_TAGS).path(primaryVersionSpecAsString).path(tagVersionSpecAsString)
			.request().delete();

		checkResponseStatus(response);

	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#setEMFProperties(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      java.util.List, org.eclipse.emf.emfstore.internal.server.model.ProjectId)
	 */
	public List<EMFStoreProperty> setEMFProperties(
		SessionId sessionId, List<EMFStoreProperty> property, ProjectId projectId) throws ESException {

		// convert params
		final String projectIdAsString = projectId.getId();
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectsToXmlIntoStreamingOutput(property);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_PROPERTIES)
			.request(MediaType.APPLICATION_XML)
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		final List<EMFStoreProperty> properties = TransferUtil
			.<EMFStoreProperty> getEObjectListFromResponse(response);

		return properties;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#getEMFProperties(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId)
	 */
	public List<EMFStoreProperty> getEMFProperties(SessionId sessionId, ProjectId projectId) throws ESException {

		// convert params to Strings
		final String projectIdAsString = projectId.getId();

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_PROPERTIES)
			.request(MediaType.APPLICATION_XML).get();

		checkResponseStatus(response);

		final List<EMFStoreProperty> properties = TransferUtil
			.<EMFStoreProperty> getEObjectListFromResponse(response);

		return properties;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#createEmptyProject(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      java.lang.String, java.lang.String, org.eclipse.emf.emfstore.internal.server.model.versioning.LogMessage)
	 */
	public ProjectInfo createEmptyProject(SessionId sessionId, String name,
		String description, LogMessage logMessage) throws ESException {

		return createProject(sessionId, name, description, logMessage, null);
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#resolveUser(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.accesscontrol.ACOrgUnitId)
	 */
	public ACUser resolveUser(SessionId sessionId, ACOrgUnitId id)
		throws ESException {

		final String username;
		if (id != null && id.getId() != null) {
			username = id.getId();
		} else {
			username = getConnectionProxy(sessionId).getUsername();
		}

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(USERS_PATH)
			.path(username)
			.request(MediaType.APPLICATION_XML).get();

		checkResponseStatus(response);

		final ACUser resolvedUser = getEObjectFromResponse(response);

		return resolvedUser;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#uploadFileChunk(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.filetransfer.FileChunk)
	 */
	public FileTransferInformation uploadFileChunk(SessionId sessionId,
		ProjectId projectId, FileChunk fileChunk) throws ESException {

		// convert params to Strings
		final String projectIdAsString = projectId.getId();
		final StreamingOutput streamingOutput = convertSerializableIntoStreamingOutput(fileChunk);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_FILES)
			.request(MediaType.WILDCARD).post(Entity.entity(streamingOutput, MediaType.WILDCARD));

		checkResponseStatus(response);

		FileTransferInformation fileTransferInformation = null;
		try {
			fileTransferInformation = TransferUtil
				.getFileTransferInformationFromResponse(response);
		} catch (final ClassNotFoundException e) {
			throw new ESException(e);
		} catch (final IOException e) {
			throw new ESException(e);
		}

		return fileTransferInformation;

	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#downloadFileChunk(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId,
	 *      org.eclipse.emf.emfstore.internal.server.filetransfer.FileTransferInformation)
	 */
	public FileChunk downloadFileChunk(SessionId sessionId,
		ProjectId projectId, FileTransferInformation fileInformation)
		throws ESException {

		// convert params to Strings
		final String projectIdAsString = projectId.getId();
		final String fileIdentifier = fileInformation.getFileIdentifier().getIdentifier(); // this identifier is unique
		final String chunkNumberAsString = String.valueOf(fileInformation.getChunkNumber());
		final String fileSizeAsString = String.valueOf(fileInformation.getFileSize());

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget().path(PROJECTS_PATH)
			.path(projectIdAsString)
			.path(PROJECTS_PATH_FILES)
			.path(fileIdentifier).path(chunkNumberAsString)
			.queryParam(FILE_SIZE_QUERY_PARAM, fileSizeAsString).request(MediaType.WILDCARD).get();

		checkResponseStatus(response);

		try {
			final FileChunk fileChunkFromResponse = getFileChunkFromResponse(response);
			return fileChunkFromResponse;
		} catch (final ClassNotFoundException e) {
			throw new ESException(e);
		} catch (final IOException e) {
			throw new ESException(e);
		}

	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#transmitProperty(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.emfstore.internal.server.model.accesscontrol.OrgUnitProperty,
	 *      org.eclipse.emf.emfstore.internal.server.model.accesscontrol.ACUser,
	 *      org.eclipse.emf.emfstore.internal.server.model.ProjectId)
	 */
	public void transmitProperty(SessionId sessionId,
		OrgUnitProperty changedProperty, ACUser tmpUser, ProjectId projectId)
		throws ESException {

		throw new UnsupportedOperationException();
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.server.EMFStore#registerEPackage(org.eclipse.emf.emfstore.internal.server.model.SessionId,
	 *      org.eclipse.emf.ecore.EPackage)
	 */
	public void registerEPackage(SessionId sessionId, EPackage pkg)
		throws ESException {

		// convert params
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectToXmlIntoStreamingOutput(pkg);

		// make http call
		final Response response = getConnectionProxy(sessionId).getTarget()
			.path(PACKAGES_PATH).request()
			.post(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.client.model.connectionmanager.ConnectionManager#logIn(java.lang.String,
	 *      java.lang.String, org.eclipse.emf.emfstore.internal.client.model.ServerInfo,
	 *      org.eclipse.emf.emfstore.internal.server.model.ClientVersionInfo)
	 */
	public AuthenticationInformation logIn(String username, String password,
		ServerInfo severInfo, ClientVersionInfo clientVersionInfo)
		throws ESException {

		// create clientManager which creates the WebTarget
		JaxrsClientManager clientManager;
		try {
			clientManager = new JaxrsClientManager(
				severInfo, username, password);
		} catch (final ESCertificateException ex) {
			throw new ESException(ex);
		}

		// retrieve ResolvedACUser from Server
		final ACUser acUser = resolveUserWithClientVersionInfo(clientVersionInfo, clientManager);

		final SessionId sessionId = createSessionId(username);

		// create AuthenticationInformation
		final AuthenticationInformation authenticationInformation = org.eclipse.emf.emfstore.internal.server.model.ModelFactory.eINSTANCE
			.createAuthenticationInformation();
		authenticationInformation.setResolvedACUser(acUser);
		authenticationInformation.setSessionId(sessionId);

		// add the proxy to the map
		addConnectionProxy(authenticationInformation.getSessionId(), clientManager);

		return authenticationInformation;
	}

	/**
	 * resolve a User when he logs in, returns data needed to create the ConnectionProxy on client side
	 *
	 * @param clientVersionInfo
	 * @param clientManager
	 * @return the resolved ACUser
	 * @throws ESException
	 */
	private ACUser resolveUserWithClientVersionInfo(ClientVersionInfo clientVersionInfo,
		final JaxrsClientManager clientManager) throws ESException {
		final StreamingOutput streamingOutput = TransferUtil
			.convertEObjectToXmlIntoStreamingOutput(clientVersionInfo);
		final Response response = clientManager.getTarget().path(USERS_PATH)
			.path(clientManager.getUsername()).request(MediaType.APPLICATION_XML)
			.put(Entity.entity(streamingOutput, MediaType.APPLICATION_XML));

		checkResponseStatus(response);

		final ACUser acUser = getEObjectFromResponse(response);
		return acUser;
	}

	/**
	 * creates a local SessionId which is unique
	 *
	 * @param username
	 * @return a SessionId
	 */
	private SessionId createSessionId(String username) {

		final SessionId sessionId = org.eclipse.emf.emfstore.internal.server.model.ModelFactory.eINSTANCE
			.createSessionId();
		final String id = UUID.randomUUID().toString();
		sessionId.setId(id);
		return sessionId;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.client.model.connectionmanager.ConnectionManager#logout(org.eclipse.emf.emfstore.internal.server.model.SessionId)
	 */
	public void logout(SessionId sessionId) throws ESException {

		removeConnectionProxy(sessionId);
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.emfstore.internal.client.model.connectionmanager.ConnectionManager#isLoggedIn(org.eclipse.emf.emfstore.internal.server.model.SessionId)
	 */
	public boolean isLoggedIn(SessionId id) {

		return hasConnectionProxy(id);
	}

}