/*
    * Copyright (C) 2007-2012 Argeo GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *         http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.argeo.slc.repo;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.Set;
  import java.util.StringTokenizer;
  import java.util.TreeSet;
  import java.util.jar.Attributes;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  import java.util.jar.JarInputStream;
  import java.util.jar.JarOutputStream;
  import java.util.jar.Manifest;
  import java.util.zip.ZipInputStream;
  
  import javax.jcr.Credentials;
  import javax.jcr.GuestCredentials;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.Repository;
  import javax.jcr.RepositoryException;
  import javax.jcr.RepositoryFactory;
  import javax.jcr.Session;
  import javax.jcr.SimpleCredentials;
  import javax.jcr.nodetype.NodeType;
  
  import org.apache.commons.io.FilenameUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.argeo.cms.ArgeoNames;
  import org.argeo.cms.ArgeoTypes;
  import org.argeo.jcr.JcrMonitor;
  import org.argeo.jcr.JcrUtils;
  import org.argeo.node.NodeUtils;
  import org.argeo.node.security.Keyring;
  import org.argeo.slc.DefaultNameVersion;
  import org.argeo.slc.NameVersion;
  import org.argeo.slc.SlcException;
  import org.argeo.slc.SlcNames;
  import org.argeo.slc.SlcTypes;
  import org.argeo.slc.repo.maven.ArtifactIdComparator;
  import org.argeo.slc.repo.maven.MavenConventionsUtils;
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.artifact.DefaultArtifact;
  import org.osgi.framework.Constants;
  
  /** Utilities around repo */
  public class RepoUtils implements ArgeoNames, SlcNames {
  	private final static Log log = LogFactory.getLog(RepoUtils.class);
  
  	/** Packages a regular sources jar as PDE source. */
  	public static void packagesAsPdeSource(File sourceFile,
  			NameVersion nameVersion, OutputStream out) throws IOException {
  		if (isAlreadyPdeSource(sourceFile)) {
  			FileInputStream in = new FileInputStream(sourceFile);
  			IOUtils.copy(in, out);
  			IOUtils.closeQuietly(in);
  		} else {
  			String sourceSymbolicName = nameVersion.getName() + ".source";
  
  			Manifest sourceManifest = null;
  			sourceManifest = new Manifest();
  			sourceManifest.getMainAttributes().put(
  					Attributes.Name.MANIFEST_VERSION, "1.0");
  			sourceManifest.getMainAttributes().putValue("Bundle-SymbolicName",
  					sourceSymbolicName);
  			sourceManifest.getMainAttributes().putValue("Bundle-Version",
  					nameVersion.getVersion());
  			sourceManifest.getMainAttributes().putValue(
  					"Eclipse-SourceBundle",
  					nameVersion.getName() + ";version="
  							+ nameVersion.getVersion());
  			copyJar(sourceFile, out, sourceManifest);
  		}
  	}
 
 	public static byte[] packageAsPdeSource(InputStream sourceJar,
 			NameVersion nameVersion) {
 		String sourceSymbolicName = nameVersion.getName() + ".source";
 
 		Manifest sourceManifest = null;
 		sourceManifest = new Manifest();
 		sourceManifest.getMainAttributes().put(
 				Attributes.Name.MANIFEST_VERSION, "1.0");
 		sourceManifest.getMainAttributes().putValue("Bundle-SymbolicName",
 				sourceSymbolicName);
 		sourceManifest.getMainAttributes().putValue("Bundle-Version",
 				nameVersion.getVersion());
 		sourceManifest.getMainAttributes().putValue("Eclipse-SourceBundle",
 				nameVersion.getName() + ";version=" + nameVersion.getVersion());
 
 		return modifyManifest(sourceJar, sourceManifest);
 	}
 
 	/**
 	 * Check whether the file as already been packaged as PDE source, in order
 	 * not to mess with Jar signing
 	 */
 	private static boolean isAlreadyPdeSource(File sourceFile) {
 		JarInputStream jarInputStream = null;
 
 		try {
 			jarInputStream = new JarInputStream(new FileInputStream(sourceFile));
 
 			Manifest manifest = jarInputStream.getManifest();
 			Iterator<?> it = manifest.getMainAttributes().keySet().iterator();
 			boolean res = false;
 			// containsKey() does not work, iterating...
 			while (it.hasNext())
 				if (it.next().toString().equals("Eclipse-SourceBundle")) {
 					res = true;
 					break;
 				}
 			// boolean res = manifest.getMainAttributes().get(
 			// "Eclipse-SourceBundle") != null;
 			if (res)
 				log.info(sourceFile + " is already a PDE source");
 			return res;
 		} catch (Exception e) {
 			// probably not a jar, skipping
 			if (log.isDebugEnabled())
 				log.debug("Skipping " + sourceFile + " because of "
 						+ e.getMessage());
 			return false;
 		} finally {
 			IOUtils.closeQuietly(jarInputStream);
 		}
 	}
 
 	/**
 	 * Copy a jar, replacing its manifest with the provided one
 	 * 
 	 * @param manifest
 	 *            can be null
 	 */
 	private static void copyJar(File source, OutputStream out, Manifest manifest)
 			throws IOException {
 		JarFile sourceJar = null;
 		JarOutputStream output = null;
 		try {
 			output = manifest != null ? new JarOutputStream(out, manifest)
 					: new JarOutputStream(out);
 			sourceJar = new JarFile(source);
 
 			entries: for (Enumeration<?> entries = sourceJar.entries(); entries
 					.hasMoreElements();) {
 				JarEntry entry = (JarEntry) entries.nextElement();
 				if (manifest != null
 						&& entry.getName().equals("META-INF/MANIFEST.MF"))
 					continue entries;
 
 				InputStream entryStream = sourceJar.getInputStream(entry);
 				JarEntry newEntry = new JarEntry(entry.getName());
 				// newEntry.setMethod(JarEntry.DEFLATED);
 				output.putNextEntry(newEntry);
 				IOUtils.copy(entryStream, output);
 			}
 		} finally {
 			IOUtils.closeQuietly(output);
 			try {
 				if (sourceJar != null)
 					sourceJar.close();
 			} catch (IOException e) {
 				// silent
 			}
 		}
 	}
 
 	/** Copy a jar changing onlythe manifest */
 	public static void copyJar(InputStream in, OutputStream out,
 			Manifest manifest) {
 		JarInputStream jarIn = null;
 		JarOutputStream jarOut = null;
 		try {
 			jarIn = new JarInputStream(in);
 			jarOut = new JarOutputStream(out, manifest);
 			JarEntry jarEntry = null;
 			while ((jarEntry = jarIn.getNextJarEntry()) != null) {
 				if (!jarEntry.getName().equals("META-INF/MANIFEST.MF")) {
 					JarEntry newJarEntry = new JarEntry(jarEntry.getName());
 					jarOut.putNextEntry(newJarEntry);
 					IOUtils.copy(jarIn, jarOut);
 					jarIn.closeEntry();
 					jarOut.closeEntry();
 				}
 			}
 		} catch (IOException e) {
 			throw new SlcException("Could not copy jar with MANIFEST "
 					+ manifest.getMainAttributes(), e);
 		} finally {
 			if (!(in instanceof ZipInputStream))
 				IOUtils.closeQuietly(jarIn);
 			IOUtils.closeQuietly(jarOut);
 		}
 	}
 
 	/** Reads a jar file, modify its manifest */
 	public static byte[] modifyManifest(InputStream in, Manifest manifest) {
 		ByteArrayOutputStream out = new ByteArrayOutputStream(200 * 1024);
 		try {
 			copyJar(in, out, manifest);
 			return out.toByteArray();
 		} finally {
 			IOUtils.closeQuietly(out);
 		}
 	}
 
 	/** Read the OSGi {@link NameVersion} */
 	public static NameVersion readNameVersion(Artifact artifact) {
 		File artifactFile = artifact.getFile();
 		if (artifact.getExtension().equals("pom")) {
 			// hack to process jars which weirdly appear as POMs
 			File jarFile = new File(artifactFile.getParentFile(),
 					FilenameUtils.getBaseName(artifactFile.getPath()) + ".jar");
 			if (jarFile.exists()) {
 				log.warn("Use " + jarFile + " instead of " + artifactFile
 						+ " for " + artifact);
 				artifactFile = jarFile;
 			}
 		}
 		return readNameVersion(artifactFile);
 	}
 
 	/** Read the OSGi {@link NameVersion} */
 	public static NameVersion readNameVersion(File artifactFile) {
 		try {
 			return readNameVersion(new FileInputStream(artifactFile));
 		} catch (Exception e) {
 			// probably not a jar, skipping
 			if (log.isDebugEnabled()) {
 				log.debug("Skipping " + artifactFile + " because of " + e);
 				// e.printStackTrace();
 			}
 		}
 		return null;
 	}
 
 	/** Read the OSGi {@link NameVersion} */
 	public static NameVersion readNameVersion(InputStream in) {
 		JarInputStream jarInputStream = null;
 		try {
 			jarInputStream = new JarInputStream(in);
 			return readNameVersion(jarInputStream.getManifest());
 		} catch (Exception e) {
 			// probably not a jar, skipping
 			if (log.isDebugEnabled()) {
 				log.debug("Skipping because of " + e);
 			}
 		} finally {
 			IOUtils.closeQuietly(jarInputStream);
 		}
 		return null;
 	}
 
 	/** Read the OSGi {@link NameVersion} */
 	public static NameVersion readNameVersion(Manifest manifest) {
 		DefaultNameVersion nameVersion = new DefaultNameVersion();
 		nameVersion.setName(manifest.getMainAttributes().getValue(
 				Constants.BUNDLE_SYMBOLICNAME));
 
 		// Skip additional specs such as
 		// ; singleton:=true
 		if (nameVersion.getName().indexOf(';') > -1) {
 			nameVersion
 					.setName(new StringTokenizer(nameVersion.getName(), " ;")
 							.nextToken());
 		}
 
 		nameVersion.setVersion(manifest.getMainAttributes().getValue(
 				Constants.BUNDLE_VERSION));
 
 		return nameVersion;
 	}
 
 	/*
 	 * DATA MODEL
 	 */
 	/** The artifact described by this node */
 	public static Artifact asArtifact(Node node) throws RepositoryException {
 		if (node.isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
 			// FIXME update data model to store packaging at this level
 			String extension = "jar";
 			return new DefaultArtifact(node.getProperty(SLC_GROUP_ID)
 					.getString(),
 					node.getProperty(SLC_ARTIFACT_ID).getString(), extension,
 					node.getProperty(SLC_ARTIFACT_VERSION).getString());
 		} else if (node.isNodeType(SlcTypes.SLC_ARTIFACT)) {
 			return new DefaultArtifact(node.getProperty(SLC_GROUP_ID)
 					.getString(),
 					node.getProperty(SLC_ARTIFACT_ID).getString(), node
 							.getProperty(SLC_ARTIFACT_CLASSIFIER).getString(),
 					node.getProperty(SLC_ARTIFACT_EXTENSION).getString(), node
 							.getProperty(SLC_ARTIFACT_VERSION).getString());
 		} else if (node.isNodeType(SlcTypes.SLC_MODULE_COORDINATES)) {
 			return new DefaultArtifact(node.getProperty(SLC_CATEGORY)
 					.getString(), node.getProperty(SLC_NAME).getString(),
 					"jar", node.getProperty(SLC_VERSION).getString());
 		} else {
 			throw new SlcException("Unsupported node type for " + node);
 		}
 	}
 
 	/**
 	 * The path to the PDE source related to this artifact (or artifact version
 	 * base). There may or there may not be a node at this location (the
 	 * returned path will typically be used to test whether PDE sources are
 	 * attached to this artifact).
 	 */
 	public static String relatedPdeSourcePath(String artifactBasePath,
 			Node artifactNode) throws RepositoryException {
 		Artifact artifact = asArtifact(artifactNode);
 		Artifact pdeSourceArtifact = new DefaultArtifact(artifact.getGroupId(),
 				artifact.getArtifactId() + ".source", artifact.getExtension(),
 				artifact.getVersion());
 		return MavenConventionsUtils.artifactPath(artifactBasePath,
 				pdeSourceArtifact);
 	}
 
 	/**
 	 * Copy this bytes array as an artifact, relative to the root of the
 	 * repository (typically the workspace root node)
 	 */
 	public static Node copyBytesAsArtifact(Node artifactsBase,
 			Artifact artifact, byte[] bytes) throws RepositoryException {
 		String parentPath = MavenConventionsUtils.artifactParentPath(
 				artifactsBase.getPath(), artifact);
 		Node folderNode = JcrUtils.mkfolders(artifactsBase.getSession(),
 				parentPath);
 		return JcrUtils.copyBytesAsFile(folderNode,
 				MavenConventionsUtils.artifactFileName(artifact), bytes);
 	}
 
 	private RepoUtils() {
 	}
 
 	/** If a source return the base bundle name, does not change otherwise */
 	public static String extractBundleNameFromSourceName(String sourceBundleName) {
 		if (sourceBundleName.endsWith(".source"))
 			return sourceBundleName.substring(0, sourceBundleName.length()
 					- ".source".length());
 		else
 			return sourceBundleName;
 	}
 
 	/*
 	 * SOFTWARE REPOSITORIES
 	 */
 
 	/** Retrieve repository based on information in the repo node */
 	public static Repository getRepository(RepositoryFactory repositoryFactory,
 			Keyring keyring, Node repoNode) {
 		try {
 			Repository repository;
 			if (repoNode.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
 				String uri = repoNode.getProperty(ARGEO_URI).getString();
 				if (uri.startsWith("http")) {// http, https
 					repository = NodeUtils.getRepositoryByUri(
 							repositoryFactory, uri);
 				} else if (uri.startsWith("vm:")) {// alias
 					repository = NodeUtils.getRepositoryByUri(
 							repositoryFactory, uri);
 				} else {
 					throw new SlcException("Unsupported repository uri " + uri);
 				}
 				return repository;
 			} else {
 				throw new SlcException("Unsupported node type " + repoNode);
 			}
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot connect to repository " + repoNode,
 					e);
 		}
 	}
 
 	/**
 	 * Reads credentials from node, using keyring if there is a password. Can
 	 * return null if no credentials needed (local repo) at all, but returns
 	 * {@link GuestCredentials} if user id is 'anonymous' .
 	 */
 	public static Credentials getRepositoryCredentials(Keyring keyring,
 			Node repoNode) {
 		try {
 			if (repoNode.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
 				if (!repoNode.hasProperty(ARGEO_USER_ID))
 					return null;
 
 				String userId = repoNode.getProperty(ARGEO_USER_ID).getString();
 				if (userId.equals("anonymous"))// FIXME hardcoded userId
 					return new GuestCredentials();
 				char[] password = keyring.getAsChars(repoNode.getPath() + '/'
 						+ ARGEO_PASSWORD);
 				Credentials credentials = new SimpleCredentials(userId,
 						password);
 				return credentials;
 			} else {
 				throw new SlcException("Unsupported node type " + repoNode);
 			}
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot connect to repository " + repoNode,
 					e);
 		}
 	}
 
 	/**
 	 * Shortcut to retrieve a session given variable information: Handle the
 	 * case where we only have an URI of the repository, that we want to connect
 	 * as anonymous or the case of a identified connection to a local or remote
 	 * repository.
 	 * 
 	 * Callers must close the session once it has been used
 	 */
 	public static Session getRemoteSession(RepositoryFactory repositoryFactory,
 			Keyring keyring, Node repoNode, String uri, String workspaceName) {
 		try {
 			if (repoNode == null && uri == null)
 				throw new SlcException(
 						"At least one of repoNode and uri must be defined");
 			Repository currRepo = null;
 			Credentials credentials = null;
 			// Anonymous URI only workspace
 			if (repoNode == null)
 				// Anonymous
 				currRepo = NodeUtils.getRepositoryByUri(repositoryFactory, uri);
 			else {
 				currRepo = RepoUtils.getRepository(repositoryFactory, keyring,
 						repoNode);
 				credentials = RepoUtils.getRepositoryCredentials(keyring,
 						repoNode);
 			}
 			return currRepo.login(credentials, workspaceName);
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot connect to workspace "
 					+ workspaceName + " of repository " + repoNode
 					+ " with URI " + uri, e);
 		}
 	}
 
 	/**
 	 * Shortcut to retrieve a session on a remote Jrc Repository from
 	 * information stored in a local argeo node or from an URI: Handle the case
 	 * where we only have an URI of the repository, that we want to connect as
 	 * anonymous or the case of a identified connection to a local or remote
 	 * repository.
 	 * 
 	 * Callers must close the session once it has been used
 	 */
 	public static Session getRemoteSession(RepositoryFactory repositoryFactory,
 			Keyring keyring, Repository localRepository, String repoNodePath,
 			String uri, String workspaceName) {
 		Session localSession = null;
 		Node repoNode = null;
 		try {
 			localSession = localRepository.login();
 			if (repoNodePath != null && localSession.nodeExists(repoNodePath))
 				repoNode = localSession.getNode(repoNodePath);
 
 			return RepoUtils.getRemoteSession(repositoryFactory, keyring,
 					repoNode, uri, workspaceName);
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot log to workspace " + workspaceName
 					+ " for repo defined in " + repoNodePath, e);
 		} finally {
 			JcrUtils.logoutQuietly(localSession);
 		}
 	}
 
 	/**
 	 * Write group indexes: 'binaries' lists all bundles and their versions,
 	 * 'sources' list their sources, and 'sdk' aggregates both.
 	 */
 	public static void writeGroupIndexes(Session session,
 			String artifactBasePath, String groupId, String version,
 			Set<Artifact> binaries, Set<Artifact> sources) {
 		try {
 			Set<Artifact> indexes = new TreeSet<Artifact>(
 					new ArtifactIdComparator());
 			Artifact binariesArtifact = writeIndex(session, artifactBasePath,
 					groupId, RepoConstants.BINARIES_ARTIFACT_ID, version,
 					binaries);
 			indexes.add(binariesArtifact);
 			if (sources != null) {
 				Artifact sourcesArtifact = writeIndex(session,
 						artifactBasePath, groupId,
 						RepoConstants.SOURCES_ARTIFACT_ID, version, sources);
 				indexes.add(sourcesArtifact);
 			}
 			// sdk
 			writeIndex(session, artifactBasePath, groupId,
 					RepoConstants.SDK_ARTIFACT_ID, version, indexes);
 			session.save();
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot write indexes for group " + groupId,
 					e);
 		}
 	}
 
 	/** Write a group index. */
 	private static Artifact writeIndex(Session session,
 			String artifactBasePath, String groupId, String artifactId,
 			String version, Set<Artifact> artifacts) throws RepositoryException {
 		Artifact artifact = new DefaultArtifact(groupId, artifactId, "pom",
 				version);
 		String pom = MavenConventionsUtils.artifactsAsDependencyPom(artifact,
 				artifacts, null);
 		Node node = RepoUtils.copyBytesAsArtifact(
 				session.getNode(artifactBasePath), artifact, pom.getBytes());
 		addMavenChecksums(node);
 		return artifact;
 	}
 
 	/** Add files containing the SHA-1 and MD5 checksums. */
 	public static void addMavenChecksums(Node node) throws RepositoryException {
 		// TODO optimize
 		String sha = JcrUtils.checksumFile(node, "SHA-1");
 		JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".sha1",
 				sha.getBytes());
 		String md5 = JcrUtils.checksumFile(node, "MD5");
 		JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".md5",
 				md5.getBytes());
 	}
 
 	/**
 	 * Custom copy since the one in commons does not fit the needs when copying
 	 * a workspace completely.
 	 */
 	public static void copy(Node fromNode, Node toNode) {
 		copy(fromNode, toNode, null);
 	}
 
 	public static void copy(Node fromNode, Node toNode, JcrMonitor monitor) {
 		try {
 			String fromPath = fromNode.getPath();
 			if (monitor != null)
 				monitor.subTask("copying node :" + fromPath);
 			if (log.isDebugEnabled())
 				log.debug("copy node :" + fromPath);
 
 			// FIXME : small hack to enable specific workspace copy
 			if (fromNode.isNodeType("rep:ACL")
 					|| fromNode.isNodeType("rep:system")) {
 				if (log.isTraceEnabled())
 					log.trace("node " + fromNode + " skipped");
 				return;
 			}
 
 			// add mixins
 			for (NodeType mixinType : fromNode.getMixinNodeTypes()) {
 				toNode.addMixin(mixinType.getName());
 			}
 
 			// Double check
 			for (NodeType mixinType : toNode.getMixinNodeTypes()) {
 				if (log.isDebugEnabled())
 					log.debug(mixinType.getName());
 			}
 
 			// process properties
 			PropertyIterator pit = fromNode.getProperties();
 			properties: while (pit.hasNext()) {
 				Property fromProperty = pit.nextProperty();
 				String propName = fromProperty.getName();
 				try {
 					String propertyName = fromProperty.getName();
 					if (toNode.hasProperty(propertyName)
 							&& toNode.getProperty(propertyName).getDefinition()
 									.isProtected())
 						continue properties;
 
 					if (fromProperty.getDefinition().isProtected())
 						continue properties;
 
 					if (propertyName.equals("jcr:created")
 							|| propertyName.equals("jcr:createdBy")
 							|| propertyName.equals("jcr:lastModified")
 							|| propertyName.equals("jcr:lastModifiedBy"))
 						continue properties;
 
 					if (fromProperty.isMultiple()) {
 						toNode.setProperty(propertyName,
 								fromProperty.getValues());
 					} else {
 						toNode.setProperty(propertyName,
 								fromProperty.getValue());
 					}
 				} catch (RepositoryException e) {
 					throw new SlcException("Cannot property " + propName, e);
 				}
 			}
 
 			// recursively process children nodes
 			NodeIterator nit = fromNode.getNodes();
 			while (nit.hasNext()) {
 				Node fromChild = nit.nextNode();
 				Integer index = fromChild.getIndex();
 				String nodeRelPath = fromChild.getName() + "[" + index + "]";
 				Node toChild;
 				if (toNode.hasNode(nodeRelPath))
 					toChild = toNode.getNode(nodeRelPath);
 				else
 					toChild = toNode.addNode(fromChild.getName(), fromChild
 							.getPrimaryNodeType().getName());
 				copy(fromChild, toChild);
 			}
 
 			// update jcr:lastModified and jcr:lastModifiedBy in toNode in
 			// case
 			// they existed
 			if (!toNode.getDefinition().isProtected()
 					&& toNode.isNodeType(NodeType.MIX_LAST_MODIFIED))
 				JcrUtils.updateLastModified(toNode);
 
 			// Workaround to reduce session size: artifact is a saveable
 			// unity
 			if (toNode.isNodeType(SlcTypes.SLC_ARTIFACT))
 				toNode.getSession().save();
 
 			if (monitor != null)
 				monitor.worked(1);
 
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot copy " + fromNode + " to " + toNode,
 					e);
 		}
 	}
 
 }