/*
    * $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.preferences.util;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.download.FTPFileset;
  import com.mindtree.techworks.insight.download.Fileset;
  import com.mindtree.techworks.insight.download.HTTPFileset;
  import com.mindtree.techworks.insight.download.ProxyInfo;
  import com.mindtree.techworks.insight.download.SFTPFileset;
  import com.mindtree.techworks.insight.preferences.PreferenceManager;
  import com.mindtree.techworks.insight.preferences.model.Preference;
  import com.mindtree.techworks.insight.preferences.model.PreferenceAttribute;
  
  /**
   * The <code>PreferenceInterpreter</code> class is a utility that has static
   * methods to interpret Preference instances and return data relevant to the
   * client using the preference
   * 
   * @author Regunath B
   * @version 1.0, 05/03/30
   */
  public class PreferenceInterpreter {
  
  	/**
  	 * Constant for 'true' boolean value
  	 */
  	private static final String TRUE = "true";
  
  	//
  	// Constants for Preference ids
  	//
  
  	/**
  	 * Preference containing the event columns
  	 */
  	private static final String DISPLAY_COLUMN = "eventcolumnpreference";
  
  	/**
  	 * Preference containing the file sets
  	 */
  	private static final String FILESET = "fileset";
  
  	/**
  	 * Preference containing the local filesets
  	 */
  	private static final String LOCAL_FILESETS = "local";
  
  	/**
  	 * Preference containing the ftp filesets
  	 */
  	private static final String FTP_FILESETS = "ftpfiles";
  
  	/**
  	 * Preference containing the ftp filesets
  	 */
  	private static final String SFTP_FILESETS = "sftpfiles";
  	
  	/**
  	 * Preference containing the http filesets
  	 */
  	private static final String HTTP_FILESETS = "remote";
  
  	/**
  	 * Preference containing the proxy information
  	 */
  	private static final String PROXY = "proxy";
  
  	//
  	// Constants for PreferenceAttribute ids
  	//
  
 	/**
 	 * Preference Attribute for the load behaiviour
 	 */
 	private static final String SHOW_FILESETS = "showFilesetsOnLoad";
 
 	/**
 	 * Preference Attribute for the Preferred fileset type
 	 */
 	private static final String PREFERRED_FILSET_TYPE = "filesetType";
 
 	// Attributes for FTP Fileset
 
 	/**
 	 * Preference Attribute for the host name
 	 */
 	private static final String FTP_FILESET_HOSTNAME = "hostname";
 
 	/**
 	 * Preference Attribute for the port
 	 */
 	private static final String FTP_FILESET_PORTNO = "portno";
 
 	/**
 	 * Preference Attribute for the home directory
 	 */
 	private static final String FTP_FILESET_HOMEDIR = "homedir";
 
 	/**
 	 * Preference Attribute for identifying if authentication is required
 	 */
 	private static final String FTP_FILESET_AUTHENTICATION = "authentication";
 
 	/**
 	 * Preference Attribute for the username
 	 */
 	private static final String FTP_FILESET_USERNAME = "username";
 
 	/**
 	 * Preference Attribute for the password
 	 */
 	private static final String FTP_FILESET_PASSWORD = "password";
 
 	/**
 	 * All file ids start with...
 	 */
 	private static final String FTP_FILESET_FILE_PREFIX = "urlId";
 
 	// Attributes for SFTP Fileset
 
 	/**
 	 * Preference Attribute for the host name
 	 */
 	private static final String SFTP_FILESET_HOSTNAME = "hostname";
 
 	/**
 	 * Preference Attribute for the port
 	 */
 	private static final String SFTP_FILESET_PORTNO = "portno";
 
 	/**
 	 * Preference Attribute for the home directory
 	 */
 	private static final String SFTP_FILESET_HOMEDIR = "homedir";
 
 	/**
 	 * Preference Attribute for identifying if authentication is required
 	 */
 	private static final String SFTP_FILESET_AUTHENTICATION = "authentication";
 
 	/**
 	 * Preference Attribute for the username
 	 */
 	private static final String SFTP_FILESET_USERNAME = "username";
 
 	/**
 	 * Preference Attribute for the password
 	 */
 	private static final String SFTP_FILESET_PASSWORD = "password";
 
 	/**
 	 * Preference Attribute for Tailing Option 
 	 */
 	private static final String TAILING_OPTION = "tailOption";
 	/**
 	 * All file ids start with...
 	 */
 	private static final String SFTP_FILESET_FILE_PREFIX = "urlId";
 	
 	// Attributes for http filesets
 
 	/**
 	 * If authentication is required on the host
 	 */
 	private static final String HTTP_AUTHENTICATION_REQUIRED = "authentication";
 
 	/**
 	 * Username to authenticate users
 	 */
 	private static final String HTTP_AUTHENTICATION_USERNAME = "username";
 
 	/**
 	 * Password to authenticate users
 	 */
 	private static final String HTTP_AUTHENTICATION_PASSWORD = "password";
 
 	/**
 	 * If proxy is to be ignored for this fileset
 	 */
 	private static final String HTTP_IGNORE_PROXY = "ignoreProxy";
 
 	/**
 	 * All url ids start with...
 	 */
 	private static final String HTTP_FILESET_URL_PREFIX = "urlId";
 
 	// Attributes for proxy information
 
 	/**
 	 * HTTP Proxy host
 	 */
 	private static final String HTTP_PROXY_HOST = "http.proxy.host";
 
 	/**
 	 * HTTP Proxy port
 	 */
 	private static final String HTTP_PROXY_PORT = "http.proxy.port";
 
 	/**
 	 * FTP Proxy host
 	 */
 	private static final String FTP_PROXY_HOST = "ftp.proxy.host";
 
 	/**
 	 * FTP Proxy port
 	 */
 	private static final String FTP_PROXY_PORT = "ftp.proxy.port";
 
 	/**
 	 * SOCKS Proxy host
 	 */
 	private static final String SOCKS_PROXY_HOST = "socks.proxy.host";
 
 	/**
 	 * SOCKS Proxy port
 	 */
 	private static final String SOCKS_PROXY_PORT = "socks.proxy.port";
 
 	/**
 	 * If Proxy requires authentication
 	 */
 	private static final String PROXY_REQUIRES_AUTHENTICATION = "authentication";
 
 	/**
 	 * Proxy authentication user
 	 */
 	private static final String PROXY_AUTH_USER = "user";
 
 	/**
 	 * Proxy authentication password
 	 */
 	private static final String PROXY_AUTH_PASSWORD = "password";
 	
 	/**
 	 * The preference of the remote protocol
 	 */
 	private static final String REMOTE_PREFERENCE = "remoteProtocol";
 	
 	/**
 	 * The port of the listener
 	 */
 	private static final String REMOTE_PORT = "port";
 	
 	/**
 	 * Cache configuration preference and preference attribute Ids
 	 */
 	private static final String CACHE_CONFIG = "cacheConfig";
 	private static final String PAGE_SIZE = "pageSize";
 	
 	//
 	// Static methods
 	//
 
 	/**
 	 * Returns an array of column identifiers for the event list display
 	 * Presentation. The colum ids are valid constants defined in
 	 * LogEventTableModel
 	 * 
 	 * @see com.mindtree.techworks.insight.model.LogEventTableModel
 	 * @return int array containing valid table column identifiers
 	 */
 	public static int [] getConfiguredColumnsForDisplay () {
 
 		ArrayList configuredColumns = new ArrayList();
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				DISPLAY_COLUMN);
 		Iterator iterator = preference.iteratePreferenceAttributeIds();
 		while (iterator.hasNext()) {
 			String id = (String) iterator.next();
 			configuredColumns.add(id);
 		}
 		// sort the ids in their natural order
 		Collections.sort(configuredColumns);
 		int [] columns = new int [configuredColumns.size()];
 		for (int i = 0; i < configuredColumns.size(); i++ ) {
 			columns[i] = Integer.parseInt(preference
 					.getPreferenceAttributeById(
 							(String) configuredColumns.get(i)).getValue());
 		}
 		return columns;
 	}
 
 	/**
 	 * Returns the preference for displaying filesets on load
 	 * 
 	 * @return true if configured filesets need to be shown, false otherwise
 	 */
 	public static boolean getShowFilesetOnLoad () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				FILESET);
 		return preference.getPreferenceAttributeById(SHOW_FILESETS).getValue()
 				.equals(TRUE);
 	}
 
 	/**
 	 * Returns the preferred fileset type to be displayed. This information is
 	 * read from
 	 * 
 	 * <pre>
 	 * fileset_filesetType
 	 * </pre>
 	 * 
 	 * @return A number identifying the preferred fileset type.
 	 */
 	public static int getPreferredFilesetType () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				FILESET);
 		return Integer.parseInt(preference.getPreferenceAttributeById(
 				PREFERRED_FILSET_TYPE).getValue());
 	}
 
 	/**
 	 * Loads and returns all the Local filesets configured under
 	 * 
 	 * <pre>
 	 * fileset$local
 	 * </pre>
 	 * 
 	 * @return A list of {@link com.mindtree.techworks.insight.download.Fileset Fileset}
 	 *         objects.
 	 */
 	public static List getLocalFilesets () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				FILESET).getPreferenceById(LOCAL_FILESETS);
 		List localFilesets = new ArrayList();
 		for (Iterator filesetPrefItr = preference.iterateChildPreferences(); filesetPrefItr
 				.hasNext();) {
 			Preference localFilesetPref = (Preference) filesetPrefItr.next();
 			Fileset localFileSet = new Fileset(localFilesetPref.getName(),
 					Fileset.LOCAL_FILESET);
 			for (Iterator fileItr = localFilesetPref
 					.iteratePreferenceAttributes(); fileItr.hasNext();) {
 				localFileSet.addFile(((PreferenceAttribute) fileItr.next())
 						.getValue());
 			}
 			localFilesets.add(localFileSet);
 		}
 		return localFilesets;
 	}
 
 	/**
 	 * Loads and returns all the FTP filesets configured under:
 	 * 
 	 * <pre>
 	 * fileset$ftpfiles
 	 * </pre>
 	 * 
 	 * @return A list of
 	 *         {@link com.mindtree.techworks.insight.download.FTPFileset FTPFileset}
 	 *         objects.
 	 */
 	public static List getFTPFilesets () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				FILESET).getPreferenceById(FTP_FILESETS);
 		List ftpFilesets = new ArrayList();
 		for (Iterator ftpFilesetPrefItr = preference.iterateChildPreferences(); ftpFilesetPrefItr
 				.hasNext();) {
 			Preference ftpFilesetPref = (Preference) ftpFilesetPrefItr.next();
 			FTPFileset ftpFileSet = new FTPFileset(ftpFilesetPref.getName());
 
 			// Load the host information
 			ftpFileSet.setHost(ftpFilesetPref.getPreferenceAttributeById(
 					FTP_FILESET_HOSTNAME).getValue());
 			String portNo = ftpFilesetPref.getPreferenceAttributeById(
 					FTP_FILESET_PORTNO).getValue();
 			if (null != portNo && portNo.length() > 0) {
 				ftpFileSet.setPort(Integer.parseInt(portNo));
 			}
 			ftpFileSet
 					.setDefaultDirectory(ftpFilesetPref
 							.getPreferenceAttributeById(FTP_FILESET_HOMEDIR)
 							.getValue());
 
 			// Load the Authentication information
 			boolean requiresAuthentication = ftpFilesetPref
 					.getPreferenceAttributeById(FTP_FILESET_AUTHENTICATION)
 					.getValue().equals(TRUE);
 			ftpFileSet.setAuthenticationRequired(requiresAuthentication);
 			if (requiresAuthentication) {
 				ftpFileSet.setUserName(ftpFilesetPref
 						.getPreferenceAttributeById(FTP_FILESET_USERNAME)
 						.getValue());
 				ftpFileSet.setPassword(ftpFilesetPref
 						.getPreferenceAttributeById(FTP_FILESET_PASSWORD)
 						.getValue());
 			}
 
 			// TODO Add proxy information
 
 			// Load the files
 			for (Iterator fileItr = ftpFilesetPref
 					.iteratePreferenceAttributes(); fileItr.hasNext();) {
 				PreferenceAttribute fileAttribute = (PreferenceAttribute) fileItr
 						.next();
 				if (fileAttribute.getId().startsWith(FTP_FILESET_FILE_PREFIX)) {
 					ftpFileSet.addFile(fileAttribute.getValue());
 				}
 			}
 
 			// All done... add the fileset to the list
 			ftpFilesets.add(ftpFileSet);
 		}
 		return ftpFilesets;
 	}
 	
 	/**
 	 * Loads and returns all the SFTP filesets configured under:
 	 * 
 	 * <pre>
 	 * fileset$sftpfiles
 	 * </pre>
 	 * 
 	 * @return A list of
 	 *         {@link com.mindtree.techworks.insight.download.SFTPFileset SFTPFileset}
 	 *         objects.
 	 */
 	public static List getSFTPFilesets () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				FILESET).getPreferenceById(SFTP_FILESETS);
 		List sftpFilesets = new ArrayList();
 		for (Iterator sftpFilesetPrefItr = preference.iterateChildPreferences(); sftpFilesetPrefItr
 				.hasNext();) {
 			Preference sftpFilesetPref = (Preference) sftpFilesetPrefItr.next();
 			SFTPFileset sftpFileSet = new SFTPFileset(sftpFilesetPref.getName());
 
 			// Load the host information
 			sftpFileSet.setHost(sftpFilesetPref.getPreferenceAttributeById(
 					SFTP_FILESET_HOSTNAME).getValue());
 			String portNo = sftpFilesetPref.getPreferenceAttributeById(
 					SFTP_FILESET_PORTNO).getValue();
 			if (null != portNo && portNo.length() > 0) {
 				sftpFileSet.setPort(Integer.parseInt(portNo));
 			}
 			sftpFileSet
 					.setDefaultDirectory(sftpFilesetPref
 							.getPreferenceAttributeById(SFTP_FILESET_HOMEDIR)
 							.getValue());
 
 			// Load the Authentication information
 			boolean requiresAuthentication = sftpFilesetPref
 					.getPreferenceAttributeById(SFTP_FILESET_AUTHENTICATION)
 					.getValue().equals(TRUE);
 			sftpFileSet.setAuthenticationRequired(requiresAuthentication);
 			if (requiresAuthentication) {
 				sftpFileSet.setUserName(sftpFilesetPref
 						.getPreferenceAttributeById(SFTP_FILESET_USERNAME)
 						.getValue());
 				sftpFileSet.setPassword(sftpFilesetPref
 						.getPreferenceAttributeById(SFTP_FILESET_PASSWORD)
 						.getValue());
 			}
 
 			// TODO Add proxy information
 
 			// Load the files
 			for (Iterator fileItr = sftpFilesetPref
 					.iteratePreferenceAttributes(); fileItr.hasNext();) {
 				PreferenceAttribute fileAttribute = (PreferenceAttribute) fileItr
 						.next();
 				if (fileAttribute.getId().startsWith(SFTP_FILESET_FILE_PREFIX)) {
 					sftpFileSet.addFile(fileAttribute.getValue());
 				}
 			}
 
 			// All done... add the fileset to the list
 			sftpFilesets.add(sftpFileSet);
 		}
 		return sftpFilesets;
 	}
 	
 
 	/**
 	 * Loads and returns all the HTTP filesets configured under:
 	 * 
 	 * <pre>
 	 * fileset$remote
 	 * </pre>
 	 * 
 	 * @return A list of
 	 *         {@link com.mindtree.techworks.insight.download.FTPFileset FTPFileset}
 	 *         objects.
 	 */
 	public static List getHttpFilesets () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				FILESET).getPreferenceById(HTTP_FILESETS);
 		List httpFilesets = new ArrayList();
 
 		// Loop through the filesets
 		for (Iterator httpFilesetPrefItr = preference.iterateChildPreferences(); httpFilesetPrefItr
 				.hasNext();) {
 			Preference httpFilesetPref = (Preference) httpFilesetPrefItr.next();
 			HTTPFileset httpFileSet = new HTTPFileset(httpFilesetPref.getName());
 
 			// Authentication information
 			boolean requiresAuthentication = httpFilesetPref
 					.getPreferenceAttributeById(HTTP_AUTHENTICATION_REQUIRED)
 					.getValue().equals(TRUE);
 			httpFileSet.setAuthenticationRequired(requiresAuthentication);
 			if (requiresAuthentication) {
 				httpFileSet.setUserName(httpFilesetPref
 						.getPreferenceAttributeById(
 								HTTP_AUTHENTICATION_USERNAME).getValue());
 				httpFileSet.setPassword(httpFilesetPref
 						.getPreferenceAttributeById(
 								HTTP_AUTHENTICATION_PASSWORD).getValue());
 			}
 
 			httpFileSet.setIgnoreProxy(httpFilesetPref
 					.getPreferenceAttributeById(HTTP_IGNORE_PROXY).getValue()
 					.equals(TRUE));
 
 			// Load the urls
 			for (Iterator urlItr = httpFilesetPref
 					.iteratePreferenceAttributes(); urlItr.hasNext();) {
 				PreferenceAttribute fileAttribute = (PreferenceAttribute) urlItr
 						.next();
 				if (fileAttribute.getId().startsWith(HTTP_FILESET_URL_PREFIX)) {
 					httpFileSet.addFile(fileAttribute.getValue());
 				}
 			}
 
 			// All done.. add this to the list
 			httpFilesets.add(httpFileSet);
 		}
 
 		return httpFilesets;
 	}
 
 	/**
 	 * Loads the proxy information from the preferences and returns that as a
 	 * ProxyInfo object.
 	 * 
 	 * @return <code>ProxyInfo</code> object containing proxy information.
 	 */
 	public static ProxyInfo getProxyInfo () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				PROXY);
 		ProxyInfo proxyInfo = new ProxyInfo();
 		String host = null;
 		String port = null;
 
 		// Load the http proxy
 		host = preference.getPreferenceAttributeById(HTTP_PROXY_HOST)
 				.getValue();
 		port = preference.getPreferenceAttributeById(HTTP_PROXY_PORT)
 				.getValue();
 		if (host != null && port != null && host.length() > 0
 				&& port.length() > 0) {
 			proxyInfo.setHttpProxyInfo(host, Integer.parseInt(port));
 		}
 
 		// Load the ftp proxy
 		host = preference.getPreferenceAttributeById(FTP_PROXY_HOST).getValue();
 		port = preference.getPreferenceAttributeById(FTP_PROXY_PORT).getValue();
 		if (host != null && port != null && host.length() > 0
 				&& port.length() > 0) {
 			proxyInfo.setFtpProxyInfo(host, Integer.parseInt(port));
 		}
 
 		// Load the socks proxy
 		host = preference.getPreferenceAttributeById(SOCKS_PROXY_HOST)
 				.getValue();
 		port = preference.getPreferenceAttributeById(SOCKS_PROXY_PORT)
 				.getValue();
 		if (host != null && port != null && host.length() > 0
 				&& port.length() > 0) {
 			proxyInfo.setSocksProxyInfo(host, Integer.parseInt(port));
 		}
 
 		proxyInfo.setAuthenticationRequired(preference
 				.getPreferenceAttributeById(PROXY_REQUIRES_AUTHENTICATION)
 				.getValue().equals(TRUE));
 		if (proxyInfo.isAuthenticationRequired()) {
 			proxyInfo.setPasswordInformation(preference
 					.getPreferenceAttributeById(PROXY_AUTH_USER).getValue(),
 					preference.getPreferenceAttributeById(PROXY_AUTH_PASSWORD)
 							.getValue());
 		}
 
 		return proxyInfo;
 	}
 
 	/**
 	 * Loads the tailing option information from the preferences and returns that as a
 	 *  booelan.
 	 * 
 	 * @return <code>boolean</code> value representing the tailing information which 
 	 * is being persisted as part of preferences.
 	 */
 
 	public static boolean getTailingStatus(){
 		Preference pref = PreferenceManager.getInstance().getPreference(FILESET);
 		if(pref!=null){
 			PreferenceAttribute prefAttribute = pref.getPreferenceAttributeById(TAILING_OPTION);
 			if(prefAttribute!=null){
 				return prefAttribute.getValue().equalsIgnoreCase(TRUE);
 			}
 		}
 		return false;
 	}
 	
 	/**
 	 * Loads the default port value for the Remote Protocol Listener. If the
 	 * preference cannot be found or it does not contain an integer value, the
 	 * {@link InsightConstants#REMOTE_PORT_DEFAULT_VALUE default value} is returned.
 	 * 
 	 * @return The value on which the listener will linked.
 	 */
 	public static int getRemoteProtocolListenerPort () {
 
 		Preference pref = PreferenceManager.getInstance ()
 				.getPreference (REMOTE_PREFERENCE);
 		if (null != pref) {
 			PreferenceAttribute preferenceAttribute = pref
 					.getPreferenceAttributeById (REMOTE_PORT);
 			if (null != preferenceAttribute) {
 				try {
 					return Integer.valueOf (preferenceAttribute.getValue ())
 							.intValue ();
 				} catch (NumberFormatException nfe) {
 					// Do nothing with the exception, just return the default
 					// and set that to the preference
 					preferenceAttribute.setValue (String
 							.valueOf (InsightConstants.REMOTE_PORT_DEFAULT_VALUE));
 					return InsightConstants.REMOTE_PORT_DEFAULT_VALUE;
 				}
 			}
 		}
 		return InsightConstants.REMOTE_PORT_DEFAULT_VALUE;
 	}
 	
 	/**
 	 * Returns the configured cache page size of the default value defined in 
 	 * InsightConstants if no configuration is defined
 	 * @return the configured page size or the default value
 	 */
 	public static int getCachePageSize() {
 		Preference pref = PreferenceManager.getInstance ()
 		.getPreference (CACHE_CONFIG);
 		if (null != pref) {
 			PreferenceAttribute preferenceAttribute = pref
 					.getPreferenceAttributeById (PAGE_SIZE);
 			if (null != preferenceAttribute) {
 				try {
 					return Integer.valueOf (preferenceAttribute.getValue ())
 							.intValue ();
 				} catch (NumberFormatException nfe) {
 					// Do nothing with the exception, just return the default
 					// and set that to the preference
 					preferenceAttribute.setValue (String
 							.valueOf (InsightConstants.DEFAULT_PAGE_SIZE));
 					return InsightConstants.DEFAULT_PAGE_SIZE;
 				}
 			}
 		}
 		return InsightConstants.DEFAULT_PAGE_SIZE;		
 	}
 }