/*
    * $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;
  
  import java.awt.Dimension;
  import java.awt.EventQueue;
  import java.awt.Toolkit;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.util.Enumeration;
  
  import javax.swing.BorderFactory;
  import javax.swing.JComponent;
  import javax.swing.JScrollBar;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;
  import javax.swing.ListSelectionModel;
  import javax.swing.event.ListSelectionEvent;
  import javax.swing.event.ListSelectionListener;
  import javax.swing.table.JTableHeader;
  import javax.swing.table.TableColumn;
  import javax.swing.table.TableColumnModel;
  
  import com.mindtree.techworks.insight.Controller;
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.gui.action.IAction;
  import com.mindtree.techworks.insight.gui.renderers.LogEventTableCellRenderer;
  import com.mindtree.techworks.insight.gui.renderers.SortableHeaderRenderer;
  import com.mindtree.techworks.insight.model.ILogEventModelMutator;
  import com.mindtree.techworks.insight.model.LogEventTableModel;
  import com.mindtree.techworks.insight.pagination.IPage;
  import com.mindtree.techworks.insight.preferences.PreferenceChangeListener;
  import com.mindtree.techworks.insight.preferences.PreferenceManager;
  import com.mindtree.techworks.insight.preferences.util.PreferenceInterpreter;
  import com.mindtree.techworks.insight.spi.LogEvent;
  
  /**
  *
  * The <code>EventListPresentation</code> class is a Presentation implementation
  * that displays summary information of LoggingEvent instances received by this
  * Presentation. This Presentation contains a JTable that displays the summary - one
  * row per event.   
  *
  * @author  Regunath B
  * @version 1.0, 04/10/25
  * @see     com.mindtree.techworks.insight.gui.Presentation
  * @see     org.apache.log4j.spi.LoggingEvent
  */
  
  public class EventListPresentation implements Presentation, ListSelectionListener, IAction, PreferenceChangeListener {	
  
  	/*
  	 * Constant that identifies the JTable widget
  	 */
  	private static final int TABLE_WIDGET = 1;
  	
  	/*
  	 * Constants for the preferred size of this Presentation 
  	 */
  	private static final int WIDTH = 900;
  	private static final int HEIGHT = 300;
  	
  	/**
  	 * Constants for scroll lock state
  	 */
  	private static final int SCROLL_LOCK = 10;
  	private static final int SCROLL_UNLOCK = 20;
  	private static final int SCROLL_JUST_UNLOCKED = 30;
  	
  	/**
  	 * Constant for the Event Column display Preference identifier
  	 */
  	private static final String EVENT_COLUMN_PREFERENCE_ID = "eventcolumnpreference";
  
  	/*
  	 * The Controller instance for this Presentation
  	 */
 	private Controller controller;
 
 	/*
 	 * The AbstractTableModel implementation that backs the JTable contained in 
 	 * this Presentation
 	 */
 	private LogEventTableModel tableModel;
 
 	/*
 	 * The JTable instance that renders the LoggingEvent instances
 	 */
 	private JTable table;
 
 	/*
 	 * The JScrollPane that contains the JTable
 	 */
 	private JScrollPane scrollPane;
 	
 	/*
 	 * The tableCellRenderer instance used for rendering the table columns
 	 */
 	private LogEventTableCellRenderer cellRenderer;
 	
 	/*
 	 * The boolean indicator to enable/disable sorting
 	 */
 	private boolean enableSort;
 	
 	/**
 	 * The scroll lock state indicator
 	 */
 	private volatile int scrollLockState = SCROLL_UNLOCK;
 	
 	/**
 	 * Constructor for this class
 	 * @param controller the Controller instance for this Presentation
 	 */
 	public EventListPresentation(Controller controller) {
 		int[] displayColumns = PreferenceInterpreter.getConfiguredColumnsForDisplay();
 		tableModel = new LogEventTableModel(displayColumns);
 		table = new JTable(tableModel);
 		initTable(displayColumns, false);
 		
         table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
         table.getTableHeader().addMouseListener(new MouseHandler(this.tableModel));		
 		
         scrollPane = new JScrollPane(table);
         scrollPane.setBorder(BorderFactory.createTitledBorder(InsightConstants.getLiteral("EVENTS")));
         scrollPane.setPreferredSize(getIdealPreferredSize());
         
         ListSelectionModel rowSM = table.getSelectionModel();
         rowSM.addListSelectionListener(this);
         
 		this.controller = controller;
 		controller.registerPresentation(this);
 		controller.registerAction(this);
 		
 		// add this PreferenceChangeListener for callback when Event column preference changes
 		PreferenceManager.getInstance().registerListener(EVENT_COLUMN_PREFERENCE_ID, this);
 		
 	}	
 
 	/**
 	 * Presentation interface method implementation. Returns the fully qualified class name
 	 * of this Presentation
 	 * @see com.mindtree.techworks.insight.gui.Presentation#getUID()
 	 */
 	public String getUID() {
 		return this.getClass().getName();
 	}
 
 	/**
 	 * Presentation interface method implementation. Does nothing
 	 * @see com.mindtree.techworks.insight.gui.Presentation#notifyWidgetStateChange(com.mindtree.techworks.insight.gui.Presentation, int, java.lang.Object)
 	 */
 	public void notifyWidgetStateChange(Presentation presentation, int identifier, Object data) {	
 	}
 	
 	/**
 	 * Presentation interface method implementation. Returns the contained JScrollPane instance
 	 * @see com.mindtree.techworks.insight.gui.Presentation#getViewComponent()
 	 */
 	public JComponent getViewComponent() {
 		return scrollPane;
 	}
 
 	/**
 	 * Presentation interface method implementation. Returns true.
 	 * @see com.mindtree.techworks.insight.gui.Presentation#doesProcessRealTimeUpdates()
 	 */
 	public boolean doesProcessRealTimeUpdates() {
 		return true;
 	}
 
 	/**
 	 * Presentation interface method implementation.Adds the event to the AbstractTableModel instance
 	 * that backs the JTable instance contained in this Presentation. 
 	 * @see com.mindtree.techworks.insight.gui.Presentation#processRealTimeUpdate(com.mindtree.techworks.insight.spi.LogEvent)
 	 */
 	public void processRealTimeUpdate(LogEvent event) {
 		if (this.scrollLockState == SCROLL_JUST_UNLOCKED) {
 			synchronized(this) {
 				try {
 					// Wait for the table model to be updated with the last set of
 					// entries and return since the last event would have been added
 					// anyway
 					wait();
 					return;
 				} catch(InterruptedException ie) {
 					// do nothing
 				}
 			}
 		}
 		int size = tableModel.getRowCount();
 		if (size >= PreferenceInterpreter.getCachePageSize()) {
 			if (!this.controller.isScrollLock() && this.controller.getMutatorType() == ILogEventModelMutator.TAILING_MUTATOR) {
 				// Clear the model if tailing mutator in order to
 				// continue to display the last received entries
 				tableModel.clearModel();
 				tableModel.addLogEvent(event);
 			}
 		} else {
 			tableModel.addLogEvent(event);
 		}
 		// If tailing, set the scrollbar position to display the last received entry
 		if (!this.controller.isScrollLock() && this.controller.getMutatorType() == ILogEventModelMutator.TAILING_MUTATOR) {
 			JScrollBar scrollBar = scrollPane.getVerticalScrollBar();
 			scrollBar.setValue(scrollBar.getMaximum());
 		}
 	}
 	
 	/** 
 	 * Interface methid implementation
 	 * @see com.mindtree.techworks.insight.gui.Presentation#resetWidgets()
 	 */
 	public void resetWidgets() {
 		tableModel.clearModel();
 	}	
 
 	/**
 	 * ListSelectionListener interface method implementation. Gets the selected
 	 * LoggingEvent and informs the Controller of a widget change. 
 	 * Note that the data Object passed by this Presentation is of type org.apache.log4j.spi.LoggingEvent
 	 * @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
 	 * @see org.apache.log4j.spi.LoggingEvent
 	 */
 	public void valueChanged(ListSelectionEvent event) {
         if (event.getValueIsAdjusting()) {
             return;
         }
         ListSelectionModel lsm = (ListSelectionModel) event.getSource();
         if (!lsm.isSelectionEmpty()) {
             Object data = tableModel.getLoggingEvent(lsm.getMinSelectionIndex());
             controller.getCurrentLogEventModel().setLogEventIndex(tableModel.getLoggingEvent(lsm.getMinSelectionIndex()).getSequenceNumber());
             // fire a widget change only when data is really available and the change has occurred from a manual
             // selection. Helps to ignore events that fire when data is loaded asynchronously into the table model
             if (data != null) {
             	controller.fireWidgetChanged(this,TABLE_WIDGET, data);
             }
         }
 	}
 
 	/**
 	 * Interface method implementation
 	 * @see Presentation#displayPage(IPage, long)
 	 */
 	public void displayPage(IPage page, long eventSequenceNumber) {
 		this.tableModel.updateDataModel(page.getLogEventList());
 		initTable(tableModel.getColumnList(), true);
 		if (eventSequenceNumber >= 0) {
 			// get the zero based index in the current page
 			int selectedIndex = ((int)((eventSequenceNumber-1) % PreferenceInterpreter.getCachePageSize()));
 			this.table.setRowSelectionInterval(selectedIndex,selectedIndex);
 			this.table.setColumnSelectionInterval(0, 0);
 			// Set the Thread to be invoked for Positioning the scrollbar after 
 			// all other GUI events have completed
 			EventQueue.invokeLater(new ScrollBarPositionLocator(page,selectedIndex));
 		} else {
 			// position the scrollbar to the start of the page
 			scrollPane.getVerticalScrollBar().setValue(0);
 		}
 	}
 	
 	/**
 	 * IAction interface method implementation
 	 * @see com.mindtree.techworks.insight.gui.action.IAction#getType()
 	 */
 	public int getType() {
 		return IAction.MUTATION;
 	}
 
 	/**
 	 * IAction interface method implementation
 	 * @see com.mindtree.techworks.insight.gui.action.IAction#setEnabled(boolean)
 	 */
 	public void setEnabled(boolean enable) {
 		this.enableSort = enable;
 	}
 	
 	/**
 	 * PreferenceChangeListener interface method implementation
 	 * @see com.mindtree.techworks.insight.preferences.PreferenceChangeListener#preferenceChanged(java.lang.String)
 	 */
 	public void preferenceChanged(String preferenceId) {
 		if (preferenceId.equals(EVENT_COLUMN_PREFERENCE_ID)) {
 			initTable(PreferenceInterpreter.getConfiguredColumnsForDisplay(), true);
 		}
 	}	
 
 	/**
 	 * Presentation Interface method implementation
 	 * @see Presentation#setScrollLock(boolean)
 	 */
 	public void setScrollLock(boolean scrollLock) {
 		this.scrollLockState = scrollLock ? SCROLL_LOCK : SCROLL_JUST_UNLOCKED;
 		if (this.scrollLockState == SCROLL_JUST_UNLOCKED) {
 			// The scroll lock is being disabled. Load the last page
 			// entries if the mutator is a tailing mutator
 			if (this.controller.getMutatorType() == ILogEventModelMutator.TAILING_MUTATOR) {
 				IPage page = this.controller.
 				getCurrentLogEventModel().getPageSet().getLastPage();
 				this.tableModel.updateDataModelAndDisplay(page.getLogEventList());
 				synchronized(this) {
 					this.scrollLockState = SCROLL_UNLOCK;
 					// wake up all waiting threads that may want to update
 					// the table model
 					notifyAll();
 				}
 			} else {
 				// set to unlocked state immediately if the mutator is not tailing
 				this.scrollLockState = SCROLL_UNLOCK;
 			}
 		}
 	}
 	
 	/**
 	 * Helper method to initialize the table display aspects
 	 * @param displayColumns array containing the display column ids
 	 * @param hasStructureChanged true if the display of table or structure has changed, false otherwise
 	 */
 	private void initTable(int[] displayColumns, boolean hasStructureChanged) {
 		this.tableModel.setColumnList(displayColumns);
 		if (hasStructureChanged) {
 			this.tableModel.fireTableStructureChanged();
 		}		
         Enumeration columns = table.getColumnModel().getColumns();
         cellRenderer = new LogEventTableCellRenderer();
 		int index = 0;
         while(columns.hasMoreElements()) {
         	TableColumn tableColumn = (TableColumn)columns.nextElement();
     		// set the identifiers and renderer for the TableColumn instances
         	tableColumn.setIdentifier(new Integer(displayColumns[index]));
         	tableColumn.setCellRenderer(cellRenderer);
         	index += 1;
         }        
         JTableHeader tableHeader = table.getTableHeader();
         tableHeader.setDefaultRenderer(
                 new SortableHeaderRenderer(tableHeader.getDefaultRenderer()));
 	}
 	
 	/**
 	 * Helper method that returns the best size between this component's preferred size and that ideal 
 	 * for the display size
 	 * @return Dimension most appropriate for this Presentation
 	 */
 	private Dimension getIdealPreferredSize() {
 		Dimension dimension = null;
 		Dimension screenDim = Toolkit.getDefaultToolkit().getScreenSize();
 		dimension = new Dimension((int)Math.min(screenDim.getWidth() - 50, WIDTH),
 				(int)Math.min(screenDim.getHeight()/3, HEIGHT));
 		return dimension;		
 	}        	
 	
 	/**
 	 * Helper class that sets the value/position of the scroll pane's the 
 	 * vertical scroll bar depending on the log event that was located.
 	 *  
 	 */
 	private class ScrollBarPositionLocator extends Thread {
 		
 		private IPage page;
 		private int selectedIndex;
 		public ScrollBarPositionLocator(IPage page, int selectedIndex) {
 			this.page = page;
 			this.selectedIndex = selectedIndex;
 		  	// explicitly set the priority to normal. Otherwise
 		  	// this thread will inherit the priority of the creator thread
 		  	// i.e the AWT event dispatch thread that runs with max priority
 			this.setPriority(Thread.NORM_PRIORITY);						
 		}		
 		public void run() {
 			JScrollBar scrollBar = scrollPane.getVerticalScrollBar();
 			int widthPerRow = scrollBar.getMaximum()/page.getLogEventList().size();
 			scrollBar.setValue(selectedIndex * widthPerRow);
 		}
 	}
 	
 	/**
 	 * Helper class that handles mouse clicks on the table header
 	 */
 
     private class MouseHandler extends MouseAdapter {
 
 		/*
 		 * The table model of the JTable
 		 */
 		private LogEventTableModel tableModel;
     	
     	/**
     	 * Constructor for this class
     	 * @param tableModel The table model for the JTable
     	 */    	
     	public MouseHandler(LogEventTableModel tableModel){
     		this.tableModel = tableModel;
     	}
     	
     	/**
     	 * Overriden super class method
     	 * @see java.awt.event.MouseAdapter#mouseClicked(java.awt.event.MouseEvent)
     	 */
         public void mouseClicked(MouseEvent e) {
         	if (table.getModel().getRowCount() < PreferenceInterpreter.getCachePageSize()) { 
 	        	if (!enableSort) {
 	        		// donot sort if current page is being updated or if no data found
 	       			return;
 	       		}
         	}
             JTableHeader h = (JTableHeader) e.getSource();
             TableColumnModel columnModel = h.getColumnModel();
             int viewColumn = columnModel.getColumnIndexAtX(e.getX());
             int column = columnModel.getColumn(viewColumn).getModelIndex();
             this.tableModel.sortColumn(this.tableModel.getColumnList()[column]);
         }
     }
 
 }