/***
    * 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.datacontrol;
  
  import java.util.List;
  
  import net.sf.echobinding.binding.BindingContext;
  import net.sf.echobinding.model.PresentationModel;
  import net.sf.echobinding.persistence.DefaultPersistenceManager;
  import net.sf.echobinding.persistence.PersistenceManager;
  import net.sf.echobinding.table.EditableTable;
  import nextapp.echo2.app.Column;
  import nextapp.echo2.app.Component;
  import nextapp.echo2.app.event.ActionListener;
  
  /***
   * A editable table that allows inline editing. A FormColumnTable
   * organizes the table data within one <code>Column</code> component. Each
   * item in the list will be added to the column as a <code>Row</code>. This
   * row has to be defined by overwriting the abstract method
   * <code>ceateRow(BindingContext ctx, int rowNummer)</code>.
   * <p>
   * If you supply a PersistenceMangager, you can add new rows to the table by
   * calling the <code>addRow()</code> method. Again, new rows will be added
   * to the table by the <code>ceateRow(BindingContext ctx, int rowNummer)</code>
   * method.
   * <p>
   * 
   */
  public abstract class FormColumnTable<T> extends Column implements
  		EditableTable<T> {
  
  	protected List<T> _list;
  
  	protected BindingContext _ctx;
  
  	protected ActionListener _actionListener;
  
  	private PersistenceManager<T> _persistenceManager;
  	
  	
  	
  	
  	/***
  	 * @param list
  	 * @param ctx
  	 */
  	public FormColumnTable(List<T> list, BindingContext ctx) {
  		super();
  		
  		_list = list;
  		_ctx = ctx;
  	}
  
  
  	/* (non-Javadoc)
  	 * @see nextapp.echo2.app.Component#init()
  	 */
  	@Override
  	public void init() {
  		super.init();
  		initialize();
  	}
  
  	/***
  	 * 
  	 */
  	protected void initialize() {
  		removeAll();
  		int index = 0;
  		for (T bean : getList()) {
  			addRowObject( index++, bean );
  		}
 	}
 
 	/***
 	 * 
 	 * @param index
 	 * @param bean
 	 * @return
 	 */
 	private int addRowObject(int index, T bean) {
 		BindingContext childContext = getContext().createChild().setModel(bean);
 		add(createRow(childContext,	index++));
 		
 		initPresentationModel( childContext.getPresentationModel() );
 		
 		return index;
 	}
 
 	/***
 	 * @param presentationModel
 	 */
 	private void initPresentationModel(PresentationModel presentationModel) {
 		if(presentationModel!=null)
 			presentationModel.init();
 	}
 
 	/***
 	 * Defines how a table row should look like. 
 	 * 
 	 * @param ctx
 	 * @param rowNumber
 	 * @return
 	 */
 	public abstract Component createRow(BindingContext ctx, int rowNumber);
 
 
 	public void addRow() {
 		T newObject = createRowObject();
 		addToTable( newObject );
 	}
 
 	/***
 	 * @param newObject
 	 */
 	private void addToTable(T newObject) {
 		getList().add(newObject);
 		int index = getList().indexOf(newObject);
 		addRowObject(index, newObject);
 	}
 
 	/***
 	 * @return
 	 */
 	private T createRowObject() {
 		return getPersistenceManager().createNewObject();
 	}
 
 	public void deleteRow(BindingContext context) {
 		T bean = (T) context.getModel();
 		int index = getList().indexOf(bean);
 		getList().remove(bean);
 		
 		if(getPersistenceManager().isPersistent(bean))
 			getPersistenceManager().deleteObject(bean);
 		
 		remove(index);
 	}
 	
 	
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#copyRow(echobinding.binding.BindingContext)
 	 */
 	public void copyRow(BindingContext context) {
 		T bean = (T) context.getModel();
 		T copy = getPersistenceManager().copyObject(bean);
 		addToTable(copy);		
 	}
 
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#saveRow(echobinding.binding.BindingContext)
 	 */
 	public void saveRow(BindingContext context) {
 		T bean = (T) context.getModel();
 		getPersistenceManager().saveObject(bean);
 	}
 	
 	/* (non-Javadoc)
 	 * @see echobinding.table.EditableTable#editRow(echobinding.binding.BindingContext)
 	 */
 	public void editRow(BindingContext context) {
 	}
 
 	protected ActionListener getActionListener() {
 		return _actionListener;
 	}
 
 	protected void setActionListener(ActionListener actionListener) {
 		_actionListener = actionListener;
 	}
 	
 	@SuppressWarnings("unchecked")
 	public boolean isPersistent(int row) {
 		T bean = getList().get(row);
 		return getPersistenceManager().isPersistent(bean);
 	}
 	
 	/***
 	 * Saves each row object.
 	 * 
 	 * @see PersistenceManager
 	 *
 	 */
 	public void save() {
 		for(T obj : getList()) {
 			getPersistenceManager().saveObject(obj);
 		}
 	}
 	
 	/***
 	 * 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 DefaultPersistenceManager<T>(getList().get(0));
 		return _persistenceManager;
 	}
 
 	/***
 	 * Sets the persistence manager.
 	 * 
 	 * @param persistenceManager The persistence manager to set.
 	 */
 	public void setPersistenceManager(PersistenceManager<T> persistenceManager) {
 		_persistenceManager = persistenceManager;
 	}
 
 	/***
 	 * Returns the binding context.
 	 * 
 	 * @return the binding context
 	 */
 	public BindingContext getContext() {
 		return _ctx;
 	}
 	
 	/***
 	 * Sets the binding context.
 	 * 
 	 * @param ctx The context to set.
 	 */
 	public void setContext(BindingContext ctx) {
 		_ctx = ctx;
 	}
 	
 	/***
 	 * Returns the list.
 	 * 
 	 * @return 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;
 	}
 }