/*
    * $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.model;
  
  import java.text.SimpleDateFormat;
  import java.util.*;
  
  import javax.swing.table.AbstractTableModel;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.spi.LogEvent;
  
  /**
  *
  * The <code>LogEventTableModel</code> class is a derivative of the Swing AbstractTableModel.
  * It defines the table model used by the log viewer to display LoggingEvent summary information.
  *
  * @author  Regunath B
  * @version 1.0, 04/10/25
  * @see     javax.swing.AbstractTableModel
  * @see     org.apache.log4j.spi.LoggingEvent
  */
  
  public class LogEventTableModel extends AbstractTableModel {
  	
  	/**
  	 * Used for object serialization
  	 */
  	private static final long serialVersionUID = -6989331565976765303L;
  
  	/*
  	 * The SimpleDateFormat instance for formatting dates
  	 */
  	private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");
  
  	/*
  	 * Hashmap of column names for the JTable
  	 */
      public static final HashMap COL_NAMES = new HashMap();
      
      /*
       * Useful constants to identify the column indexes
       */
      public static final int FIRST_INDEX = 0;    
      public static final int TIME_INDEX = 0;
      public static final int THREAD_INDEX = 1;
      public static final int PRIORITY_INDEX = 2;
      public static final int CATEGORY_INDEX = 3;
      public static final int MESSAGE_INDEX = 4;
      public static final int EXCEPTION_NAME_INDEX = 5;
      public static final int METHOD_INDEX = 6;
      public static final int LINE_INDEX = 7;
      public static final int FILE_INDEX = 8;
      public static final int CLASS_INDEX = 9;
      public static final int RELATIVETIME_INDEX = 10;
      public static final int LAST_INDEX = 10;
      
      /**
       * Static initializer block to populate the column name HashMap
       */
      static{
      	COL_NAMES.put(new Integer(TIME_INDEX),InsightConstants.getLiteral("TIME_LABEL"));
      	COL_NAMES.put(new Integer(THREAD_INDEX),InsightConstants.getLiteral("THREAD_NAME_LABEL"));
      	COL_NAMES.put(new Integer(PRIORITY_INDEX),InsightConstants.getLiteral("PRIORITY_LABEL"));
      	COL_NAMES.put(new Integer(CATEGORY_INDEX),InsightConstants.getLiteral("LOGGER_NAME")); 
      	COL_NAMES.put(new Integer(MESSAGE_INDEX),InsightConstants.getLiteral("MESSAGE_LABEL")); 
      	COL_NAMES.put(new Integer(EXCEPTION_NAME_INDEX),InsightConstants.getLiteral("EXCEPTION_LABEL")); 
      	COL_NAMES.put(new Integer(METHOD_INDEX),InsightConstants.getLiteral("METHOD_LABEL"));
      	COL_NAMES.put(new Integer(LINE_INDEX),InsightConstants.getLiteral("LINE_LABEL")); 
      	COL_NAMES.put(new Integer(FILE_INDEX),InsightConstants.getLiteral("FILE_LABEL")); 
      	COL_NAMES.put(new Integer(CLASS_INDEX),InsightConstants.getLiteral("CLASS_LABEL")); 
      	COL_NAMES.put(new Integer(RELATIVETIME_INDEX),InsightConstants.getLiteral("RELATIVETIME_LABEL")); 
      };    
  	    
  	/*
  	 * Collection that stores the LoggingEvent instances currently rendered by
  	 * the JTable backed by this AbstractTableModel
  	 */
 	private List eventList = new ArrayList();
 
 	/*
 	 * The ModelDataSorter instance that does data sorting for this TableModel
 	 */
 	private ModelDataSorter modelDataSorter;
 	
 	/*
 	 * Array of table column identifiers
 	 */
 	private int[] columnList;
 	
 	/**
 	 * Constructor for this class 
 	 * @param int array containing valid column identifiers defined in this class
 	 */
 	public LogEventTableModel(int[] columnList) {
 		this.columnList = columnList;
 		modelDataSorter = new ModelDataSorter();
 	}
 	
 	/**
 	 * Dynamically changes the columns displayed by this model to the ones
 	 * specified
 	 * @param columnList int array containing valid column identifiers defined in this class
 	 */
 	public void changeDisplayColumns(int[] columnList) {
 		this.columnList = columnList;
 		modelDataSorter.resetSortParams();
 		super.fireTableStructureChanged();
 	}
 	
 	/**
 	 * Superclass method implementation
 	 * @see javax.swing.table.TableModel#getRowCount()
 	 */
 	public int getRowCount() {
 		return eventList.size();
 	}
 	
 	/**
 	 * Superclass method implementation
 	 * @see javax.swing.table.TableModel#getColumnCount()
 	 */
 	public int getColumnCount() {
 		return columnList.length;
 	}
 
 	/**
 	 * Superclass method implementation
 	 * @see javax.swing.table.TableModel#getColumnName(int)
 	 */
     public String getColumnName(int col) {
         return (String)COL_NAMES.get(new Integer(columnList[col]));
     }
 
     /**
      * Adds the specified LoggingEvent to the list of events rendered by the
      * JTable backed by this AbstractTableModel
      * @param event the LogEvent to be added to the model
      */
     public void addLogEvent(LogEvent event) {
 		eventList.add(event);
 		int startIndex = eventList.size() - 2;
 		int endIndex = eventList.size() - 1;
 		fireTableRowsInserted(startIndex < 0 ? 0 : startIndex, endIndex < 0 ? 0 : endIndex);
 	}
 
     /**
      * Gets the LogEvent from the model, identifed by the specified index
      * @param index index of the LogEvent in the internal List
      * @return LogEvent available at the specified index
      */
 	public LogEvent getLoggingEvent(int index) {
 		// Need this check to take care of value-change events that fire while data is being added to this Model
 		if (index >= eventList.size()) {
 			return null;
 		}
 		return (LogEvent)eventList.get(index);
 	}
 
 	/**
 	 * Superclass method implementation
 	 * @see javax.swing.table.TableModel#getValueAt(int, int)
 	 */
 	public Object getValueAt(int rowIndex, int columnIndex) {		
 		if (rowIndex < eventList.size()) {
 			LogEvent event = (LogEvent)eventList.get(rowIndex);
 			switch(columnList[columnIndex]) {
 				case TIME_INDEX:
 		        	return DATE_FORMAT.format(new Date(event.getTimeStamp()));
 				case THREAD_INDEX:
 					return event.getThreadName();
 				case PRIORITY_INDEX:
 					return event.getLevel();
 				case CATEGORY_INDEX:
 					return event.getLoggerName();
 				case MESSAGE_INDEX:
 					return event.getMessage();
 				case EXCEPTION_NAME_INDEX:
 					return event.getExceptionName();
 				case METHOD_INDEX:
 					return event.getLocationInformation().getMethodName();
 				case LINE_INDEX:
 					return event.getLocationInformation().getLineNumber();
 				case FILE_INDEX:
 					return event.getLocationInformation().getFileName();
 				case CLASS_INDEX:
 					return event.getLocationInformation().getClassName();
 				case RELATIVETIME_INDEX:
 					return String.valueOf(event.getRelativeTime());
 			}
 		}
 		return null;
 	}
 	
 	/**
 	 * Sorts the data held by this TableModel.
 	 * @param columnIndex the index of column data that needs to be sorted
 	 */
 	public void sortColumn(int columnIndex) {
 		modelDataSorter.sortData(columnIndex, this.eventList);
 		super.fireTableDataChanged();		
 	}
 	
     /**
      * Returns the sort order for the column specified by the columnIndex
      * @param columnIndex the index of the column whose sort order is needed
      * @return the valid sort order as defined by the ModelDataSorter class
      */
     public int getSortOrder(int columnIndex) {
     	return modelDataSorter.getSortOrder(this.columnList[columnIndex]);
     }
     
     /**
      * Clears the data contained by this TableModel. Updates the JTable
      * backed by this TableModel.
      */
     public void clearModel() {
     	eventList.clear();
     	super.fireTableDataChanged();
     	modelDataSorter.resetSortParams();
     }
 
 	/**
 	 * Updates this TableModel with the data specified. The data 
 	 * maintained by this model is cleared and the ones in the specified
 	 * List added.
 	 * @param logEventList the List of LogEvent instances to update this model with
 	 */
 	public void updateDataModel(List logEventList) {
     	eventList.clear();
     	modelDataSorter.resetSortParams();
     	// add the log events from the supplied list to the list maintained by this 
     	// log event model
     	for (int i = 0; i < logEventList.size(); i++) {
     		this.eventList.add(logEventList.get(i));
     	}
 		/*
 		 * Note: 
 		 * super.fireTableDataChanged(); is intentionally not being called
 		 * because this method is called in response to a page change where
 		 * the table is anyway re-inited.
 		 */
 	}    
 	
 	/**
 	 * Updates this TableModel and the display with the data specified. The data 
 	 * maintained by this model is cleared and the ones in the specified
 	 * List added.
 	 * @param logEventList the List of LogEvent instances to display
 	 */
 	public void updateDataModelAndDisplay(List logEventList) {
 		this.updateDataModel(logEventList);
 		super.fireTableDataChanged();
 	}
 	
 	/**
 	 * @return Returns the columnList.
 	 */
 	public int[] getColumnList() {
 		return columnList;
 	}
 	/**
 	 * @param columnList The columnList to set.
 	 */
 	public void setColumnList(int[] columnList) {
 		this.columnList = columnList;
 	}
 }