/***
    * Copyright (C) 2006 Philipp Mpalampanis
    *
    * License: MPL 1.1/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Mozilla Public License Version
    * 1.1 (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.mozilla.org/MPL/
   *
   * Software distributed under the License is distributed on an "AS IS" basis,
   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
   * for the specific language governing rights and limitations under the
   * License.
   *
   * Alternatively, the contents of this file may be used under the terms of
   * either the GNU General Public License Version 2 or later (the "GPL"), or
   * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the MPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the MPL, the GPL or the LGPL.
   */
  
  package net.sf.echobinding.table;
  
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.*;
  
  import net.sf.echobinding.binding.BindingContext;
  import net.sf.echobinding.binding.PropertyAdapter;
  import nextapp.echo2.app.*;
  import nextapp.echo2.app.event.ActionEvent;
  import nextapp.echo2.app.event.ActionListener;
  import nextapp.echo2.app.table.TableCellRenderer;
  import nextapp.echo2.app.table.TableModel;
  
  import org.apache.log4j.Logger;
  
  /***
   * A data bound table. Displays a list of items in form of a table. The columns
   * of the table are defined by the property adapters of the given
   * <code>BindingContext</code>.
   * 
   * A <code>BoundTable</code> uses by default the
   * <code>DefaultDataBoundTableCellRenderer</code> for rendering its cells.
   * 
   * @param <T> The type of the obejcts in the list.
   */
  public class BoundTable<T> extends Table implements ActionListener, PropertyChangeListener {
  
  	private static final long serialVersionUID = 3177515466581414146L;
  
  	private Logger _logger = Logger.getLogger( getClass() );
  	
  	/***
  	 * The list of items.
  	 */
  	protected List<T> _list;
  
  	/***
  	 * The binding context.
  	 */
  	protected BindingContext _ctx;
  
  	/***
  	 * The property adapters.
  	 */
  	private List<PropertyAdapter> _columnAdapters = new ArrayList<PropertyAdapter>();
  
  	/***
  	 * The ActionListeners.
  	 */
  	private ActionListener _actionListener;
  
  	/***
  	 * Array of binding contexts. There will be one context for each row in the table.
  	 */
  	private BindingContext[] _rowContexts;
  
  	/***
  	 * The header background color.
  	 */
  	private Color _headerBackground;
  
  
  	private DetailsHandler _detailHandler;
  	
  	/***
  	 * Creates a data bound table using a list. 
  	 * 
  	 * @param list the list of items
  	 * @param ctx the binding context
  	 */
 	public BoundTable(List<T> list, BindingContext ctx) {
 		super();
 
 		_list = list;
 		_ctx = ctx;
 
 	}
 
 	@Override
 	public void init() {
 		super.init();
 		initialize();
 	}
 	
 	
 	
 	/***
 	 * Creates a data bound table using a list adapter. 
 	 * 
 	 * @param listAdapterId the list adapter id
 	 * @param ctx the binding context
 	 */
 	@SuppressWarnings("unchecked")
 	public BoundTable(String listAdapterId, BindingContext ctx) {
 		this((List<T>) ctx.getValue(listAdapterId), ctx);
 	}
 
 	
 	/***
 	 * Adds a column for the specified adpater to the table.
 	 * 
 	 * @param adapterId the adapter id
 	 * 
 	 * @return the data bound table
 	 */
 	public BoundTable<T> addColumn(String adapterId) {
 		return addColumn(null, adapterId);
 	}
 
 	/***
 	 * Removes a column from the table.
 	 * 
 	 * @param adapterId The adapter id of the column to be removed
 	 * 
 	 * @return true, if the column was successfully removed, false else
 	 */
 	public boolean removeColumn(String adapterId) {
 		return getColumnAdapters().remove( _ctx.getAdapter(adapterId));
 	}
 
 	/***
 	 * Adds a column at the specified position to the table.
 	 * 
 	 * @param adapterId the adapter id
 	 * @param columnIndex the column index
 	 * 
 	 * @return the data bound table
 	 */
 	public BoundTable<T> addColumn(Integer columnIndex, String adapterId ) {
 		if(columnIndex!=null)
 			_columnAdapters.add( columnIndex, _ctx.getAdapter(adapterId) );
 		else
 			_columnAdapters.add( _ctx.getAdapter(adapterId) );
 		return this;
 	}
 	
 	
 	
 	/***
 	 * Initializes the table. Extracts the table headers from the binding
 	 * context and creates the table data.
 	 */
 	protected void initialize() {
 
 		_rowContexts = new BindingContext[ _list.size() ];
 		int i = 0;
 		for (T row : getList() ) _rowContexts[i++] = _ctx.createChild().setModel(row);
 		
 		setModel(createTableModel());
 
 		setDefaultHeaderRenderer(getTableHeaderRenderer());
 
 		TableCellRenderer defaultRenderer = getTableCellRenderer();
 		setDefaultRenderer(Integer.class, defaultRenderer);
 		setDefaultRenderer(String.class, defaultRenderer);
 		setDefaultRenderer(Double.class, defaultRenderer);
 		setDefaultRenderer(Long.class, defaultRenderer);
 		setDefaultRenderer(Boolean.class, defaultRenderer);
 		setDefaultRenderer(Object.class, defaultRenderer);
 		
 		// collections rendering 
 		BoundTableCollectionCellRenderer listTableCellRenderer = new BoundTableCollectionCellRenderer();
 		setDefaultRenderer(HashSet.class, listTableCellRenderer);
 		setDefaultRenderer(Collection.class, listTableCellRenderer);
 		setDefaultRenderer(List.class, listTableCellRenderer);
 
 		setBorder(new Border(1, Color.DARKGRAY, Border.STYLE_SOLID));
 		
 		setInsets(new Insets(5,5));
 		
 	}
 
 	/***
 	 * Gets the table header renderer.
 	 * 
 	 * @return the table header renderer
 	 */
 	protected BoundTableHeaderRenderer getTableHeaderRenderer() {
 		return new BoundTableHeaderRenderer();
 	}
 
 	/***
 	 * Gets the table cell renderer.
 	 * 
 	 * @return the table cell renderer
 	 */
 	protected TableCellRenderer getTableCellRenderer() {
 		return new DefaultDataBoundTableCellRenderer();
 	}
 
 	/***
 	 * Creates the table model.
 	 * 
 	 * @return the table model
 	 */
 	protected TableModel createTableModel() {
 		return new BoundTableModel(createTableHeaderData(), createTableData());
 	}
 
 	/***
 	 * Creates the table data.
 	 * 
 	 * @return the object[][]
 	 */
 	protected Object[][] createTableData() {
 		
 		Object[][] data = new Object[getList().size()][getColumnAdapters().size()];
 		int rowIndex = 0;
 		for (Object obj : getList()) {
 			data[rowIndex++] = createRow(obj);
 		}
 		 
 		return data;
 	}
 
 	/***
 	 * Creates the table header data.
 	 * 
 	 * @return the object[]
 	 */
 	protected Object[] createTableHeaderData() {
 		
 		// use adapter labels as table headers
 		ArrayList<String> tmp = new ArrayList<String>();
 		for (PropertyAdapter adapter : getColumnAdapters()) {
 			tmp.add( adapter.getLabel() );
 		}
 		Object[] tableHeaderData = tmp.toArray(new Object[0]);
 		
 		return tableHeaderData;
 	}
 
 	/***
 	 * Creates a row from the given bean.  
 	 * 
 	 * @param rowData the row data
 	 * @return a row in form of an array
 	 */
 	@SuppressWarnings("unchecked")
 	private Object[] createRow(Object rowData) {
 
 		ArrayList<Object> row = new ArrayList<Object>();
 		for (PropertyAdapter binding : getColumnAdapters()) {
 			Object value = binding.getValue(rowData);
 			if (value instanceof Set) {
 				row.add( new HashSet((Set)value) );
 			}
 			else {
 				row.add(value);
 			}
 		}
 		return row.toArray(new Object[0]);
 	}
 
 	/***
 	 * Returns the adapter id for the specified column. The adapter id can be
 	 * used in the TableCellRenderer to create data bound widgets.
 	 * 
 	 * @param col the col
 	 * @return the binding id for the given column index
 	 */
 	public String getAdapterId(int col) {
 		return getColumnAdapters().get(col).getId();
 	}
 
 	/***
 	 * Returns the binding context for the specified row. The binding id can be
 	 * used in the TableCellRenderer to create data bound widgets.
 	 * 
 	 * @param rowIndex the index of the row
 	 * @return the binding context for the given row index
 	 */
 	public BindingContext getBindingContext(int rowIndex) {
 		return _rowContexts[rowIndex];
 	}
 
 	public void actionPerformed(ActionEvent event) {}
 
 	/***
 	 * Returns the action listener.
 	 * 
 	 * @return the action listener
 	 */
 	public ActionListener getActionListener() {
 		return _actionListener;
 	}
 
 	/***
 	 * Sets the action listener.
 	 * 
 	 * @param actionListener the action listener
 	 */
 	public void setActionListener(ActionListener actionListener) {
 		_actionListener = actionListener;
 	}
 
 	/***
 	 * Returns the item for the specified row index.
 	 * 
 	 * @param row - the row index
 	 * @return the item for the given row index
 	 */
 	protected T getItem(int row) {
 		return _list.get(row);
 	}
 
 	
 	/* (non-Javadoc)
 	 * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
 	 */
 	public void propertyChange(PropertyChangeEvent event) {
 		
 		System.err.println(this.getClass()+"::propertyChange::"+event.getPropertyName());
 		// initialize();
 	}
 
 	/***
 	 * Returns the column adapters.
 	 * 
 	 * @return Returns the property adapters for this table.
 	 */
 	public List<PropertyAdapter> getColumnAdapters() {
 		return _columnAdapters;
 	}
 
 	/***
 	 * Sets the column adapters.
 	 * 
 	 * @param columnAdapters The column adapters to set.
 	 */
 	public void setColumnAdapters(List<PropertyAdapter> columnAdapters) {
 		_columnAdapters = columnAdapters;
 	}
 
 	/***
 	 * Returns the list.
 	 * 
 	 * @return Returns the list.
 	 */
 	public List<T> getList() {
 		return _list;
 	}
 
 	/***
 	 * Sets the list.
 	 * 
 	 * @param list The list to set.
 	 */
 	public void setList(List<T> list) {
 		_list = list;
 	}
 
 	/***
 	 * Returns the header background color.
 	 * 
 	 * @return the header background color
 	 */
 	public Color getHeaderBackground() {
 		return _headerBackground;
 	}
 
 	/***
 	 * Sets the header background color.
 	 * 
 	 * @param headerBackground the header background
 	 */
 	public void setHeaderBackground(Color headerBackground) {
 		_headerBackground = headerBackground;
 	}
 	
 	/***
 	 * @param columnIndex 
 	 * @param rowIndex 
 	 */
 	@SuppressWarnings("unchecked")
 	protected void showDetails(int columnIndex, int rowIndex) {
 		
 		if(getDetailHandler() == null) {
 			_logger.warn("No detail handler defined.");
 			return;
 		}
 		
 		String adapterId = getAdapterId(columnIndex);
 		
 		BindingContext context = getBindingContext(rowIndex);
 		PropertyAdapter adapter = context.getAdapter(adapterId);
 		
 		BindingContext oneToManyContext = adapter.getSubContext();
 		
 		Set set = (Set) context.getValue(adapterId);
 		
 		
 		getDetailHandler().handleDetails(adapterId, new ArrayList(set), oneToManyContext);
 	}
 	
 	/***
 	 * @return Returns the detailHandler.
 	 */
 	public DetailsHandler getDetailHandler() {
 		return _detailHandler;
 	}
 
 	/***
 	 * @param detailHandler The detailHandler to set.
 	 */
 	public void setDetailHandler(DetailsHandler detailHandler) {
 		_detailHandler = detailHandler;
 	}
 
 	/***
 	 * @return Returns the ctx.
 	 */
 	public BindingContext getContext() {
 		return _ctx;
 	}
 
 	/***
 	 * @param ctx The ctx to set.
 	 */
 	public void setContext(BindingContext ctx) {
 		_ctx = ctx;
 	}
 		
 }