/*
    * $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.sftpbrowse;
  
  import java.awt.Component;
  import java.io.File;
  import java.io.IOException;
  import java.net.PasswordAuthentication;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.filechooser.FileSystemView;
  
  import com.mindtree.techworks.insight.download.SshKnownHostKeyVerification;
  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.FileAttributes;
  import com.sshtools.j2ssh.sftp.SftpFile;
  
  
  /**
   * This class is used for browsing a remote file system. This class uses an
   * instance of the {@link com.sshtools.j2ssh.SftpClient SftpClient} to
   * connect to the underlying FTP Source. Connection timeouts may occur.
   * 
   * @see javax.swing.filechooser.FileSystemView FileSystemView
   * 
   * @author Bindul Bhowmik
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   * 
   */
  public class SFTPRemoteFileSystemView extends FileSystemView {
  	//
  	// Constants
  	//
  
  	/**
  	 * The logger instance for this class
  	 */
  	protected static final Logger logger = Logger
  			.getLogger(SFTPRemoteFileSystemView.class.getName());
  	
  	/**
  	 * Password Authentication to use for anonymous access
  	 */
  	public static final PasswordAuthentication anonPassAuth = new PasswordAuthentication(
  			"anonymous", "insight@mindtree.com".toCharArray());
  
  	/**
  	 * The root file system path
  	 */
  	protected static final String FILE_SYSTEM_ROOT_NAME = "/";
  
  	/**
  	 * Seperator character between files
  	 */
  	public static final String FILE_SEPERATOR = "/";
  	
  	//
  	// Instance variables
  	//
  
  	/**
  	 * Parent component used for messages
  	 */
  	private Component parentComponent;
  	
  	/**
  	 * The SSH Client used to create the SFTP Client
  	 */
  	private SshClient sshClient;
  	
 	/**
 	 * The SftpClient Object used to browse the underlying source.
 	 */
 	private SftpClient sftpClient;
 
 	/**
 	 * The host to connect to
 	 */
 	private String host;
 	
 	/**
 	 * The port to connect to
 	 */
 	private int port = -1;
 	
 	/**
 	 * The directory to start browsing in
 	 */
 	private String startDirectory;
 	
 	/**
 	 * The Authentication information
 	 */
 	private PasswordAuthentication passwordAuthentication;
 
 	/**
 	 * The default directory of the connection
 	 */
 	private String homeDirectory;
 
 	//
 	// Constructors
 	//
 
 	/**
 	 * Creates an instance of the <code>FTPRemoteFileSystemView</code>. The
 	 * host name supplied should be the same as one would pass to construct an
 	 * URL object.
 	 * 
 	 * @param host The address of the host. This can be a host name or IP
 	 *            address.
 	 * @param port The port to connect to.
 	 * @param startDirectory The directory to start browsing in
 	 * @param passwordAuthentication The credentials to connect with. This can
 	 *            be null.
 	 * @param parentComponent Parent component used for messages
 	 * @throws SFTPBrowseException If the host is null.
 	 */
 	public SFTPRemoteFileSystemView (String host, int port, String startDirectory, 
 			PasswordAuthentication passwordAuthentication, Component parentComponent)
 			throws SFTPBrowseException {
 
 
 		if (host == null || host.length() == 0) {
 			throw new SFTPBrowseException("Host null!");
 		}
 		
 		this.host = host;
 		this.startDirectory = startDirectory;
 		this.port = port;
 		this.parentComponent = parentComponent;
 		if (null != passwordAuthentication) {
 			this.passwordAuthentication = passwordAuthentication;
 		} else {
 			this.passwordAuthentication = anonPassAuth;
 		}
 	}
 
 	/**
 	 * Creates an instance of the <code>FTPRemoteFileSystemView</code>. The
 	 * host name supplied should be the same as one would pass to construct an
 	 * URL object.
 	 * 
 	 * @param host The address of the host. This can be a host name or IP
 	 *            address.
 	 * @param startDirectory The directory to start browsing in
 	 * @param passwordAuthentication The credentials to use to connect. Can be
 	 *            null.
 	 * @param parentComponent Parent component used for messages
 	 * @throws SFTPBrowseException if the host is null
 	 */
 	public SFTPRemoteFileSystemView (String host, String startDirectory, 
 			PasswordAuthentication passwordAuthentication, Component parentComponent)
 			throws SFTPBrowseException {
 
 		if (host == null || host.length() == 0) {
 			throw new SFTPBrowseException("Host null!");
 		}
 
 		this.host = host;
 		this.parentComponent = parentComponent;
 		this.startDirectory = startDirectory;
 		if (null != passwordAuthentication) {
 			this.passwordAuthentication = passwordAuthentication;
 		} else {
 			this.passwordAuthentication = anonPassAuth;
 		}
 
 	}
 	
 	//
 	// Accessors
 	//
 
 	/**
 	 * @return Returns the passwordAuthentication.
 	 */
 	public PasswordAuthentication getPasswordAuthentication () {
 
 		return passwordAuthentication;
 	}
 	
 	/**
 	 * @return Returns the host.
 	 */
 	public String getHost () {
 
 		return this.host;
 	}
 	
 	/**
 	 * @return The port to connect to.
 	 */
 	public int getPort() {
 		return this.port;
 	}
 	
 	//
 	// Utility Methods
 	//
 
 	/**
 	 * Creates an SFTP Connection
 	 * 
 	 * @throws SFTPBrowseException If the connection cannot be opened
 	 */
 	private synchronized void createSftpConnection () throws SFTPBrowseException {
 
 		sshClient = new SshClient();
 		
 		// Properties to connect.
 		SshConnectionProperties sshConnectionProperties = new SshConnectionProperties();
 		sshConnectionProperties.setHost(this.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 (this.port != -1) {
 			sshConnectionProperties.setPort(this.port);
 		}
 		
 		// TODO Explore proxy connections and add here.
 		
 		try {
 			sshClient.connect(sshConnectionProperties, new SshKnownHostKeyVerification(parentComponent));
 
 
 			// 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 SFTPBrowseException(
 						"Could not complete authentication!");
 			}
 
 			sftpClient = sshClient.openSftpClient();
 
 			// Change directory if required
 			if (null != this.startDirectory && this.startDirectory.length() > 0) {
 				sftpClient.cd(this.startDirectory);
 			}
 
 			homeDirectory = sftpClient.pwd();
 		} catch (IOException e) {
 			throw new SFTPBrowseException(e.getMessage());
 		}
 	}
 
 	/**
 	 * Private method used to check if an open connection is present, else
 	 * creates one.
 	 * 
 	 * @throws SFTPBrowseException SFTPBrowseException is thrown if the connection
 	 *             cannot be opened.
 	 */
 	private void checkConnection () throws SFTPBrowseException {
 
 		if (null == sshClient || !sshClient.isConnected()) {
 			createSftpConnection();
 		}
 	}
 	
 	//
 	// Public Methods
 	//
 	
 	/**
 	 * If a connection to the server is still open, disconnects it.
 	 */
 	public void disconnect () {
 
 		if (null != sshClient && sshClient.isConnected()) {
 			try {
 				sftpClient.quit();
 			} catch (IOException e) {
 				// Can't do anything here... just log it.
 				logger.log(Level.WARNING, "Could not close connection", e);
 			}
 			sshClient.disconnect();
 		}
 	}
 	
 	//
 	// Overridden methods from FileSystemView
 	//
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#createNewFolder(java.io.File)
 	 */
 	public File createNewFolder (File containingDir) throws IOException {
 
 		// This is a read only view of the remote system only.
 		throw new SFTPBrowseException(
 				"This file system view supports READ ONLY support ONLY!");
 	}
 
 	/**
 	 * In the remote view home and default directory are considered to be the
 	 * same.
 	 * 
 	 * @see javax.swing.filechooser.FileSystemView#getDefaultDirectory()
 	 */
 	public File getDefaultDirectory () {
 
 		return getHomeDirectory();
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#getHomeDirectory()
 	 */
 	public File getHomeDirectory () {
 
 		try {
 			checkConnection();
 			//If home directory is the root directory then return that
 			if (homeDirectory.equals(FILE_SYSTEM_ROOT_NAME)) {
 				return getRoots()[0];
 			}
 
 			// Get the file information
 			SFTPFileFile sftpFileFile = null;
 			try {
 				String parent = homeDirectory.substring(0, homeDirectory
 						.lastIndexOf(FILE_SEPERATOR));
 				
 				// FIXME Correct this
 				List returnedFiles = sftpClient.ls(parent);
 				String dirName = homeDirectory.substring(homeDirectory
 						.lastIndexOf(FILE_SEPERATOR) + 1);
 				for (int i = 0; i < returnedFiles.size(); i++ ) {
 					SftpFile returnedFile = (SftpFile) returnedFiles.get(i);
 					if (returnedFile.getFilename().equals(dirName)) {
 						sftpFileFile = new SFTPFileFile(returnedFile, this);
 					}
 				}
 			} catch (SFTPBrowseException e) {
 				logger.log(Level.WARNING, "Problem browsing file system", e);
 			} catch (IOException e) {
 				logger.log(Level.WARNING, "Problem browsing file system", e);
 			}
 
 			return sftpFileFile;
 		} catch (SFTPBrowseException e) {
 			logger.log(Level.WARNING, "FTBEx", e);
 		}
 
 		return null;
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#getRoots()
 	 */
 	public File [] getRoots () {
 
 		SFTPFileFile [] sftpFiles = null;
 		try {
 			checkConnection();
 
 			sftpClient.cd(FILE_SYSTEM_ROOT_NAME);
 			SftpFile sSftpFile = new SftpFile(sftpClient.pwd(), sftpClient.stat(FILE_SYSTEM_ROOT_NAME));
 			sSftpFile.getAttributes().setPermissions(String.valueOf(FileAttributes.S_IFDIR));
 			SFTPFileFile sSFTPFileFile = new SFTPFileFile(sSftpFile, this);
 			sftpFiles = new SFTPFileFile [1];
 			sftpFiles[0] = sSFTPFileFile;
 		} catch (SFTPBrowseException e) {
 			logger.log(Level.WARNING, "Could not get root file", e);
 		} catch (IOException e) {
 			logger.log(Level.WARNING, "Could not get root file", e);
 		} 
 		return sftpFiles;
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#createFileObject(java.io.File,
 	 *      java.lang.String)
 	 */
 	public File createFileObject (File dir, String filename) {
 
 		// We should never get here. If we ever do, call the parent and hope for
 		// the best!!!
 		logger.fine("Calling Super with: " + dir.toString() + " " + filename);
 		return super.createFileObject(dir, filename);
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#createFileObject(java.lang.String)
 	 */
 	public File createFileObject (String path) {
 
 		// We should never get here. If we ever do, call the parent and hope for
 		// the best!!!
 		logger.fine("Calling Super with: " + path);
 		return super.createFileObject(path);
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#getChild(java.io.File,
 	 *      java.lang.String)
 	 */
 	public File getChild (File parent, String fileName) {
 
 		if (parent instanceof SFTPFileFile) {
 			SftpFile parentDir = ((SFTPFileFile) parent).getSftpFile();
 			SFTPFileFile returnedFile = null;
 			try {
 				checkConnection();
 				List returnedFiles = sftpClient.ls(parentDir.getAbsolutePath());
 				
 				// Check if a path name is present.
 				if (fileName.indexOf(FILE_SEPERATOR) > -1) {
 					fileName = fileName.substring(fileName
 							.lastIndexOf(FILE_SEPERATOR) + 1);
 				}
 				for (int i = 0; i < returnedFiles.size(); i++ ) {
 					SftpFile returnedSftpFile = (SftpFile) returnedFiles.get(i);
 					if (returnedSftpFile.getFilename().equals(fileName)) {
 						returnedFile = new SFTPFileFile(returnedSftpFile, this);
 					}
 				}
 			} catch (SFTPBrowseException e) {
 				logger.log(Level.WARNING, "Problem browsing file system", e);
 			} catch (IOException e) {
 				logger.log(Level.WARNING, "Problem browsing file system", e);
 			}
 			return returnedFile;
 		} else {
 			// Should never get here!!!
 			logger.fine("Calling Super with: " + parent.toString() + " " + fileName);
 			return super.getChild(parent, fileName);
 		}
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#getFiles(java.io.File,
 	 *      boolean)
 	 */
 	public synchronized File [] getFiles (File dir, boolean useFileHiding) {
 
 		if (dir instanceof SFTPFileFile && dir.isDirectory()) {
 			SftpFile sftpFile = ((SFTPFileFile) dir).getSftpFile();
 			String name = sftpFile.getAbsolutePath();
 			try {
 				checkConnection();
 
 				// FIXME Fix parsing
 				List returnedFiles = sftpClient.ls(name);
 //				SFTPFileFile [] sftpFiles = new SFTPFileFile [returnedFiles.size()];
 				List modifiedFileList = new ArrayList(returnedFiles.size());
 				for (int i = 0; i < returnedFiles.size(); i++ ) {
 					SftpFile returnedFile = (SftpFile) returnedFiles.get(i);
 					String returnedFileName = returnedFile.getFilename();
 					if (returnedFileName.equals(".") || returnedFileName.equals("..")) {
 						continue;
 					}
 					modifiedFileList.add(new SFTPFileFile(returnedFile, this));
 				}
 				
 				SFTPFileFile [] sftpFiles = (SFTPFileFile[]) modifiedFileList.toArray(new SFTPFileFile[modifiedFileList.size()]); 
 				
 				return sftpFiles;
 
 			} catch (SFTPBrowseException e) {
 				logger.log(Level.WARNING, "Could not connect to host", e);
 				return new SFTPFileFile [0];
 			} catch (IOException e) {
 				logger.log(Level.WARNING, "Could not operate on host", e);
 				return new SFTPFileFile [0];
 			} catch (Exception e) {
 				logger.log(Level.WARNING, "Could not operate on host", e);
 				return new SFTPFileFile [0];
 			}
 		}
 		// Should never get here
 		logger.fine("Calling Super with: " + dir.toString() + " " + String.valueOf(useFileHiding));
 		return super.getFiles(dir, useFileHiding);
 
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#getParentDirectory(java.io.File)
 	 */
 	public File getParentDirectory (File dir) {
 
 		if (dir instanceof SFTPFileFile) {
 
 			SftpFile sftpFile = ((SFTPFileFile) dir).getSftpFile();
 			String name = sftpFile.getAbsolutePath();
 			if (name.equals(FILE_SYSTEM_ROOT_NAME)) {
 				return null;
 			}
 
 			String parent = name.substring(0, name.lastIndexOf(FILE_SEPERATOR));
 
 			// Parent is the root
 			if (parent.equals(FILE_SYSTEM_ROOT_NAME)) {
 				return getRoots()[0];
 			}
 
 			// Parent of the parent to list the parent
 			String pparent = parent.substring(0, parent
 					.lastIndexOf(FILE_SEPERATOR));
 			if (pparent.length() == 0) {
 				pparent = FILE_SYSTEM_ROOT_NAME;
 			}
 
 			SFTPFileFile parentFile = null;
 
 			try {
 				checkConnection();
 				// FIXME Correct list parsing
 				List returnedFiles = sftpClient.ls(pparent);
 				
 				String parentName = parent.substring(parent
 						.lastIndexOf(FILE_SEPERATOR) + 1);
 				for (int i = 0; i < returnedFiles.size(); i++ ) {
 					SftpFile returnedFile = (SftpFile) returnedFiles.get(i);
 					if (returnedFile.getFilename().equals(parentName)) {
 						parentFile = new SFTPFileFile(returnedFile, this);
 					}
 				}
 			} catch (SFTPBrowseException e) {
 				logger.log(Level.WARNING, "Problem browsing file system", e);
 			} catch (IOException e) {
 				logger.log(Level.WARNING, "Problem browsing file system", e);
 			}
 
 			if (null == parentFile) {
 				parentFile = (SFTPFileFile) getRoots()[0];
 			}
 
 			return parentFile;
 		}
 		
 		logger.fine("Calling Super with: " + dir.toString());
 		return super.getParentDirectory(dir);
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#getSystemDisplayName(java.io.File)
 	 */
 	public String getSystemDisplayName (File f) {
 
 		if (f instanceof SFTPFileFile) {
 			SftpFile sftpFile = ((SFTPFileFile) f).getSftpFile();
 			String name = sftpFile.getAbsolutePath();
 			if (FILE_SYSTEM_ROOT_NAME.equals(name)) {
 				return this.host;
 			} else {
 				return f.getName();
 			}
 		} else {
 			logger.fine("Calling Super with: " + f.getPath());
 			return super.getSystemDisplayName(f);
 		}
 	}
 
 	/**
 	 * Always returns null. The super class uses this to return special folder
 	 * names such as 'Desktop' on Windows.
 	 * 
 	 * @see javax.swing.filechooser.FileSystemView#getSystemTypeDescription(java.io.File)
 	 */
 	public String getSystemTypeDescription (File f) {
 
 		return null;
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#isComputerNode(java.io.File)
 	 */
 	public boolean isComputerNode (File dir) {
 
 		if (dir instanceof SFTPFileFile) {
 			SftpFile sftpFile = ((SFTPFileFile) dir).getSftpFile();
 			String name = sftpFile.getAbsolutePath();
 			if (FILE_SYSTEM_ROOT_NAME.equals(name)) {
 				return true;
 			} else {
 				return false;
 			}
 
 		} else {
 			return super.isComputerNode(dir);
 		}
 	}
 
 	/**
 	 * Returns false, drives not supported on remote systems
 	 * 
 	 * @see javax.swing.filechooser.FileSystemView#isDrive(java.io.File)
 	 */
 	public boolean isDrive (File dir) {
 
 		return false;
 	}
 
 	/**
 	 * Determines if the file is a real file or a link to another file.
 	 * 
 	 * @see javax.swing.filechooser.FileSystemView#isFileSystem(java.io.File)
 	 * @return <code>true</code> if it is an absolute file or
 	 *         <code>false</code>
 	 */
 	public boolean isFileSystem (File f) {
 
 		if (f instanceof SFTPFileFile) {
 			SftpFile sftpFile = ((SFTPFileFile) f).getSftpFile();
 			return !sftpFile.isLink();
 		}
 		logger.fine("Calling Super for: " + f.toString());
 		return super.isFileSystem(f);
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#isFileSystemRoot(java.io.File)
 	 */
 	public boolean isFileSystemRoot (File dir) {
 
 		if (dir instanceof SFTPFileFile) {
 			SftpFile sftpFile = ((SFTPFileFile) dir).getSftpFile();
 			String name = sftpFile.getAbsolutePath();
 			if (FILE_SYSTEM_ROOT_NAME.equals(name)) {
 				return true;
 			} else {
 				return false;
 			}
 		}
 		logger.fine("Calling Super for: " + dir.toString());
 		return super.isFileSystemRoot(dir);
 	}
 
 	/**
 	 * Returns false. No floppy drives are viewable.
 	 * 
 	 * @see javax.swing.filechooser.FileSystemView#isFloppyDrive(java.io.File)
 	 */
 	public boolean isFloppyDrive (File dir) {
 
 		return false;
 	}
 
 	/**
 	 * Hidden files are not supported now. Maybe later!
 	 * 
 	 * @see javax.swing.filechooser.FileSystemView#isHiddenFile(java.io.File)
 	 */
 	public boolean isHiddenFile (File f) {
 
 		return false;
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#isParent(java.io.File,
 	 *      java.io.File)
 	 */
 	public boolean isParent (File folder, File file) {
 
 		if (folder instanceof SFTPFileFile && file instanceof SFTPFileFile) {
 			// If file is a SFTPFileFile, you will always get back an SFTPFileFile
 			SFTPFileFile calculatedParent = (SFTPFileFile) getParentDirectory(file);
 			String parentPath = ((SFTPFileFile) folder).getSftpFile().getAbsolutePath();
 			if (parentPath.equals(calculatedParent.getSftpFile().getAbsolutePath())) {
 				return true;
 			} else {
 				return false;
 			}
 		}
 		logger.fine("Calling Super for: " + folder.toString() + " " + file.toString());
 		return super.isParent(folder, file);
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#isRoot(java.io.File)
 	 */
 	public boolean isRoot (File f) {
 
 		if (null == f) {
 			return false;
 		}
 		
 		if (f instanceof SFTPFileFile) {
 			SftpFile sftpFile = ((SFTPFileFile) f).getSftpFile();
 			String name = sftpFile.getAbsolutePath();
 			if (FILE_SYSTEM_ROOT_NAME.equals(name)) {
 				return true;
 			} else {
 				return false;
 			}
 		}
 		logger.fine("Calling super for: " + f.toString());
 		return super.isRoot(f);
 	}
 
 	/**
 	 * @see javax.swing.filechooser.FileSystemView#isTraversable(java.io.File)
 	 */
 	public Boolean isTraversable (File f) {
 
 		if (f instanceof SFTPFileFile) {
 			SftpFile sftpFile = ((SFTPFileFile) f).getSftpFile();
 			return new Boolean(sftpFile.isDirectory());
 		}
 		logger.fine("Calling super for: " + f.toString());
 		return super.isTraversable(f);
 	}
 
 }