/***
    * 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 net.sf.echobinding.binding.BindingContext;
  import net.sf.echobinding.persistence.DefaultTablePersistenceManager;
  import net.sf.echobinding.persistence.PersistenceManager;
  import net.sf.echobinding.util.Images;
  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;
  
  /***
   * A editable bound table. 
   * 
   */
  public abstract class ListEditor<T> extends BoundTable<T> implements EditableTable<T>, EditableTableRendererSupport, ActionListener {
  
  	private PersistenceManager<T> _persistenceManager;
  	
  	/***
  	 * @param listAdapterId
  	 * @param ctx
  	 */
  	public ListEditor(String listAdapterId, BindingContext ctx) {
  		super( listAdapterId, ctx );
  		
  	}
  
  	/* (non-Javadoc)
  	 * @see echobinding.table.BoundTable#createTableModel()
  	 */
  	@Override
  	protected TableModel createTableModel() {
  		return new EditableTableModel(createTableHeaderData(), createTableData());
  	}
  
  
  	/* (non-Javadoc)
  	 * @see echobinding.table.BoundTable#getTableCellRenderer()
  	 */
  	@Override
  	protected TableCellRenderer getTableCellRenderer() {
  		return new EditableTableCellRenderer();
  	}
  
  	
  	@Override
  	protected BoundTableHeaderRenderer getTableHeaderRenderer() {
  		return new EditableTableHeaderRenderer();
  	}
  
  	@SuppressWarnings("serial")
  	public Component createHeaderButtonPanel() {
  		Row buttonRow = new Row();
  		
  		Button addButton = new Button(Images.PAGE_ADD);
  		addButton.addActionListener(new ActionListener() {
  		
  			public void actionPerformed(ActionEvent arg0) {
  				addRow();
  			}
  		
  		});
  		buttonRow.add(addButton);
  		
  		return buttonRow;
  	}
  
  
  	@SuppressWarnings("serial")
  	public Component createButtonPanel(int rowIndex) {
 		
 		Row buttonRow = new Row();
 		
 		final BindingContext context = super.getBindingContext(rowIndex);
 		
 		Button editButton = new Button(Images.PAGE_EDIT);
 		editButton.addActionListener(new ActionListener() {
 			public void actionPerformed(ActionEvent arg0) {
 				editRow( context );
 			}
 		});
 		
 		Button copyButton = new Button(Images.PAGE_COPY);
 		copyButton.addActionListener(new ActionListener() {
 		
 			public void actionPerformed(ActionEvent arg0) {
 				copyRow( context );
 			}
 		
 		});
 		
 		Button deleteButton = new Button(Images.PAGE_DELETE);
 		deleteButton.addActionListener(new ActionListener() {
 		
 			public void actionPerformed(ActionEvent arg0) {
 				deleteRow( context );
 			}
 		
 		} );
 		
 		buttonRow.add(editButton);
 		buttonRow.add(copyButton);
 		buttonRow.add(deleteButton);
 
 		buttonRow.setCellSpacing(new Extent(3));
 		
 		return buttonRow;
 	}
 
 
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#editRow(BindingContext context)
 	 */
 	public void editRow(BindingContext context) {
 		showForm(context);
 	}
 	
 	/***
 	 * Displays the form for editing a selected row.
 	 * 
 	 * @param context
 	 */
 	public abstract void showForm(BindingContext context);
 		
 	@SuppressWarnings("unchecked")
 	public boolean isPersistent(int row) {
 		
 		T bean = (T) getBindingContext(row).getModel();
 		
 		return getPersistenceManager().isPersistent(bean);
 	}
 
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#addRow()
 	 */
 	public void addRow() {
 		T newRowObject = createNewRowObject();
 		getList().add(newRowObject);
 		
 		initialize();
 		
 		int index = getList().indexOf(newRowObject);
 		editRow(getBindingContext(index));
 	}
 
 	/***
 	 * @return
 	 */
 	@SuppressWarnings("unchecked")
 	private T createNewRowObject() {
 		return getPersistenceManager().createNewObject();
 	}
 	
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#deleteRow()
 	 */
 	public void deleteRow(BindingContext context) {
 		T currentRowObject = (T) context.getModel();
 		getList().remove(currentRowObject);
 		
 		deleteRowObject(currentRowObject);
 		
 		initialize();
 	}
 
 	/***
 	 * @param object
 	 */
 	private void deleteRowObject(T object) {
 		if( getPersistenceManager().isPersistent(object))
 			getPersistenceManager().deleteObject(object);
 	}
 
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#copyRow(BindingContext context)
 	 */
 	public void copyRow(BindingContext context) {
 		
 		T currentRowObject = (T) context.getModel();
 		T copy = copyRowObject(currentRowObject);
 		
 		int currentIndex = getList().indexOf(currentRowObject);
 		
 		int newIndex = currentIndex+1;
 		getList().add(newIndex, copy);
 		
 		initialize();
 		
 		newIndex = getList().indexOf(copy);
 		editRow(getBindingContext(newIndex));
 	}
 
 	/***
 	 * @param currentRowObject
 	 * @return
 	 */
 	private T copyRowObject(T object) {
 		return getPersistenceManager().copyObject(object);
 	}
 
 	
 	
 	public void saveRow(BindingContext context) {
 		
 		context.synchronize();
 		
 		T bean = (T) context.getModel();
 		
 		getPersistenceManager().saveObject(bean);
 		
 		initialize();
 	}
 
 	/***
 	 * Returns the persistence manager. If no persistence manager is set, the
 	 * default persistence manager will be used.
 	 * 
 	 * @return Returns the persistence manager.
 	 */
 	public PersistenceManager<T> getPersistenceManager() {
 		if(_persistenceManager == null)
 			_persistenceManager = new DefaultTablePersistenceManager<T>(getList().get(0), this);
 		return _persistenceManager;
 	}
 
 	/***
 	 * Sets the persistence manager.
 	 * 
 	 * @param persistenceManager The persistence manager to set.
 	 */
 	public void setPersistenceManager(PersistenceManager<T> persistenceManager) {
 		_persistenceManager = persistenceManager;
 	}
 
 }