/*
    * $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.gui.action;
  
  import java.awt.event.ActionEvent;
  import java.io.File;
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.util.LinkedList;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.swing.AbstractAction;
  import javax.swing.JFileChooser;
  import javax.swing.JOptionPane;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.appender.ParsedEventAppender;
  import com.mindtree.techworks.insight.gui.Insight;
  import com.mindtree.techworks.insight.gui.widgets.StatusBar;
  import com.mindtree.techworks.insight.model.ReceiverFormat;
  import com.mindtree.techworks.insight.preferences.util.Log4JPatternInterpeter;
  import com.mindtree.techworks.insight.preferences.util.PreferenceInterpreter;
  import com.mindtree.techworks.insight.receiver.AbstractReceiver;
  import com.mindtree.techworks.insight.receiver.FileStreamReceiver;
  import com.mindtree.techworks.insight.receiver.ReceiverInitializationException;
  import com.mindtree.techworks.insight.receiver.ReceiverInterpreter;
  import com.mindtree.techworks.insight.receiver.ReceiverListener;
  import com.mindtree.techworks.insight.receiver.RuntimeNamespaceContainer;
  import com.mindtree.techworks.insight.receiver.WildCardMatcher;
  import com.mindtree.techworks.insight.spi.LogNamespace;
  
  /**
  *
  * The <code>LoadLocalFileAction</code> class is an AbstractAction derivative that
  * provides ability to load files from the local or mounted file systems.
  * Provide a file chooser that may be used to load log files into the Insight.
  *
  * @author  Regunath B
  * @version 1.0, 04/10/25
  * @see     com.mindtree.techworks.insight.gui.Insight
  */
  
  public class LoadLocalFileAction extends AbstractAction implements ReceiverListener {
  	
  	/**
  	 * UID for the serialized form
  	 */
  	private static final long serialVersionUID = -6169872455620799521L;
  
  	/**
  	 * Singleton instance of this class
  	 */
  	private static LoadLocalFileAction instance;
  	
  	/**
  	 * FIFO LinkedList containing the namespaces that need to be loaded one after the other completes
  	 */
  	private LinkedList namespacesToBeLoaded = new LinkedList();		
  	
  	/**
  	 * The AbstractReceiver instance, if any
  	 */
  	private AbstractReceiver receiver;
  
  	/**
  	 * The file chooser used for allowing users to pick a file from local and
  	 * mounted file systems
  	 * 
  	 */
  	private final JFileChooser fileChooser = new JFileChooser(System.getProperty(InsightConstants.INSIGHT_HOME));    {
      	fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
      	fileChooser.setMultiSelectionEnabled(true);
      }
  
  	/**
  	 * The Insight instance that created this Action class
  	 */
 	private Insight insight;
 	
 	/**
 	 * Constructor for this class. Made private to prevent multiple instances.
 	 * Use @see#getInstance() to obtain instance of this class
 	 */
 	private LoadLocalFileAction() {
 		// do nothing
 	}
 	
 	/**
 	 * Accessor method to obtain instance of this class
 	 * @return singleton instance of this class
 	 */
 	public static synchronized final LoadLocalFileAction getInstance() {
 		if (instance == null) {
 			instance = new LoadLocalFileAction();
 		}
 		return instance;
 	}
 
 	/**
 	 * Initializes this LoadFileAction the first time.
 	 * Subsequent calls are ignored
 	 * @param insightInstance the Insight that created an instance of this class
 	 */
 	public void initialize(Insight insightInstance) {
 		if (this.insight == null) {
 			this.insight = insightInstance;
 		}
 		RuntimeNamespaceContainer.initializeAvailableNamespaceColorList();
 	}
 
 	/**
 	 * Overriden super class method
 	 * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
 	 */
 	public void actionPerformed(ActionEvent e) {
 		browseAndLoadLocalFiles();
 	}
 	
 	/**
 	 * Starts up the Receiver with the specified parameters
 	 * @param namespace the LogNamespace for load
 	 */
 	public void startupReceiver(LogNamespace namespace) {
 		boolean isReceiverTailing = PreferenceInterpreter.getTailingStatus();
 		// Set tailing to true only if its is a local file and tailing has been
 		// enabled in preferences
 		try {
 			boolean isLocalNamespace = (namespace.getNodeId().equalsIgnoreCase(InetAddress.getLocalHost().getHostName()));
 			isReceiverTailing = isReceiverTailing && isLocalNamespace;
 		} catch(UnknownHostException uhe) {
 			// do nothing
 		}
 		if (RuntimeNamespaceContainer.getLoadedNamespaces().contains(namespace)) {
 			StatusBar.getInstance().setDisplayText(0,InsightConstants.getLiteral("FILE_ALREADY_LOADED"), false);
 			//This is the method added for analyzing the wild cards.
 			analyzeWildCardEntries(namespacesToBeLoaded);
 			loadNextAvailableNamespace();
 			return;
 		}
 		StatusBar.getInstance().clearDisplay(0);			
 		StatusBar.getInstance().setDisplayText(1,InsightConstants.getLiteral("LOAD_FILE_STATUS") + namespace.getNamespaceAsString(), true);
 		try{
 			this.receiver = new FileStreamReceiver(namespace, isReceiverTailing);
 		}catch(ReceiverInitializationException rie){
 			StatusBar.getInstance().setDisplayText(1,rie.getMessage(),false);
 			return;
 		}
 		this.receiver.addAppender(ParsedEventAppender.getInstance(this.insight.getController()));
 		this.receiver.addReceiverListener(this);
 		this.receiver.addMutatorListener(this.insight.getController());
 		this.receiver.addMutatorListener(this.insight.getController().getCurrentLogEventModel().getPageSet());
 		this.receiver.startup();
 	}
 
 	/**
 	 * ReceiverListener interface method implementation.
 	 * @see ReceiverListener#startLoadEventNotification(LogNamespace[])
 	 */
 	public void startLoadEventNotification(LogNamespace[] namespaces) {
 		// do nothing because the isActive status is proactivley set in startupReceiver already
 	}
 
 	/**
 	 * ReceiverListener interface method implementation.
 	 * @see ReceiverListener#endLoadEventNotification(LogNamespace[], int)
 	 */
 	public void endLoadEventNotification(LogNamespace[] namespaces, int infoFlag) {
 		StatusBar.getInstance().clearDisplay(1);
 		if (infoFlag == ReceiverInterpreter.SUCCESS) {
 			for (int i = 0; i < namespaces.length; i++ ) {
 				RuntimeNamespaceContainer.getLoadedNamespaces().add(namespaces[i]);
 			}
 //			RuntimeNamespaceContainer.getLoadedNamespaces().add(namespace);
 		} else {
 			StringBuffer namespaceNames = new StringBuffer();
 			for (int i = 0; i < namespaces.length; i++ ) {
 				namespaceNames.append(namespaces[i].getNamespaceAsString());
 				if ((i + 1) < namespaces.length) {
 					namespaceNames.append(", ");
 				}
 			}
 			 JOptionPane.showMessageDialog(insight, InsightConstants.getLiteral("ERROR_NO_MATCHING_ENTRIES") +  "\n" + namespaceNames.toString(), 
 			 		InsightConstants.getLiteral("ERROR"), JOptionPane.ERROR_MESSAGE);
 		}
 		
 		analyzeWildCardEntries(namespacesToBeLoaded);
 		// load next available namespace, if any, and if they had been selected in multiples
 		loadNextAvailableNamespace();
 	}	
 	
 	/**
 	 * Adds the specified LogNamespace for load
 	 * @param namespace the LogNamespace for load
 	 */
 	public void addNamespaceForLoad(LogNamespace namespace) {
 		this.namespacesToBeLoaded.addLast(namespace);
 	}
 	
 	/**
 	 * Loads the LogNamespace(s) that have been added for load
 	 * @see #addNamespaceForLoad(LogNamespace)
 	 */
 	public void loadNamespaces() {
 		analyzeWildCardEntries(namespacesToBeLoaded);
 		loadNextAvailableNamespace();
 	}
 	
 	/**
 	 * Displays a JFileChooser for loacl and mounted file systems.
 	 * The selected files are loaded into Insight.
 	 */
 	public void browseAndLoadLocalFiles() {
 		// clear the LinkedList before populating files to be loaded
 		this.namespacesToBeLoaded.clear();
 		String nodeId = null;
 		ReceiverFormat[] receiverFormat = Log4JPatternInterpeter.getInterpretedRecieverFormat();
 		try {
 			nodeId = InetAddress.getLocalHost().getHostName();
 		} catch(UnknownHostException uhe) {
 			uhe.printStackTrace();
 		}
 		fileChooser.setMultiSelectionEnabled(!PreferenceInterpreter.getTailingStatus());
         if (fileChooser.showOpenDialog(insight) == JFileChooser.APPROVE_OPTION) {
         	if(!fileChooser.isMultiSelectionEnabled()){
                 //In Case when Multiselection is not enabled then JFileChooser#getSelectedFile() gives the 
             	// absolute path of selected file.
         		String fileAbsPath = fileChooser.getSelectedFile().getAbsolutePath();
         		//  add files to the last to enable FIFO when they are processed
         		this.namespacesToBeLoaded.addLast(new LogNamespace(fileAbsPath,InsightConstants.FILE_PROTOCOL_PREFIX+fileAbsPath,receiverFormat,nodeId));
             }else{
                 //In Case when Multiselection is enabled then JFileChooser#getSelectedFiles() gives the 
             	// array of selected files.
             	File[] chosenFiles = fileChooser.getSelectedFiles();
 	            for (int i = 0; i < chosenFiles.length; i++) {
 	            	// add files to the last to enable FIFO when they are processed
 	            	this.namespacesToBeLoaded.addLast(new LogNamespace(chosenFiles[i].getAbsolutePath(), 
 	            			InsightConstants.FILE_PROTOCOL_PREFIX + chosenFiles[i].getAbsolutePath(), 
 	            			receiverFormat, nodeId));
 	            }
             	
             }
         	analyzeWildCardEntries(namespacesToBeLoaded);
             loadNextAvailableNamespace();
         }		
 	}
 	/**
 	 * Launches insight with  the log file passed. 
 	 * @param fileName - log file's absolute path.
 	 */
 	public void LoadOnFileSelection(String fileName) {
 		String nodeId = null;
 		ReceiverFormat[] receiverFormat = Log4JPatternInterpeter.getInterpretedRecieverFormat();
 		try {
 			nodeId = InetAddress.getLocalHost().getHostName();
 		} catch(UnknownHostException uhe) {
 			uhe.printStackTrace();
 		}
 		String fileAbsPath = fileName;
 		this.namespacesToBeLoaded.addLast(new LogNamespace(fileAbsPath,InsightConstants.FILE_PROTOCOL_PREFIX+fileAbsPath,receiverFormat,nodeId));
 		analyzeWildCardEntries(namespacesToBeLoaded);
         loadNextAvailableNamespace();
 	}
 	/**
 	 * Helper method that loads the next available namespace, if any.
 	 */
 	private final void loadNextAvailableNamespace() {
 		if (namespacesToBeLoaded.size() == 0) {
 			return;
 		}
 		// Process namespaces in FIFO form
 		LogNamespace nextNamespace = (LogNamespace)namespacesToBeLoaded.removeFirst();
     	startupReceiver(nextNamespace);		
 	}
 	
 	/**
 	 * Analyzes the wild cards and converts them into full text paths in the given namespace's list.
 	 * @param namespacesToBeLoaded	The list of namespaces
 	 */
 	private void analyzeWildCardEntries(LinkedList namespacesToBeLoaded){
 		
 		List namespacesList = new ArrayList(10);
 		
 		for(int i = 0; i < namespacesToBeLoaded.size(); i++){
 		
 			String filePath = ((LogNamespace)(namespacesToBeLoaded.get(i))).getSourceString();
 			//Checks for the last file separator and extracts the file name
 			int lastFileSeparatorIndex = (filePath.lastIndexOf(File.separatorChar));
 			String fileName = filePath.substring(lastFileSeparatorIndex + 1);
 			String parentDirectoryPath = filePath.substring(0, lastFileSeparatorIndex);
 			//Supports only the wild card '*'
 			if(WildCardMatcher.hasWildCardEntries(fileName)){
 				String wildCard = fileName;
 				File parentDirectory = new File(parentDirectoryPath);
 				if(parentDirectory.isDirectory()){
 					//Takes the wild card entry and returns the matching files
 					List matchingFiles = getMatchingFiles(parentDirectory, wildCard);
 					for(int j = 0; j < matchingFiles.size(); j++){
 						LogNamespace thisNamespace = (LogNamespace)namespacesToBeLoaded.get(i);
 						String newFilePath = ((File)(matchingFiles.get(j))).getAbsolutePath();
 						String newFileLocalPath = InsightConstants.FILE_PROTOCOL_PREFIX + newFilePath;
 						namespacesList.add(new LogNamespace(newFilePath, newFileLocalPath, thisNamespace.getReceiverFormat(), thisNamespace.getNodeId()));
 					}
 					namespacesToBeLoaded.remove(i);
 				}
 			}
 		}
 		for(int i = 0; i < namespacesList.size(); i++){
 			namespacesToBeLoaded.addFirst((LogNamespace)namespacesList.get(i));
 		}
 	}
 	
 	/**
 	 * Matches all the files in the directory (parentDirectory) with the given
 	 *  pattern and returns all the matching files as a vector.
 	 * @param parentDirectory	The directory from which the file list has to be taken.
 	 * @param pattern	The wild card pattern.
 	 * @return	A vector of matching files.
 	 */
 	private List getMatchingFiles(File parentDirectory, String pattern){
 		//Vector for storing all the file paths matching the given pattern
 		List filesList = new ArrayList(parentDirectory.listFiles().length); 
 		File[] files = parentDirectory.listFiles();
 		
 		for(int i = 0; i < files.length; i++){
 			if(files[i].isDirectory()){
 				//Uncomment this for support of nested directories.
 				//getMatchingFiles(files[i], pattern);
 			}
 			else{
 				String filePath = files[i].getAbsolutePath();
 				String fileName = filePath.substring(filePath.lastIndexOf('/') == -1 ? filePath.lastIndexOf('\\') + 1 : filePath.lastIndexOf('/') + 1);
 				WildCardMatcher matcher = new WildCardMatcher(pattern);
 				if(matcher.matches(fileName)){
 					filesList.add(files[i]);
 				}
 				else{
 				}
 			}
 		}
 		return filesList;
 	}
 
 	/**
 	 * Returns the currently active AbstractReceiver, if any, or null otherwise
 	 * @return Returns null or the receiver.
 	 */
 	public AbstractReceiver getReceiver() {
 		return receiver;
 	}
 }