/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.mindtree.techworks.insight.download;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  
  import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
  import org.apache.commons.httpclient.HostConfiguration;
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpException;
  import org.apache.commons.httpclient.HttpStatus;
  import org.apache.commons.httpclient.NTCredentials;
  import org.apache.commons.httpclient.auth.AuthScope;
  import org.apache.commons.httpclient.methods.GetMethod;
  import org.apache.commons.httpclient.params.HttpMethodParams;
  
  import com.mindtree.techworks.insight.download.ProxyInfo.ProtocolProxyInfo;
  import com.mindtree.techworks.insight.preferences.util.PreferenceInterpreter;
  
  
  /**
   * TODO
   * 
   * @see com.mindtree.techworks.insight.download.RemoteClient RemoteClient
   * @author Bindul Bhowmik
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  public class HTTPRemoteClient extends RemoteClient {
  
  	//
  	// Static block to register with the factory
  	//
  	static {
  		// This class handles only HTTP filesets
  		RemoteClientFactory.registerClient("HTTP_CLIENT",
  				HTTPRemoteClient.class);
  	}
  
  	//
  	// Instance variables
  	//
  
  	/**
  	 * The HTTP fileset containing the host information
  	 */
  	private HTTPFileset fileset;
  
  	/**
  	 * The HTTP Client used for the downloads
  	 */
  	private HttpClient httpClient;
  
  	//
  	// Implemented abstract methods
  	//
  
  	/**
  	 * @see com.mindtree.techworks.insight.download.RemoteClient#setFileset(com.mindtree.techworks.insight.download.Fileset)
  	 */
  	protected void setFileset (Fileset fileset) throws RemoteClientException {
  
  		if (fileset.getType() != Fileset.HTTP_FILESET
  				|| !(fileset instanceof HTTPFileset)) {
  			throw new RemoteClientException(
  					"This client can handle only HTTPFileset");
  		}
  		this.fileset = (HTTPFileset) fileset;
  
  		// Initialize the client
  		initialize();
  
 	}
 
 	/**
 	 * @see com.mindtree.techworks.insight.download.RemoteClient#downloadFile(java.lang.String)
 	 */
 	/*
 	 * Return type chaged to String[] from String in synchronization with RemoteClient
 	 */
 	protected String[] downloadFile (String fileName)
 			throws RemoteClientException {
 
 		// System is busy
 		isBusy = true;
 
 		// Get the temporary file
 		File destinationFile = null;
 		FileOutputStream fos = null;
 		InputStream is = null;
 
 		// Set authentication if required
 		setAuthorization(fileName);
 
 		// Get the destination file
 		try {
 			destinationFile = getDestinationFile(fileName, '/');
 			fos = new FileOutputStream(destinationFile);
 		} catch (FileNotFoundException e) {
 			// Should never get here...
 			throw new RemoteClientException(
 					"Could not write to temporary file.", e);
 		} catch (IOException e) {
 			throw new RemoteClientException("Could not create temporary file.",
 					e);
 		}
 
 		// Get the method
 		GetMethod getMethod = new GetMethod(fileName);
 
 		// Retry logic
 		DefaultHttpMethodRetryHandler retryHandler = new DefaultHttpMethodRetryHandler(0, false);
 		httpClient.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, retryHandler);
 
 		try {
 			// Execute
 			int statusCode = httpClient.executeMethod(getMethod);
 
 			// Check the status code
 			if (statusCode != HttpStatus.SC_OK) {
 				throw new RemoteClientException(
 						"Could not complete HTTP GET : "
 								+ getMethod.getStatusLine());
 			}
 
 			is = getMethod.getResponseBodyAsStream();
 			int byteToRead;
 			byteToRead = is.read();
 			while (byteToRead != -1) {
 				fos.write(byteToRead);
 				byteToRead = is.read();
 			}
 
 		} catch (HttpException e) {
 			throw new RemoteClientException("Could not complete HTTP GET : "
 					+ e.getMessage(), e);
 		} catch (IOException e) {
 			throw new RemoteClientException("Could not complete HTTP GET : "
 					+ e.getMessage(), e);
 		} finally {
 			getMethod.releaseConnection();
 			try {
 				fos.close();
 			} catch (IOException ioe) {
 				// Cannot do anything here!
 				ioe.printStackTrace(System.err);
 			}
 			try {
 				if (null != is) {
 					is.close();
 				}
 			} catch (IOException ioe) {
 				// Cannot do anything here!
 				ioe.printStackTrace(System.err);
 			}
 			isBusy = false;
 		}
 		/*
 		 * Changed in support of wild cards. The new downloaded file set is returned as an array of strings.
 		 */
 		String[] stringArray = new String[1];
 		stringArray[0] = destinationFile.getAbsolutePath();
 		// Return the path to the downloaded file
 		return stringArray;
 	}
 
 	/**
 	 * @see com.mindtree.techworks.insight.download.RemoteClient#closeConnection()
 	 */
 	protected void closeConnection () throws RemoteClientException {
 
 		// Nothing to do for HTTP Client
 
 	}
 
 	//
 	// Util Methods
 	//
 
 	/**
 	 * Sets up the client and other configurations
 	 */
 	private void initialize () {
 
 		HostConfiguration hostConfiguration = new HostConfiguration();
 		httpClient = new HttpClient();
 
 		// Proxy information
 		if (!fileset.isIgnoreProxy()) {
 			ProxyInfo proxyInfo = PreferenceInterpreter.getProxyInfo();
 			ProtocolProxyInfo httpProxyInfo = proxyInfo.getHttpProxyInfo();
 			// Set the proxy information if proxy is set in preferences.
 			if (null != httpProxyInfo && httpProxyInfo.isSet()) {
 				hostConfiguration.setProxy(httpProxyInfo.getHost(),
 						httpProxyInfo.getPort());
 
 				if (proxyInfo.isAuthenticationRequired()) {
 
 					NTCredentials credentials = getNTCredentials(proxyInfo
 							.getPasswordInformation().getUserName(),
 							new StringBuffer().append(
 									proxyInfo.getPasswordInformation()
 											.getPassword()).toString(),
 							httpProxyInfo.getHost());
 
 					// Set the proxy credentials
 					AuthScope authscope = new AuthScope(httpProxyInfo.getHost(), httpProxyInfo.getPort());
 					httpClient.getState().setProxyCredentials(authscope, credentials);
 				}
 			}
 		}
 
 		httpClient.setHostConfiguration(hostConfiguration);
 	}
 
 	/**
 	 * Sets the authorization credentials on the HTTP client for the url passed.
 	 * This method is used to set the password credentials on the client per
 	 * host rather than set a default authentication credential, so that if the
 	 * instance of the host is reused, hosts which do not require this
 	 * authorization are not passed the credentials.
 	 * 
 	 * @param url The url from which host is to be taken for setting the
 	 *            password credentials.
 	 */
 	private void setAuthorization (String url) {
 
 		// Authorization on the host
 		if (fileset.isAuthenticationRequired()) {
 			try {
 				URL theURL = new URL(url);
 				NTCredentials credentials = getNTCredentials(fileset
 						.getUserName(), fileset.getPassword(), theURL.getHost());
 				AuthScope authScope = new AuthScope(theURL.getHost(), (theURL
 						.getPort() == -1) ? theURL.getDefaultPort() : theURL
 						.getPort());
 				httpClient.getState().setCredentials(authScope, credentials);
 			} catch (MalformedURLException e) {
 				// Just don't do authorization here!
 				e.printStackTrace(System.err);
 			}
 		}
 	}
 
 	/**
 	 * Creates a NTCredentials object from the information passed. This is used
 	 * for any authentication for the HTTPClient.
 	 * 
 	 * @param user The username
 	 * @param password The password to use for authentication
 	 * @param host The host on which this authorization is to be used.
 	 * @return A {@link NTCredentials NTCredentials}object containing the
 	 *         information.
 	 */
 	private NTCredentials getNTCredentials (String user, String password,
 			String host) {
 
 		String domain = null;
 		String userName = user;
 
 		// If the username contains the domain name, split them. For example,
 		// if the username entered is 'DOMAIN\\user', at the end of this
 		// operation, domain should contain 'DOMAIN' and userName 'user'
 		if (userName.indexOf('\\') > -1) {
 			domain = userName.substring(0, userName.indexOf('\\'));
 			userName = userName.substring(userName.indexOf('\\') + 1);
 		}
 
 		return new NTCredentials(userName, password, host, domain);
 	}
 
 }