/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common 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.
   *
   * CosyBeans-Common 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 CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components.table;
  
  import com.cosylab.logging.DebugLogger;
  
  import com.cosylab.util.ObjectList;
  
  import java.util.LinkedList;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.SwingUtilities;
  import javax.swing.event.TableModelEvent;
  import javax.swing.event.TableModelListener;
  import javax.swing.table.TableModel;
  
  
  /**
   * <code>QueueTableModelInterceptor</code> wraps around <code>TableModel</code>
   * and intercepts update events. All events are queued and dispatched in AWT
   * thread. Similar events are integrated into one event. This makes updates
   * from delegate GUI thread safe and prevents table to be updated unnecessary.
   * 
   * <p>
   * Tu use interceptor, create your model, create interceptor and pass your
   * model as parameter, then add to the table interceptor as model. Listen to
   * model events directly on your model and not on interceptor or on model,
   * which is rerturned from the table (except if <code>QueueTable</code>
   * becouse it completly hides the interceptor).
   * </p>
   *
   * @author <a href="mailto:igor.kriznar@cosylab.com">Igor Kriznar</a>
   * @version $Id: QueueTableModelInterceptor.java,v 1.11 2008-08-25 11:18:22 jbobnar Exp $
   *
   * @since May 3, 2004.
   */
  public class QueueTableModelInterceptor implements TableModel,
  	TableModelListener, Runnable
  {
  	private final TableModel delegate;
  	private ObjectList listeners = new ObjectList(TableModelListener.class);
  	private final LinkedList<TableModelEvent> queue = new LinkedList<TableModelEvent>();
  	private final Logger logger = DebugLogger.getLogger("QTMI", Level.OFF);
  	private Interceptor updater;
  	private int relaxationTime=1000;
  	private boolean destroyed=false;
  
  	class Interceptor extends Thread
  	{
  		long last = System.currentTimeMillis();
  		boolean update = false;
  
  		public Interceptor() {
  			super();
  		}
  		/**
  		 * DOCUMENT ME!
  		 */
  		public synchronized void run()
  		{
  			while (!destroyed) {
  				long t = System.currentTimeMillis();
  
  				if (update) {
  					if (t - last > relaxationTime || t-last + 1 <= 0) {
  						SwingUtilities.invokeLater(QueueTableModelInterceptor.this);
  						last = t;
  						update = false;
  					} else {
  						try {
  							wait(t - last + 1);
  						} catch (Exception e) {
  							e.printStackTrace();
  						}
  					}
  				} else {
  					try {
  						wait(0);
  					} catch (Exception e) {
  						e.printStackTrace();
  					}
 				}
 			}
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 */
 		public synchronized void update()
 		{
 			update = true;
 			notifyAll();
 		}
 	}
 
 	/**
 	 * Creates a new QueueTableModelInterceptor object.
 	 *
 	 * @param delegate the wrapped model
 	 */
 	public QueueTableModelInterceptor(TableModel delegate)
 	{
 		//assert (delegate != null);
 		this.delegate = delegate;
 
 		delegate.addTableModelListener(this);
 		
 		updater = new Interceptor();
 		updater.start();
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnCount()
 	 */
 	public int getColumnCount()
 	{
 		return delegate.getColumnCount();
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getRowCount()
 	 */
 	public int getRowCount()
 	{
 		return delegate.getRowCount();
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#isCellEditable(int, int)
 	 */
 	public boolean isCellEditable(int rowIndex, int columnIndex)
 	{
 		return delegate.isCellEditable(rowIndex, columnIndex);
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnClass(int)
 	 */
 	public Class<?> getColumnClass(int columnIndex)
 	{
 		return delegate.getColumnClass(columnIndex);
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getValueAt(int, int)
 	 */
 	public Object getValueAt(int rowIndex, int columnIndex)
 	{
 		return delegate.getValueAt(rowIndex, columnIndex);
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#setValueAt(java.lang.Object, int, int)
 	 */
 	public void setValueAt(Object aValue, int rowIndex, int columnIndex)
 	{
 		delegate.setValueAt(aValue, rowIndex, columnIndex);
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnName(int)
 	 */
 	public String getColumnName(int columnIndex)
 	{
 		return delegate.getColumnName(columnIndex);
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#addTableModelListener(javax.swing.event.TableModelListener)
 	 */
 	public void addTableModelListener(TableModelListener l)
 	{
 		listeners.add(l);
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#removeTableModelListener(javax.swing.event.TableModelListener)
 	 */
 	public void removeTableModelListener(TableModelListener l)
 	{
 		listeners.remove(l);
 	}
 
 	/**
 	 * The model which is wrapped by this interceptor.
 	 *
 	 * @return
 	 */
 	public TableModel getDelegate()
 	{
 		return delegate;
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.event.TableModelListener#tableChanged(javax.swing.event.TableModelEvent)
 	 */
 	public void tableChanged(TableModelEvent e)
 	{
 		enqueue(e);
 	}
 
 	protected void fire(TableModelEvent e)
 	{
 		logger.fine("column= " + e.getColumn() + " row= " + e.getFirstRow()
 		    + "-" + e.getLastRow() + " type= " + e.getType());
 
 		TableModelListener[] l = (TableModelListener[])listeners.toArray();
 
 		for (int i = 0; i < l.length; i++) {
 			try {
 				l[i].tableChanged(e);
 			} catch (Exception ex) {
 				ex.printStackTrace();
 			}
 		}
 	}
 
 	protected synchronized void enqueue(TableModelEvent e)
 	{
 		logger.fine("adding column= " + e.getColumn() + " row= "
 		    + e.getFirstRow() + "-" + e.getLastRow() + " type= " + e.getType());
 
 		TableModelEvent ev = queue.size() > 0
 			? (TableModelEvent)queue.getLast() : null;
 
 		// now we try to merge last two events, if they are of same type
 		if (ev != null
 		    && (ev.getType() == e.getType()
   	        //bugfix RT#10735 by jkamenik
 		    //this would not work correctly if ev has not HEADER_ROW type event
 		    //|| e.getType() == TableModelEvent.HEADER_ROW
 			//end bugfix
 		    || ev.getType() == TableModelEvent.HEADER_ROW)) {
 			
 		    int col = ev.getColumn();
 
 			if (col != e.getColumn()) {
 				col = TableModelEvent.ALL_COLUMNS;
 			}
 
 			int first = ev.getFirstRow();
 
 			if (first > e.getFirstRow()) {
 				first = e.getFirstRow();
 			}
 
 			int last = ev.getLastRow();
 
 			if (last < e.getLastRow() && last != TableModelEvent.HEADER_ROW) {
 				last = e.getLastRow();
 			}
 
 			//System.out.println("Merging ("+first+","+last+","+col+") from ("+ev.getFirstRow()+","+ev.getLastRow()+","+ev.getColumn()+") and ("+e.getFirstRow()+","+e.getLastRow()+","+e.getColumn()+")");
 			// last check if we have actually generated new event
 			if (col != ev.getColumn() || first != ev.getFirstRow()
 			    || last != ev.getLastRow()) {
 				queue.removeLast();
 				logger.fine("added column= " + col + " row= " + first + "-"
 				    + last + " type= " + ev.getType());
 				queue.add(new TableModelEvent(this, first, last, col,
 				        ev.getType()));
 
 				//System.out.println("Merged "+queue.size());
 				/*System.out.println("Merged (" + first + "," + last + "," + col
 				    + ") from (" + ev.getFirstRow() + "," + ev.getLastRow()
 				    + "," + ev.getColumn() + ") and (" + e.getFirstRow() + ","
 				    + e.getLastRow() + "," + e.getColumn() + ")");*/
 				updater.update();
 			}
 		} else {
 			// new event added to the queue
 			logger.fine("added column= " + e.getColumn() + " row= "
 			    + e.getFirstRow() + "-" + e.getLastRow() + " type= "
 			    + e.getType());
 			queue.add(e);
 
 			updater.update();
 		}
 	}
 
 	protected synchronized TableModelEvent dequeue()
 	{
 		return queue.size() > 0 ? queue.removeFirst() : null;
 	}
 
 	/* (non-Javadoc)
 	 * @see java.lang.Runnable#run()
 	 */
 	public void run()
 	{
 		TableModelEvent e;
 
 		while ((e = dequeue()) != null) {
 			//System.out.println("Update ("+e.getFirstRow()+","+e.getLastRow()+","+e.getColumn()+")");
 			if (e.getSource() == this) {
 				fire(e);
 			} else {
 				fire(new TableModelEvent(this, e.getFirstRow(), e.getLastRow(),
 				        e.getColumn(), e.getType()));
 			}
 		}
 	}
 
 	/**
 	 * Returns minimum time betwean two table updates interceptor will wait.
 	 * @return minimum time betwean two table updates 
 	 */
 	public int getRelaxationTime() {
 		return relaxationTime;
 	}
 
 	/**
 	 * Sets minimum time betwean two table updates interceptor will wait.
 	 * @param relaxationTime
 	 */
 	public void setRelaxationTime(int relaxationTime) {
 		this.relaxationTime = relaxationTime;
 		updater.update();
 	}
 
 	/**
 	 * Returns <code>true</code> after destroy was called.
 	 * @return <code>true</code> if destroyed
 	 */
 	public boolean isDestroyed() {
 		return destroyed;
 	}
 	
 	/**
 	 * Clears internal interceptor thread.
 	 *
 	 */
 	public void destroy() {
 		destroyed=true;
 		updater.update();
 		
 		delegate.removeTableModelListener(this);
 		listeners.clear();
 		queue.clear();
 	}
 }
 
 /* __oOo__ */