/*
    * $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;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import com.mindtree.techworks.insight.gui.Insight;
  import com.mindtree.techworks.insight.gui.Presentation;
  import com.mindtree.techworks.insight.gui.action.IAction;
  import com.mindtree.techworks.insight.gui.widgets.StatusBar;
  import com.mindtree.techworks.insight.model.ILogEventModelMutator;
  import com.mindtree.techworks.insight.model.IMutatorListener;
  import com.mindtree.techworks.insight.model.LogEventModel;
  import com.mindtree.techworks.insight.pagination.IPage;
  import com.mindtree.techworks.insight.spi.LogEvent;
  
  /**
  *
  * The <code>Controller</code> class is the Mediator between the various Presentation
  * instances in the GUI. It also acts as the bridge between the GUI components
  * and the control and model components such as the Appender implementation(s).
  * All Presentation instances must register with this Controller using
  * <p>
  * #regsiterPresentation(Presentation presentation)
  * <p>
  * @author  Regunath B
  * @version 1.0, 04/10/25
  * @see com.mindtree.techworks.insight.gui.Presentation
  */
  
  public class Controller implements IMutatorListener {
  	
  	/**
  	 * The Insight instance that created this Controller
  	 */
  	private Insight insight;
  
  	/**
  	 * Map hashed by UIDs of Presentation instances containing 
  	 * lists of presentations that have been registered.
  	 */
  	private Map presentationMap = new HashMap();
  
  	/**
  	 * List of Presentation instances controlled by this Controller
  	 */
  	private List presentationList = new ArrayList();
  	
  	/**
  	 * List of active IAction instances 
  	 */
  	private List actionsList = new ArrayList();
  
  	/**
  	 * Root Model
  	 */	
  	private LogEventModel rootLogEventModel;
  
  	/**
  	 * Current/Active Model
  	 */	
  	private LogEventModel currentLogEventModel;
  	
  	/**
  	 * Type of the mutator, if any.
  	 */
  	private int mutatorType;
  	
  	/**
  	 * The status for the scroll lock, if any
  	 */
  	private boolean scrollLock = false;
  	
  	/**
 	 * Constructor for this class
 	 * @param insight the Insight instance that created this Controller
 	 */
 	public Controller(Insight insight) {
 		this.insight = insight;
 	}
 
 	/**
 	 * Regsiters the specified Presentation with this Controller
 	 * @param presentation the Presentation instance to be registered with this Controller
 	 */
 	public void registerPresentation(Presentation presentation) {
 		presentationList.add(presentation);
 	}
 
 	/**
 	 * Regsiters the specified IAction with this Controller
 	 * @param action the IAction instance to be registered with this Controller
 	 */
 	public void registerAction(IAction action) {
 		actionsList.add(action);
 		action.setEnabled(evaluateActionEnable(IAction.STARTUP, action));
 	}
 	
 	/**
 	 * Gets the Presentation identified by the specified cllass name
 	 * @param className the Class name of the Presentation required
 	 * @return the registered Presentation identified by the specified class name
 	 * @throws RuntimeException in case the Presentation is not found or has not been registered yet
 	 */
 	public Presentation getPresentation(String className) {
 		Iterator iterator = presentationList.iterator();
 		while(iterator.hasNext()) {
 			Presentation presentation = (Presentation)iterator.next();
 			if (presentation.getClass().getName().equals(className)) {
 				return presentation;
 			}
 		}
 		throw new RuntimeException("No registered Presentation with name : " + className);
 	}
 
 	/**
 	 * Registers the specified listener Presentation for call back when widgets
 	 * on the source Presentation change.
 	 * @param sourcePresentation the source Presentation where the widget change would occur 
 	 * @param listener the listener Presentation that is interested in widget changes on the source
 	 */
 	public void registerWidgetChangeListener(Presentation sourcePresentation, Presentation listener) {
 		List listenerList = (List)presentationMap.get(sourcePresentation.getUID());
 		if (listenerList == null) {
 			listenerList = new ArrayList();
 			presentationMap.put(sourcePresentation.getUID(),listenerList);
 		}
 		listenerList.add(listener);
 	}
 	
 	/**
 	 * Called by registered Presentation instances when widgets in them undergo a change
 	 * @param sourcePresentation the Presentation where the change occurred
 	 * @param widgetId unique id that identifies the widget in the Presentation
 	 * @param data optional data returned by the Presentation in the context of the widget change
 	 */
 	public void fireWidgetChanged(Presentation sourcePresentation, int widgetId, Object data) {
 		List listenerList = (List)presentationMap.get(sourcePresentation.getUID());
 		Iterator iterator = listenerList.iterator();
 		while(iterator.hasNext()) {
 			((Presentation)iterator.next()).notifyWidgetStateChange(sourcePresentation, widgetId, data);
 		}
 	}
 
 	/**
 	 * Notifies this Controller that an event was processed by the Appender.
 	 * This Controller passes this event to registered Presentation instances that
 	 * can handle run-time updates of event data.
 	 * @param event data describing the event that was processed by the Appender
 	 */
 	public void notifyLogEventOccurred(LogEvent event) {
 		Iterator iterator = presentationList.iterator();
 		while(iterator.hasNext()) {
 			Presentation p = (Presentation)iterator.next();
 			if (p.doesProcessRealTimeUpdates()) {
 				p.processRealTimeUpdate(event);
 			}
 		}
 		setStatus();
 	}
 	
 	/**
 	 * Notifies this Controller to reset the displays of all registered
 	 * Presentation implementations.
 	 */
 	public void resetPresentations() {
 		Iterator iterator = presentationList.iterator();
 		while(iterator.hasNext()) {
 			Presentation p = (Presentation)iterator.next();
 			p.resetWidgets();
 		}		
 	}
 	/**
 	 * @return Returns the insight.
 	 */
 	public Insight getInsight() {
 		return insight;
 	}
 	
 	/**
 	 * @return Returns the currentLogEventModel.
 	 */
 	public LogEventModel getCurrentLogEventModel() {
 		return this.currentLogEventModel;
 	}
 	
 	/**
 	 * Sets the specified LogEventModel as the current model
 	 * @param logEventModel The currentLogEventModel to set.
 	 * @param pageNumber the page number to be loaded as the current page
 	 * @param selectedEventIndex the index of the selected LogEvent
 	 */
 	public void setCurrentLogEventModel(LogEventModel logEventModel, long pageNumber, long selectedEventIndex) {
 		if(!logEventModel.equals(rootLogEventModel)){
 			logEventModel.setPreviousLogEventModel(this.currentLogEventModel);	
 		}
 		logEventModel.clearSearchResults();
 		this.currentLogEventModel = logEventModel;
 		setSelectedEvent(pageNumber, selectedEventIndex);
 	}
 	
 	/**
 	 * Sets the selection to the indicated log event
 	 * @param pageNumber the page number to be loaded as the current page
 	 * @param selectedEventIndex the index of the selected LogEvent
 	 */
 	public void setSelectedEvent(long pageNumber, long selectedEventIndex) {
 		this.currentLogEventModel.getPageSet().loadPageByNumber(pageNumber);
 		firePageChanged(selectedEventIndex);			
 	}
 
 
 	/**
 	 * Sets the specified LogEventModel as the current model
 	 * @param logEventModel The currentLogEventModel to set.
 	 */
 	public void setCurrentLogEventModel(LogEventModel logEventModel) {
 		// Load the first page and set the selection index to -1 after setting the specified
 		// model as the current model
 		setCurrentLogEventModel(logEventModel, 1, -1);
 	}
 	
 	/**
 	 * Clears the current event model. Replaces the current model with its
 	 * predecessor model. Also resets the presentations.
 	 */
 	public void clearCurrentModel(){
 		resetPresentations();
 		getCurrentLogEventModel().clear();
 		if(getCurrentLogEventModel().getPreviousLogEventModel() != null){			
 			this.currentLogEventModel = getCurrentLogEventModel().getPreviousLogEventModel();
 			this.currentLogEventModel.clearSearchResults();
 			// Load the first page of the model
 			this.currentLogEventModel.getPageSet().loadPageByNumber(1);
 			firePageChanged();			
 		} else {
 			// take the buttons to the start state
 			actionPerformed(IAction.STARTUP);
 		}
 	 }
 
 	/**
 	 * @return Returns the rootLogEventModel.
 	 */
 	public LogEventModel getRootLogEventModel() {
 		return rootLogEventModel;
 	}
 	
 	/**
 	 * @param rootLogEventModel The rootLogEventModel to set.
 	 */
 	public void setRootLogEventModel(LogEventModel rootLogEventModel) {
 		this.rootLogEventModel = rootLogEventModel;
 		// set the current model to the specified root model as well
 		this.currentLogEventModel = rootLogEventModel;
 		this.currentLogEventModel.clearSearchResults();
 	}
 
 	/**
 	 * Informs this Controller that the current page has changed.
 	 * All presentations are notified to reflect the page change
 	 */
 	public void firePageChanged() {
 		IPage page = this.currentLogEventModel.getPageSet().getCurrentPage();
 		Iterator iterator = presentationList.iterator();
 		while(iterator.hasNext()) {
 			Presentation p = (Presentation)iterator.next();
 			p.displayPage(page, -1);
 		}
 		setStatus();
 	}	
 	
 	/**
 	 * Informs this Controller that the current page has changed.
 	 * All presentations sre notified to reflect the page change and
 	 * LogEvent at the specified selectedEventIndex is highlighted 
 	 * @param selectedEventIndex the index of the selected LogEvent
 	 */
 	public void firePageChanged(long selectedEventIndex) {
 		IPage page = this.currentLogEventModel.getPageSet().getCurrentPage();
 		Iterator iterator = presentationList.iterator();
 		while(iterator.hasNext()) {
 			Presentation p = (Presentation)iterator.next();
 			p.displayPage(page, selectedEventIndex);
 		}
 		setStatus();		
 	}
 
 	/**
 	 * Sets the status display for Insight
 	 */
 	public void setStatus(){
   	    StatusBar.getInstance().setStatisticsDisplayText(this.currentLogEventModel.getStatus());
 	}
 	
 	/**
 	 * Call back method using which the controller will be notifed by 
 	 * any LogEventModelMutators starts mutating the LogEventModel 
 	 * @see IMutatorListener#startMutating()
 	 */
 	public void startMutating (int mutatorType) {
 		this.mutatorType = mutatorType;
 		actionPerformed(IAction.MUTATION);
 	}
 
 	/**
 	 * Call back method using which the controller will be notifed by 
 	 * any LogEventModelMutators ends mutating the LogEventModel
 	 * @see IMutatorListener#endMutating(int)
 	 */
 	public void endMutating (int infoFlag) {
 		// enable buttons only if atleast one log event has been interpreted
 		if (infoFlag == ILogEventModelMutator.SUCCESS) {
 			actionPerformed(IAction.NO_CONSTRAINTS);
 		} else {
 			// if a previous model exists, activate it and enable all buttons
 			if (this.currentLogEventModel.getPreviousLogEventModel() != null) {
 				setCurrentLogEventModel(this.currentLogEventModel.getPreviousLogEventModel());
 				actionPerformed(IAction.NO_CONSTRAINTS);
 			} else {
 				if (this.currentLogEventModel.getPageSet().getLastPage().getLogEventList().size() > 0) { 
 					// some data exists from a previous success load/mutation
 					actionPerformed(IAction.NO_CONSTRAINTS);					
 				} else {
 					// the application is in startup state
 					actionPerformed(IAction.STARTUP);
 				}
 			}
 		}
 	}
 	
 	/**
 	 * Informs this Controller that an action of the specified type has been
 	 * performed. This Controller controls enabling and disabling of affected
 	 * action widgets based on the specified action type
 	 * @param actionType the valid action type as defined in IAction
 	 * @see IAction
 	 */
 	public void actionPerformed(int actionType) {
 		Iterator iterator = actionsList.iterator();
 		while(iterator.hasNext()) {
 			IAction action = (IAction)iterator.next();
 			action.setEnabled(evaluateActionEnable(actionType, action));
 		}
 	}
 	
 	/**
 	 * Helper method that evaluates if the enable/disable effect on the 
 	 * specified IAction by the occurrence of an action of the specified action
 	 * type
 	 * @param actionType type of the action that occurred
 	 * @param action the IAction to be evaluated for enabling
 	 * @return true if the specified IAction can be enabled, false otherwise
 	 */
 	private boolean evaluateActionEnable(int actionType, IAction action) {
 		boolean enable = false;
 		int mutualExclusionType = IAction.NONE;
 		for (int i = 0; i < IAction.MUTUAL_EXCLUSION_TYPES.length; i++) {
 			if (IAction.MUTUAL_EXCLUSION_TYPES[i][0] == action.getType()) {
 				mutualExclusionType = IAction.MUTUAL_EXCLUSION_TYPES[i][1];
 				break;
 			}
 		}				
 		if (((action.getType() & actionType) == actionType)  &&
 			((action.getType() & actionType) != mutualExclusionType)){		
 			enable = true;
 		}
 		return enable;
 	}
 	
 	/**
 	 * Returns the type of the active mutator, if any
 	 * @return Returns the mutatorType.
 	 */
 	public int getMutatorType() {
 		return mutatorType;
 	}
 	
 	/**
 	 * Sets the status of the scroll lock. 
 	 * @param lock boolean true for scroll lock, false otherwise
 	 */
 	public void setScrollLock(boolean lock) {
 		this.scrollLock = lock;
 		this.currentLogEventModel.getPageSet().setMutatorType(this.scrollLock ?
 				ILogEventModelMutator.NON_TAILING_MUTATOR : ILogEventModelMutator.TAILING_MUTATOR);
 		Iterator iterator = presentationList.iterator();
 		while(iterator.hasNext()) {
 			Presentation p = (Presentation)iterator.next();
 			p.setScrollLock(this.scrollLock);
 		}
 	}
 	
 	/**
 	 * Returns the status of the scroll lock
 	 * @return Returns the scrollLock.
 	 */
 	public boolean isScrollLock() {
 		return scrollLock;
 	}
 }