package com.trendmicro.grid.acl.client;
   
   import com.trendmicro.grid.acl.PublicServiceDiscovery;
   import com.trendmicro.grid.acl.Service;
   import com.trendmicro.grid.acl.l0.*;
   import com.trendmicro.grid.acl.l0.datatypes.FileIdentifier;
   import net.sf.tinyjee.streams.ByteBufferOutputStream;
   import net.sf.tinyjee.ws.client.ClientServiceContext;
   
  import javax.xml.ws.WebServiceFeature;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.*;
  import java.security.DigestInputStream;
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.UUID;
  
  import static java.util.logging.Level.WARNING;
  import static java.util.logging.Logger.getLogger;
  
  /**
   * Implements a sharable, thread safe client to connect to the JAX-WS based web services.
   *
   * @author Juergen_Kellerer, 2010-05-16
   */
  public class ServiceClient {
  
  	static final int STREAM_BUFFER_SIZE = 8 * 1024;
  
  	/**
  	 * HACK: Hiding info logs on dynamically compiled client stubs as they pollute the
  	 * logs (especially when used in a CLI context).
  	 */
  	static {
  		if (!Boolean.getBoolean("gacl.jaxws.verbose")) {
  			getLogger("com.sun.xml.ws").setLevel(WARNING);
  			getLogger("javax.enterprise.resource.webservices").setLevel(WARNING);
  		}
  	}
  
  	private final String defaultHost;
  	private int defaultPortNumber;
  	private boolean defaultSecure;
  
  	private final ClientServiceContext context = new ClientServiceContext();
  
  	/**
  	 * Creates a new service client using built-in default settings.
  	 */
  	public ServiceClient() {
  		this(null, null);
  	}
  
  	/**
  	 * Creates a new service client using the given GRID ACL default host and an optional api-key.
  	 *
  	 * @param defaultHost the default hostname to use when retrieving a port using {@link #getPort(Class)}.
  	 * @param apiKey      an optional API key to use with SOAP calls (can be set to 'null' if not relevant).
  	 *                    If specified, connections are by default opened using a secured (SSL/TLS) connection.
  	 */
  	public ServiceClient(String defaultHost, UUID apiKey) {
  		// Level0 - Services
  		addDefinition(CacheControlService.class, "/ws/level-0/internal/cache-control", apiKey);
  		addDefinition(FileRequestService.class, "/ws/level-0/internal/filecontent-request", apiKey);
  		addDefinition(FileService.class, "/ws/level-0/internal/files", apiKey);
  		addDefinition(PackageService.class, "/ws/level-0/internal/packages", apiKey);
  		addDefinition(ProcessingService.class, "/ws/level-0/internal/processing", apiKey);
  		addDefinition(PublicAuthenticationService.class, "/ws/level-0/authentication", apiKey);
  		addDefinition(PublicCategoryService.class, "/ws/level-0/categories", apiKey);
  		addDefinition(PublicFileService.class, "/ws/level-0/files", apiKey);
  		addDefinition(PublicPackageService.class, "/ws/level-0/packages", apiKey);
  		addDefinition(PublicReportService.class, "/ws/level-0/reporting", apiKey);
  		addDefinition(SourceService.class, "/ws/level-0/internal/sources", apiKey);
  
  		// Other - Services
  		addDefinition(PublicServiceDiscovery.class, "/ws/discovery", apiKey);
  
  		this.defaultHost = defaultHost;
  		defaultSecure = apiKey != null;
  	}
  
  	/**
  	 * Creates a new service client for the given default hostname, port number and SSL option.
  	 *
  	 * @param defaultHost       the default hostname to use when retrieving a port using {@link #getPort(Class)}.
  	 * @param defaultPortNumber the port number of the ACL running on the given host. Use '0' to use the protocol's default port.
  	 * @param defaultSecure     toggles whether the service is by default accessed using a secured (SSL/TLS) connection.
  	 */
  	public ServiceClient(String defaultHost, int defaultPortNumber, boolean defaultSecure) {
  		this(defaultHost, defaultPortNumber, defaultSecure, null);
  	}
  
  	/**
 	 * Creates a new service client for the given default hostname, port number and SSL option.
 	 *
 	 * @param defaultHost       the default hostname to use when retrieving a port using {@link #getPort(Class)}.
 	 * @param defaultPortNumber the port number of the ACL running on the given host. Use '0' to use the protocol's default port.
 	 * @param defaultSecure     toggles whether the service is by default accessed using a secured (SSL/TLS) connection.
 	 * @param apiKey            an optional API key to use with SOAP calls. (can be set to 'null')
 	 */
 	public ServiceClient(String defaultHost, int defaultPortNumber, boolean defaultSecure, UUID apiKey) {
 		this(defaultHost, apiKey);
 		this.defaultPortNumber = defaultPortNumber;
 		this.defaultSecure = defaultSecure;
 	}
 
 	private void addDefinition(Class<? extends Service> endpointInterface, String path, UUID apiKey) {
 		if (!path.startsWith("/")) path = '/' + path;
 		if (apiKey != null) path += ";api-key=" + apiKey;
 
 		context.addDefinition(endpointInterface, endpointInterface.getSimpleName(), URI.create("http://localhost" + path + "?wsdl"));
 	}
 
 	/**
 	 * Returns the underlying client context instance.
 	 *
 	 * @return the underlying client context instance.
 	 */
 	public ClientServiceContext getContext() {
 		return context;
 	}
 
 	/**
 	 * Is a utility method that generates a file identifier from the given URL.
 	 *
 	 * @param source the source to generate the file-identifier of.
 	 * @return a fully qualified file identifier containing SHA1 and MD5.
 	 * @throws IOException in case of reading the source failed.
 	 */
 	public static FileIdentifier generateFileIdentifier(URL source) throws IOException {
 		final MessageDigest sha1, md5;
 		try {
 			sha1 = MessageDigest.getInstance("SHA1");
 			md5 = MessageDigest.getInstance("MD5");
 		} catch (NoSuchAlgorithmException e) {
 			throw new IOException(e);
 		}
 
 		final DigestInputStream sha1Stream = new DigestInputStream(source.openStream(), sha1);
 		final DigestInputStream md5Stream = new DigestInputStream(sha1Stream, md5);
 
 		copyAndClose(md5Stream, null);
 
 		return new FileIdentifier(sha1Stream.getMessageDigest().digest(), md5Stream.getMessageDigest().digest());
 	}
 
 	/**
 	 * Is a utility method that generates a file identifier from the given File.
 	 *
 	 * @param source the source to generate the file-identifier of.
 	 * @return a fully qualified file identifier containing SHA1 and MD5.
 	 * @throws IOException in case of reading the source failed.
 	 */
 	public static FileIdentifier generateFileIdentifier(File source) throws IOException {
 		return generateFileIdentifier(source.toURI().toURL());
 	}
 
 	/**
 	 * Gets content from the given URL using the same session as used with web-service calls.
 	 *
 	 * @param sourceUrl the URL to GET.
 	 * @return the input stream containing the content stream.
 	 * @throws IOException in case of reading the content failed.
 	 */
 	public InputStream getFromUrl(URL sourceUrl) throws IOException {
 		final URLConnection urlConnection = sourceUrl.openConnection();
 		configureWithSessionCookies(urlConnection);
 
 		return urlConnection.getInputStream();
 	}
 
 	/**
 	 * Gets content from the given URL using the same session as used with web-service calls and writes it to the provided output stream.
 	 * <p/>
 	 * This method has more advanced error reporting than {@link #getFromUrl(java.net.URL)} as it also evaluates HTTP response codes and
 	 * error replies from the server.
 	 *
 	 * @param sourceUrl    the URL to GET.
 	 * @param targetStream the target to write the content to.
 	 * @throws IOException In case of reading or writing the content failed.
 	 */
 	public void getFromUrl(URL sourceUrl, OutputStream targetStream) throws IOException {
 		final HttpURLConnection huc = (HttpURLConnection) sourceUrl.openConnection();
 		configureWithSessionCookies(huc);
 
 		try {
 			copyAndClose(huc.getInputStream(), targetStream);
 			if (huc.getResponseCode() >= 400) throw new IOException("Unexpected response code, should be < 400");
 		} catch (IOException e) {
 			String message = "Failed to GET content from URL '" + sourceUrl + '\'';
 			convertHttpErrorStream(huc, message, e);
 		}
 	}
 
 	/**
 	 * Puts content to the given URI using the same session as used with web-service calls.
 	 *
 	 * @param inputStream the stream of the content to put.
 	 * @param targetUrl   the target URL to put the content to.
 	 * @throws IOException In case of reading or writing the content failed.
 	 */
 	public void putToUrl(InputStream inputStream, URL targetUrl) throws IOException {
 		HttpURLConnection huc = preparePutToUrl(targetUrl);
 
 		try {
 			copyAndClose(inputStream, huc.getOutputStream());
 			if (huc.getResponseCode() >= 400) throw new IOException("Unexpected response code, should be < 400");
 		} catch (IOException e) {
 			String message = "Failed to send content via PUT to URL '" + targetUrl + '\'';
 			convertHttpErrorStream(huc, message, e);
 		}
 	}
 
 	/**
 	 * Prepares a HttpURLConnection to PUT content to the underlying URL using the same session as used with web-service calls.
 	 *
 	 * @param targetUrl the target URL to put the content to.
 	 * @return a configured HttpURLConnection instance that can be used for putting the content.
 	 * @throws IOException In case of reading or setting the cookies fails.
 	 */
 	public HttpURLConnection preparePutToUrl(URL targetUrl) throws IOException {
 		HttpURLConnection huc = (HttpURLConnection) targetUrl.openConnection();
 		huc.setRequestMethod("PUT");
 		huc.setDoOutput(true);
 		huc.setChunkedStreamingMode(STREAM_BUFFER_SIZE);
 
 		configureWithSessionCookies(huc);
 
 		return huc;
 	}
 
 	/**
 	 * Adds session cookies to the given http url connection.
 	 *
 	 * @param urlConnection the url connection to configure.
 	 * @throws IOException in case of the configuration failed.
 	 */
 	public void configureWithSessionCookies(URLConnection urlConnection) throws IOException {
 		try {
 			final CookieManager manager = context.getSessionHandler().getCookieManager();
 			final Map<String, List<String>> cookies = manager.get(urlConnection.getURL().toURI(), urlConnection.getRequestProperties());
 			for (Map.Entry<String, List<String>> entry : cookies.entrySet()) {
 				for (String cookieValue : entry.getValue())
 					urlConnection.addRequestProperty(entry.getKey(), cookieValue);
 			}
 		} catch (URISyntaxException e) {
 			throw new IOException(e);
 		}
 	}
 
 	public String getDefaultHost() {
 		return defaultHost;
 	}
 
 	public int getDefaultPortNumber() {
 		return defaultPortNumber;
 	}
 
 	public boolean isDefaultSecure() {
 		return defaultSecure;
 	}
 
 	/**
 	 * Returns a cached port (proxy) of the given endpoint interface using the specified default values for host, port-number and security.
 	 * <p/>
 	 * Look after implementations of {@link Service} to see what endpoint interfaces exist and can be used here.
 	 *
 	 * @param endpointInterface the interface describing the endpoint protocol.
 	 * @param <T>               the endpoint interface type.
 	 * @return a cached port (proxy) of the given endpoint interface.
 	 */
 	public <T extends Service> T getPort(Class<T> endpointInterface) {
 		return context.getPort(endpointInterface, defaultHost, defaultPortNumber, defaultSecure);
 	}
 
 	/**
 	 * Returns a cached port (proxy) of the given endpoint interface.
 	 * <p/>
 	 * Look after implementations of {@link Service} to see what endpoint interfaces exist and can be used here.
 	 *
 	 * @param endpointInterface the interface describing the endpoint protocol.
 	 * @param host              the hostname of the remote machine to connect to.
 	 * @param <T>               the endpoint interface type.
 	 * @return a cached port (proxy) of the given endpoint interface.
 	 */
 	public <T extends Service> T getPort(Class<T> endpointInterface, String host) {
 		return context.getPort(endpointInterface, host);
 	}
 
 	/**
 	 * Returns a cached port (proxy) of the given endpoint interface.
 	 * <p/>
 	 * Look after implementations of {@link Service} to see what endpoint interfaces exist and can be used here.
 	 *
 	 * @param endpointInterface the interface describing the endpoint protocol.
 	 * @param host              the hostname of the remote machine to connect to.
 	 * @param port              the port number of the remote machine to connect to.
 	 * @param secure            whether a secure transport should be chosen.
 	 * @param features          specifies additional standard or vendor specific features that
 	 *                          may be applied to the returned port proxy.
 	 * @param <T>               the endpoint interface type.
 	 * @return a cached port (proxy) of the given endpoint interface.
 	 */
 	public <T extends Service> T getPort(Class<T> endpointInterface, String host, int port, boolean secure, WebServiceFeature... features) {
 		return context.getPort(endpointInterface, host, port, secure, features);
 	}
 
 	/**
 	 * Returns all endpoint interfaces of the service definitions.
 	 *
 	 * @return all endpoint interfaces of the service definitions.
 	 */
 	@SuppressWarnings("unchecked")
 	public Collection<Class<? extends Service>> getDefinedPorts() {
 		return (Collection) context.getDefinedPorts();
 	}
 
 	private static void copyAndClose(InputStream in, OutputStream out) throws IOException {
 		try {
 			int r;
 			byte[] buffer = new byte[STREAM_BUFFER_SIZE];
 			while ((r = in.read(buffer)) != -1)
 				if (out != null) out.write(buffer, 0, r);
 		} finally {
 			in.close();
 			if (out != null) out.close();
 		}
 	}
 
 	private static void convertHttpErrorStream(HttpURLConnection huc, String message, IOException originalException) throws IOException {
 		String detailedErrorMessage = "--failed-to-retrieve-error-details--";
 		try {
 			ByteBufferOutputStream messageBuffer = new ByteBufferOutputStream();
 			copyAndClose(huc.getErrorStream(), messageBuffer);
 			detailedErrorMessage = messageBuffer.toString();
 		} catch (IOException ignore) {
 		}
 
 		throw new IOException(message + "; The server replied with:\n" +
 				huc.getResponseCode() + ' ' + huc.getResponseMessage() +
 				"\n\n" + detailedErrorMessage, originalException);
 	}
 }