/*
    * $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.InetAddress;
  import java.net.PasswordAuthentication;
  import java.net.SocketException;
  import java.net.URL;
  import java.net.UnknownHostException;
  import java.util.List;
  import java.util.ArrayList;
  
  import org.apache.commons.net.ftp.FTPClient;
  import org.apache.commons.net.ftp.FTPReply;
  import org.apache.commons.net.ftp.FTPFile;
  
  import com.mindtree.techworks.insight.download.ftpbrowse.FTPBrowseException;
  import com.mindtree.techworks.insight.receiver.WildCardMatcher;
  
  
  
  /**
   * TODO
   * 
   * @see com.mindtree.techworks.insight.download.RemoteClientFactory RemoteClientFactory
   * @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 FTPRemoteClient extends RemoteClient {
  	
  	//
  	// Static block to register with the factory
  	//
  	static {
  		// This class handles only FTP filesets
  		RemoteClientFactory.registerClient("FTP_CLIENT", FTPRemoteClient.class);
  	}
  	
  	//
  	// Constants
  	//
  	
  	/**
  	 * Password Authentication to use for anonymous access
  	 */
  	public static final PasswordAuthentication anonPassAuth = new PasswordAuthentication(
  			"anonymous", "insight@mindtree.com".toCharArray());
  	
  	//
  	// Instance variables
  	//
  	
  	/**
  	 * The FTPFileset used to connect to the host
  	 */
  	private FTPFileset fileset;
  	
  	/**
  	 * FTPClient used to connect to the host.
  	 */
  	private FTPClient ftpClient;
  	
  	//
  	// 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.FTP_FILESET
 				|| !(fileset instanceof FTPFileset)) {
 			throw new RemoteClientException(
 			"This client can handle only FTPFileset");
 		}
 		this.fileset = (FTPFileset) fileset;
 		
 	}
 	
 	/**
 	 * @see com.mindtree.techworks.insight.download.RemoteClient#downloadFile(java.lang.String)
 	 */
 	/*
 	 * Signature changed in synchronization with RemoteClient
 	 */
 	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);
 		FTPFile[] remoteFiles;
 		File destinationFile = null;
 		FileOutputStream fos = null;
 		
 		//Checks whether the file name has any wild cards. 
 		//Presently 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 = ftpClient.listFiles(remoteDirectory);
 						List remoteFilesList = new ArrayList(remoteFiles.length);
 						for(int i = 0; i < remoteFiles.length; i++){
 							remoteFilesList.add(remoteFiles[i].getName());
 						}
 						//Gets the names of the files matching with the given pattern.
 						matchingFileNames = getMatchingFiles(remoteFilesList, pattern);
 					}
 					catch(IOException ie){
 						throw new RemoteClientException("Couldn't open a " +
 								"connection with the remote client", 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
 				if (!ftpClient.retrieveFile(fileName, fos)) {
 					throw new RemoteClientException("Could not download file");
 				}
 				downloadedFiles.add(destinationFile.getAbsolutePath());
 			} catch (IOException e) {
 				throw new RemoteClientException("Could not download file", e);
 			} finally {
 				isBusy = false;
 				try {
 					// Close the streams
 					fos.close();
 				} catch (IOException e1) {
 					// Cant do anything here... just ignore it
 					e1.printStackTrace();
 				}
 			}
 		}
 		
 		//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){
 		
 		List matchingFiles = new ArrayList(5);
 		
 		for(int i = 0; i < remoteFiles.size(); i++){
 			String filePath = (String)remoteFiles.get(i);
 			int fileSeperatorIndex = (filePath.lastIndexOf('\\') == -1) ? filePath.lastIndexOf('/') : filePath.lastIndexOf('\\');
 			String fileName = filePath.substring(fileSeperatorIndex + 1);
 			//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 != ftpClient && ftpClient.isConnected()) {
 			try {
 				ftpClient.disconnect();
 			} catch (IOException e) {
 				throw new RemoteClientException("Problem closing connection.", e);
 			}
 		}
 	}
 	
 	//
 	// Private util methods
 	//
 	
 	/**
 	 * Creates an FTP Connection
 	 * 
 	 * @throws RemoteClientException If the connection cannot be opened
 	 */
 	private synchronized void createFTPConnection () throws RemoteClientException {
 		
 		ftpClient = new FTPClient();
 		try {
 			// Get the url and password from the fileset
 			URL url = fileset.getHostURL();
 			PasswordAuthentication passwordAuthentication = fileset
 			.getPasswordAuthentication();
 			
 			// If the password is not set, use anonymous login
 			if (null == passwordAuthentication) {
 				passwordAuthentication = anonPassAuth;
 			}
 			
 			InetAddress inetAddress = InetAddress.getByName(url.getHost());
 			// The user might have specified the port to connect to (if other
 			// than the default FTP port). URL API specifies that -1 is returned
 			// if no port is set. Otherwise the use the port.
 			if (url.getPort() == -1) {
 				ftpClient.connect(inetAddress);
 			} else {
 				ftpClient.connect(inetAddress, url.getPort());
 			}
 			
 			if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
 				throw new FTPBrowseException(ftpClient.getReplyString());
 			}
 			ftpClient.login(passwordAuthentication.getUserName(),
 					new StringBuffer().append(
 							passwordAuthentication.getPassword()).toString());
 			
 			if (url.getPath().length() > 0) {
 				ftpClient.changeWorkingDirectory(url.getPath());
 			}
 		} catch (UnknownHostException e) {
 			throw new RemoteClientException("Host not found.", e);
 		} catch (SocketException e) {
 			throw new RemoteClientException("Socket cannot be opened.", e);
 		} catch (IOException e) {
 			throw new RemoteClientException("Socket cannot be opened.", e);
 		}
 	}
 	
 	/**
 	 * Private method used to check if an open connection is present, else
 	 * creates one.
 	 *  
 	 * @throws RemoteClientException is thrown if the connection
 	 *             cannot be opened.
 	 */
 	private void checkConnection () throws RemoteClientException {
 		
 		if (null == ftpClient || !ftpClient.isConnected()) {
 			createFTPConnection();
 		}
 	}
 	
 }