package com.explosion.datastream.exql.gui.dbbrowser;
   
   /*
    * =============================================================================
    * 
    * Copyright 2004 Stephen Cowx
    * 
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   * 
   * http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   * 
   * =============================================================================
   */
  
  import java.awt.BorderLayout;
  import java.awt.FontMetrics;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Vector;
  
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;
  import javax.swing.table.DefaultTableModel;
  import javax.swing.table.JTableHeader;
  import javax.swing.table.TableColumn;
  
  import org.apache.log4j.LogManager;
  import org.apache.log4j.Logger;
  
  import com.explosion.datastream.exql.EXQLConstants;
  import com.explosion.datastream.exql.EXQLModuleManager;
  import com.explosion.datastream.exql.gui.EXQLBaseTool;
  import com.explosion.datastream.exql.gui.table.DsProTable;
  import com.explosion.datastream.exql.gui.table.Sort_HeaderRenderer;
  import com.explosion.datastream.exql.gui.table.Sort_MouseListener;
  import com.explosion.expf.Application;
  import com.explosion.expfmodules.rdbmsconn.dbom.DBEntity;
  import com.explosion.expfmodules.rdbmsconn.dbom.DBEntityBuffer;
  import com.explosion.expfmodules.rdbmsconn.dbom.DataSet;
  import com.explosion.utilities.GeneralUtils;
  import com.explosion.utilities.RowHeaderUtil;
  import com.explosion.utilities.exception.ExceptionManagerFactory;
  
  /***
   * @author Stephen Cowx
   */
  
  public class TabularDataView extends JPanel {
  
  	private static Logger log = LogManager.getLogger(TabularDataView.class);
  	private JScrollPane scrollPane = new JScrollPane();
  	private DsProTable dataTable;
  
  	private Sort_MouseListener mouseListener = null;
  	private Sort_HeaderRenderer headerRenderer = null;
      private JLabel label;
  	
  	/* A map containing the last columnWidths if there was no DBEntityData */
  	private Map lastColumnWidths = new HashMap();
  
  	/***
  	 * Constructor
  	 */
  	public TabularDataView(EXQLBaseTool tool, boolean editable) {
  		try {
  			dataTable = new DsProTable(tool, editable);
  			init();
  		} catch (Exception e) {
  			ExceptionManagerFactory.getExceptionManager().manageException(e,
  					"Exception caught while constructing data view.");
  		}
  	}
  
  	/***
  	 * Initialises the panel
  	 */
  	private void init() throws Exception {
  		this.setLayout(new BorderLayout());
  		this.add(scrollPane, BorderLayout.CENTER);
  		scrollPane.getViewport().add(dataTable, null);
  		
  	}
  
  	/***
  	 * Applies the properties for this tool;
  	 */
 	public void applyPreferences() {
 
 		dataTable.applyPreferences();
 	}
     
     /***
      * Adds a label with the specified message
      */
     private void addLabel(String message)
     {
         label = new JLabel(message);
         label.setName(message);
         this.add(label, BorderLayout.NORTH);
     }
     /***
      * Removes a label with the specified message if it exists
      */
     private void removeLabel()
     {
         if (label != null)
         {
           this.remove(label);
           this.label = null;
         }
     }
 
 	/***
 	 * This method updates the displayed values
 	 */
 	public void update(EXQLBaseTool tool) {
 		try {
 			DataSet set = tool.getCurrentEntityMetaData().getDataSet();
 			DBEntity dbed = tool.getCurrentEntityMetaData().getDbEntity();
             removeLabel();
             
 			if (set != null) {
 				log.debug("Dbed: " + dbed);
                 Application.ensureLocalCookie(EXQLConstants.MENU_EXPORT, 1, tool);
                 
                 
                 RowHeaderUtil util = new RowHeaderUtil();
 				util.setRowHeader(dataTable, false);
 				
                 /* Mark it as not editable if there is no metadata or no primary key */
                 if (dbed == null || dbed.getPrimaryKeyColumns().size() < 1)
                 {
                     dataTable.setEditable(false);
                     if (dbed != null)
                     {
                         addLabel("No primary key defined, edits not allowed on this table");
                     }
                 }
                 else
                 {
                     dataTable.setEditable(true);
                     
                 }
                 dataTable.setModel(set.getTableModel());
 
 				if (dbed != null) {
 					/*
 					 * Add listeners for the column widths and set the widths if
 					 * they have been persisted from last time
 					 */
 					boolean widthsSet = false;
 					Enumeration eneration = dataTable.getColumnModel()
 							.getColumns();
 					while (eneration.hasMoreElements()) {
 						TableColumn column = (TableColumn) eneration
 								.nextElement();
 
 						ColumnWidthListener listener = new ColumnWidthListener(
 								dbed.getDBEntityBuffer(), (String) column
 										.getHeaderValue());
 						column.addPropertyChangeListener(listener);
 
 					}
                }
                
 				
 				/* Add lsiteners and renderes for sorting */
 				JTableHeader header = dataTable.getTableHeader();
 				if (header != null) {
 					if (dbed != null) {
 						if (mouseListener == null) {
 							mouseListener = new Sort_MouseListener(tool.getViewer());
 							header.addMouseListener(mouseListener);
                             header.setToolTipText("Double click on this header to sort by this column.  Shift Double click to remove the sort.  Cntrl Double Click to reverse the sort");
 							headerRenderer = new Sort_HeaderRenderer(dataTable);
 							header.setDefaultRenderer(headerRenderer);
 						}
 
 						mouseListener.setEntity(dbed);
 						headerRenderer.setEntity(dbed);
 					} else {
 						header.removeMouseListener(mouseListener);
 						//header.setDefaultRenderer(null);
 						mouseListener = null;
 						headerRenderer = null;
 					}
 				}
 
 				int maxWidth = ((Integer) EXQLModuleManager.instance().getPreference(EXQLConstants.RDBMS_OPTION_MAX_AUTO_COLUMNWIDTH).getValue()).intValue();
 				
 				/* Size the columns to fit */
                 sizeColumnsToFitWidths(dbed != null ? dbed.getDBEntityBuffer() : null, dataTable, set
 						.getLongestEntries(), set.getColumnNames(), maxWidth, true);
 			} else {
                 Application.ensureLocalCookie(EXQLConstants.MENU_EXPORT, 0, tool);
 				show_NoInfo_Message();
 			}
 		} catch (Exception ex) {
 			ExceptionManagerFactory.getExceptionManager()
 					.manageException(ex,
 							"Experienced exception while populating view of table data.");
 			show_NoInfo_Message();
 		}
 	}
 
 	/***
 	 * Returns the dataTable.
 	 * 
 	 * @return JTable
 	 */
 	public DsProTable getDataTable() {
 		return dataTable;
 	}
 
 	public void showMessage(String message) {
 		FontMetrics fontMetrics = dataTable.getFontMetrics(dataTable.getFont());
 		int width = fontMetrics.stringWidth(message);
 		String[] longestEntry = {message};
 
 		this.dataTable.setModel(GeneralUtils.getEmptyModel(message));
 		GeneralUtils.sizeColumnsToFitWidths(dataTable, longestEntry, null, 500,
 				false);
 	}
 
 	public void show_NoInfo_Message() {
 		showMessage("No information to show.");
 	}
 
 	public void clear() {
 		dataTable.setModel(new DefaultTableModel(new Vector(), new Vector()));
 	}
 
 	/***
 	 * This method sizes a tables columns sensibly. It requires quite a lot of
 	 * info.
 	 */
 	private void sizeColumnsToFitWidths(DBEntityBuffer buffer, JTable table,
 			String[] longestColumnEntries, Vector columnNames, int maxWidth,
 			boolean includeColumnNames) {
 		if (table == null || longestColumnEntries == null)
 			return;
 
 		if (includeColumnNames && columnNames == null)
 			throw new IllegalArgumentException(
 					"Invalid use of method, includeColumnNames is true but no names have been provided.");
 
 		FontMetrics fontMetrics = table.getFontMetrics(table.getFont());
 		Enumeration columns = table.getColumnModel().getColumns();
 		int i = 0;
 		
 		while (columns.hasMoreElements()) {
 			int width = -1;
 			TableColumn column = (TableColumn) columns.nextElement();
 			if (buffer != null)
 			    width = buffer.getColumnWidth((String) column.getHeaderValue());
 			
 			if (width >= 0) {
 				/*
 				 * This column width has been set before so we reset it to it's
 				 * last value and move on to the next column
 				 */
 				column.setWidth(width);
 				column.setPreferredWidth(width);
 				continue;
 			}
 
 			if (includeColumnNames)
 			{
 				if (column.getHeaderValue().equals("CAPTUREDATE"))
 					{
 					  int f=0;
 					}
 				
 				if (longestColumnEntries[i].length() < ((String) columnNames.elementAt(i)).length())
 				{
 			    	width = fontMetrics.stringWidth((String) columnNames.elementAt(i)) + 10;
 				}
 				else
 				{
 					width = fontMetrics.stringWidth(longestColumnEntries[i]) + 10;
 				}
 			}
 			else
 			{
 				width = fontMetrics.stringWidth(longestColumnEntries[i]) + 10;
 			}
 
 			if (width > maxWidth) {
 				if (buffer != null)
 				   buffer.setColumnWidth((String) column.getHeaderValue(),
 						maxWidth);
 				column.setWidth(maxWidth);
 				column.setPreferredWidth(maxWidth);
 			} else {
 				column.setWidth(width);
 				column.setPreferredWidth(width);
 				if (buffer != null)
 					buffer.setColumnWidth((String) column.getHeaderValue(), width);
 			}
 			i++;
 		}
 	}
 
 	/***
 	 * @return Returns the scrollPane.
 	 */
 	public JScrollPane getScrollPane() {
 		return scrollPane;
 	}
 }
 /***
  * This class monitors the width of the column as the user changes it then sets
  * the correct width in the DBEntity Buffer so that the user will get the same
  * size columns when they come back next time.
  * 
  * @author Stephen Created on Apr 29, 2004
  */
 
 class ColumnWidthListener implements PropertyChangeListener {
 
 	private DBEntityBuffer buffer;
 	private String columnName;
 	private Map lastColumnWidths;
 	private static Logger log = LogManager.getLogger(ColumnWidthListener.class);
 
 	/***
 	 * Constructor
 	 * 
 	 * @param buffer
 	 * @param columnName
 	 */
 	public ColumnWidthListener(DBEntityBuffer buffer, String columnName) {
 		this.buffer = buffer;
 		this.columnName = columnName;
 		//this.lastColumnWidths = lastColumnWidths;
 	}
 
 	/***
 	 * changes the entitybuffer column width if appropriate
 	 * 
 	 * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
 	 * @param event
 	 */
 	public void propertyChange(PropertyChangeEvent event) {
 		if (event.getPropertyName().equals("width")) {
 			buffer.setColumnWidth(columnName, ((Number) event.getNewValue())
 					.intValue());
 		}
 	}
 }