/*
    * $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.net.PasswordAuthentication;
  import java.util.ArrayList;
  import java.util.List;
  
  import com.mindtree.techworks.insight.receiver.WildCardMatcher;
  import com.sshtools.j2ssh.SftpClient;
  import com.sshtools.j2ssh.SshClient;
  import com.sshtools.j2ssh.authentication.AuthenticationProtocolState;
  import com.sshtools.j2ssh.authentication.PasswordAuthenticationClient;
  import com.sshtools.j2ssh.configuration.SshConnectionProperties;
  import com.sshtools.j2ssh.sftp.SftpFile;
  
  
  /**
   * 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 SFTPRemoteClient extends RemoteClient {
  
  	//
  	// Static block to register with the factory
  	//
  
  	static {
  		// This class handles only SFTP filesets
  		RemoteClientFactory.registerClient("SFTP_CLIENT",
  				SFTPRemoteClient.class);
  	}
  
  	//
  	// Constants
  	//
  
  	/**
  	 * Password Authentication to use for anonymous access
  	 */
  	public static final PasswordAuthentication anonPassAuth = new PasswordAuthentication(
  			"anonymous", "insight@mindtree.com".toCharArray());
  
  	//
  	// Instance variables
  	//
  
  	/**
  	 * SSH Client instance for the host
  	 */
  	private SshClient sshClient;
  
  	/**
  	 * The fileset driving this client
  	 */
  	SFTPFileset fileset;
  
  	/**
  	 * The SFTP Client
  	 */
  	private SftpClient sftpClient;
  
  	//
  	// 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.SFTP_FILESET
 				|| !(fileset instanceof SFTPFileset)) {
 			throw new RemoteClientException(
 					"This client can handle only SFTPFileset");
 		}
 		this.fileset = (SFTPFileset) fileset;
 
 	}
 	
 	/**
 	 * @see com.mindtree.techworks.insight.download.RemoteClient#downloadFile(java.lang.String)
 	 */
 	/*
 	 * The return type of this method is changed from String to String[]
 	 * in support of wild cards.
 	 */
 	protected String[] downloadFile (String fileName)
 			throws RemoteClientException {
 
 		isBusy = true;
 		checkConnection();
 		//Vector for storing the file names matching with the given pattern.
 		List matchingFileNames = new ArrayList(5);
 		//Vector for storing the file names of all the downloaded files.
 		List downloadedFiles = new ArrayList(5);
 		List remoteFiles;
 		File destinationFile = null;
 		FileOutputStream fos = null;
 		//Checks whether the file name has any wild cards. Currently supporting only the wild card '*'.
 		if(WildCardMatcher.hasWildCardEntries(fileName)){
 			int fileSeperatorIndex = (fileName.lastIndexOf('\\') == -1) ? fileName.lastIndexOf('/') : fileName.lastIndexOf('\\');  
 			String remoteDirectory = (fileName.substring(0, fileSeperatorIndex));
 			String pattern = (fileName.substring(fileSeperatorIndex + 1));
 			try{
 				//Fetches the file list from the remote directory
 				remoteFiles = sftpClient.ls(remoteDirectory);
 				//Gets the names of the files matching with the given pattern.
 				matchingFileNames = getMatchingFiles(remoteFiles, pattern);
 			}
 			catch(IOException ie){
 				throw new RemoteClientException("Could not read remote fileset", ie);
 			}
 		}
 		else{
 			matchingFileNames.add(fileName);
 		}
 		
 		for(int i = 0; i < matchingFileNames.size(); i++){
 			fileName = (String)matchingFileNames.get(i);
 			//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);
 			}
 
 			try {
 				// Get the destination file
 				sftpClient.get(fileName, fos);
 				downloadedFiles.add(destinationFile.getAbsolutePath());
 
 			} catch (IOException e) {
 				throw new RemoteClientException("Could not download file", e);
 			} finally {
 				isBusy = false;
 				// The stream is closed by the get method
 				try {
 					// Close the streams
 					fos.close();
 				} catch (IOException e1) {
 					// Cant do anything here... just ignore it
 				}
 			}
 		}
 		//Converts the vector downloaded Files to a string array.
 		String[] downloadedFileNames = new String[downloadedFiles.size()];
 		for(int i = 0; i < downloadedFiles.size(); i++){
 			downloadedFileNames[i] = (String)downloadedFiles.get(i);
 		}
 		// Return the paths of all files to the downloaded file.
 		return downloadedFileNames;
 	}
 
 	/**
 	 * Returns a vector of filenames matching the given pattern. 
 	 * @param remoteFiles	The list of remote files.
 	 * @param pattern	The pattern to be matched with.
 	 * @return	The matching file names as a vector.
 	 */
 	private List getMatchingFiles(List remoteFiles, String pattern){
 		//Vector for storing the file names matching the given pattern
 		List matchingFiles = new ArrayList(5);
 		for(int i = 0; i < remoteFiles.size(); i++){
 			String filePath = ((SftpFile)remoteFiles.get(i)).getAbsolutePath();
 			String fileName = ((SftpFile)remoteFiles.get(i)).getFilename();
 			//Checks whether the fileName matches the given wild card. 
 			WildCardMatcher matcher = new WildCardMatcher(pattern);
 			if(matcher.matches(fileName)){
 				matchingFiles.add(filePath);
 			}
 			else{
 			}
 		}
 		return matchingFiles;
 	}
 	
 	/**
 	 * @see com.mindtree.techworks.insight.download.RemoteClient#closeConnection()
 	 */
 	protected void closeConnection () throws RemoteClientException {
 
 		if (null != sshClient && sshClient.isConnected()) {
 			try {
 				sftpClient.quit();
 			} catch (IOException e) {
 				// Can't do anything here... just log it.
 				e.printStackTrace(System.err);
 			}
 			sshClient.disconnect();
 		}
 
 	}
 
 	//
 	// Private util methods
 	//
 
 	/**
 	 * Creates an SFTP Connection
 	 * 
 	 * @throws RemoteClientException If the connection cannot be opened
 	 */
 	private synchronized void createSftpConnection ()
 			throws RemoteClientException {
 
 		sshClient = new SshClient();
 
 		String host = fileset.getHost();
 		int port = fileset.getPort();
 		String startDirectory = fileset.getDefaultDirectory();
 		PasswordAuthentication passwordAuthentication = fileset
 				.getPasswordAuthentication();
 
 		// If the password is not set, use anonymous login
 		if (null == passwordAuthentication) {
 			passwordAuthentication = anonPassAuth;
 		}
 
 		// Properties to connect.
 		SshConnectionProperties sshConnectionProperties = new SshConnectionProperties();
 		sshConnectionProperties.setHost(host);
 		// The user might have specified the port to connect to (if other
 		// than the default SFTP port). URL API specifies that -1 is returned
 		// if no port is set. Otherwise the use the port.
 		if (port != -1) {
 			sshConnectionProperties.setPort(port);
 		}
 
 		// TODO Explore proxy connections and add here.
 
 		try {
 			sshClient.connect(sshConnectionProperties,
 					new SshKnownHostKeyVerification(insight));
 
 
 			// Authentication
 			// TODO Check if other authentication mechanishms are required
 			PasswordAuthenticationClient passwordAuthenticationClient = new PasswordAuthenticationClient();
 			passwordAuthenticationClient.setUsername(passwordAuthentication
 					.getUserName());
 			passwordAuthenticationClient.setPassword(new StringBuffer().append(
 					passwordAuthentication.getPassword()).toString());
 
 			if (sshClient.authenticate(passwordAuthenticationClient) != AuthenticationProtocolState.COMPLETE) {
 				throw new RemoteClientException(
 						"Could not complete authentication!");
 			}
 
 			sftpClient = sshClient.openSftpClient();
 
 			// Change directory if required
 			if (null != startDirectory && startDirectory.length() > 0) {
 				sftpClient.cd(startDirectory);
 			}
 
 		} catch (IOException e) {
 			throw new RemoteClientException("Cannot open connection", e);
 		}
 	}
 
 	/**
 	 * Private method used to check if an open connection is present, else
 	 * creates one.
 	 * 
 	 * @throws RemoteClientException SFTPBrowseException is thrown if the
 	 *             connection cannot be opened.
 	 */
 	private void checkConnection () throws RemoteClientException {
 
 		if (null == sshClient || !sshClient.isConnected()) {
 			createSftpConnection();
 		}
 	}
 
 	//
 	// Class to monitor progress
 	//
 
 //	/**
 //	 * This class notifies the instance of progress.
 //	 * 
 //	 * @see FileTransferProgress FileTransferProgress
 //	 * @author Bindul Bhowmik
 //	 * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
 //	 */
 //	protected class SFTPTransferProgressMonitor implements FileTransferProgress {
 //
 //		/**
 //		 * Indicates total bytes to download
 //		 */
 //		private long totalBytes;
 //
 //		/**
 //		 * The file being downloaded
 //		 */
 //		private String fileName;
 //
 //		/**
 //		 * Creates a SFTPTransferProgressMonitor instance
 //		 */
 //		public SFTPTransferProgressMonitor () {
 //
 //			// Nothing to do
 //		}
 //
 //		/**
 //		 * @see com.sshtools.j2ssh.FileTransferProgress#started(long,
 //		 *      java.lang.String)
 //		 */
 //		public void started (long bytesTotal, String remoteFile) {
 //
 //			this.totalBytes = bytesTotal;
 //			this.fileName = remoteFile;
 //			if (null != statusBar) {
 //				statusBar.setDisplayText(1, InsightConstants
 //						.getLiteral("DOWNLOAD_SFTP_FILE")
 //						+ fileName, true);
 //			}
 //
 //		}
 //
 //		/**
 //		 * @see com.sshtools.j2ssh.FileTransferProgress#isCancelled()
 //		 */
 //		public boolean isCancelled () {
 //
 //			//If cancel option is to be provided, modify here.
 //			return false;
 //		}
 //
 //		/**
 //		 * @see com.sshtools.j2ssh.FileTransferProgress#progressed(long)
 //		 */
 //		public void progressed (long bytesSoFar) {
 //
 //			long progress = Math.round(((float)bytesSoFar / totalBytes) * 100);
 //			if (null != statusBar) {
 //				statusBar
 //						.setDisplayText(1, InsightConstants
 //								.getLiteral("DOWNLOAD_SFTP_FILE")
 //								+ fileName
 //								+ " "
 //								+ String.valueOf(progress)
 //								+ "%", true);
 //			}
 //
 //		}
 //
 //		/**
 //		 * @see com.sshtools.j2ssh.FileTransferProgress#completed()
 //		 */
 //		public void completed () {
 //
 //			if (null != statusBar) {
 //				statusBar.setDisplayText(0, InsightConstants
 //						.getLiteral("DOWNLOAD_SFTP_FILE_COMPLETE" + fileName),
 //						false);
 //				statusBar.clearDisplay(1);
 //			}
 //		}
 //	}
 
 }