/*
    * Copyright 2004 Jeff Johnston
    *
    * 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.
   */
  package org.extremecomponents.table.tag;
  
  import java.util.Iterator;
  import java.util.List;
  
  import javax.servlet.jsp.JspException;
  import javax.servlet.jsp.tagext.TagSupport;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.taglibs.standard.lang.support.ExpressionEvaluatorManager;
  import org.extremecomponents.table.TableAttributes;
  import org.extremecomponents.table.bean.Column;
  import org.extremecomponents.table.bean.Export;
  import org.extremecomponents.table.bean.Form;
  import org.extremecomponents.table.bean.Input;
  import org.extremecomponents.table.bean.Table;
  import org.extremecomponents.table.model.ExportHandler;
  import org.extremecomponents.table.model.TableModel;
  import org.extremecomponents.util.ExceptionUtils;
  
  
  /***
   * The container which holds all the main table information. Will also
   * hold global information if needed. The table tag is copied
   * into the Table and encapsulated in the Model.
   *
   * @author Jeff Johnston
   */
  public class TableTag extends TagSupport implements TableAttributes
  {
  	private static Log logger = LogFactory.getLog(TableTag.class);
  
  	/***
  	 * The Model represents the internal plumbing of the table
  	 */
  	private TableModel model;
  
  	/***
  	 * Will iterate over the columns the number of times specified by the maxRows attribute.
  	 */
  	private Iterator iterator;
  
  	private String id;
  	private String collection;
  	private String action;
  	private String scope;
  	private String styleClass;
  	private String headerClass;
  	private String border;
  	private String cellpadding;
  	private String cellspacing;
  	private String maxRows;
  	private String filter;
  	private String pagination;
  	private String imagePath;
  	private String sort;
  	private String title;
  	private String style;
  	private String width;
  
  	public String getId()
  	{
  		return id;
  	}
  
  	public void setId(String id)
  	{
  		this.id = id;
  	}
  
  	public String getCollection()
  	{
  		return collection;
  	}
  
  	public void setCollection(String collection)
  	{
  		this.collection = collection;
  	}
  
  	public String getAction()
  	{
  		return action;
 	}
 
 	public void setAction(String action)
 	{
 		this.action = action;
 	}
 
 	public String getScope()
 	{
 		return scope;
 	}
 
 	public void setScope(String scope)
 	{
 		this.scope = scope;
 	}
 
 	public String getStyleClass()
 	{
 		return styleClass;
 	}
 
 	public void setStyleClass(String styleClass)
 	{
 		this.styleClass = styleClass;
 	}
 
 	public String getHeaderClass()
 	{
 		return headerClass;
 	}
 
 	public void setHeaderClass(String headerClass)
 	{
 		this.headerClass = headerClass;
 	}
 
 	public String getBorder()
 	{
 		return border;
 	}
 
 	public void setBorder(String border)
 	{
 		this.border = border;
 	}
 
 	public String getCellpadding()
 	{
 		return cellpadding;
 	}
 
 	public void setCellpadding(String cellpadding)
 	{
 		this.cellpadding = cellpadding;
 	}
 
 	public String getCellspacing()
 	{
 		return cellspacing;
 	}
 
 	public void setCellspacing(String cellspacing)
 	{
 		this.cellspacing = cellspacing;
 	}
 
 	public String getMaxRows()
 	{
 		return maxRows;
 	}
 
 	public void setMaxRows(String maxRows)
 	{
 		this.maxRows = maxRows;
 	}
 
 	public String getFilter()
 	{
 		return filter;
 	}
 
 	public void setFilter(String filter)
 	{
 		this.filter = filter;
 	}
 
 	public String getPagination()
 	{
 		return pagination;
 	}
 
 	public void setPagination(String pagination)
 	{
 		this.pagination = pagination;
 	}
 
 	public String getImagePath()
 	{
 		return imagePath;
 	}
 
 	public void setImagePath(String imagePath)
 	{
 		this.imagePath = imagePath;
 	}
 
 	public String getSort()
 	{
 		return sort;
 	}
 
 	public void setSort(String sort)
 	{
 		this.sort = sort;
 	}
 
 	public String getTitle()
 	{
 		return title;
 	}
 
 	public void setTitle(String title)
 	{
 		this.title = title;
 	}
 
 	public String getStyle()
 	{
 		return style;
 	}
 
 	public void setStyle(String style)
 	{
 		this.style = style;
 	}
 
 	public String getWidth()
 	{
 		return width;
 	}
 
 	public void setWidth(String width)
 	{
 		this.width = width;
 	}
 
 	public void addParameter(String name, String value)
 	{
 		model.getRegistry().addParameter(name, value);
 	}
 
 	public void addForm(Form form)
 	{
 		model.getFormHandler().addForm(form);
 	}
 
 	public void addInput(Input input)
 	{
 		model.getFormHandler().addInput(input);
 	}
 
 	public void addProperty(String name, String value)
 	{
 		model.getProperties().setProperty(name, value);
 	}
 
 	public void addExport(Export export)
 	{
 		model.getExportHandler().addExport(export);
 	}
 
 	public boolean hasMetaData()
 	{
 		return model.getViewHandler().rowcount() > 0;
 	}
 
 	/***
 	 * Add the Column meta data to the Model
 	 */
 	public void addColumnMetaData(Column column)
 	{
 		model.getColumnMetaData().addColumn(column);
 	}
 
 	/***
 	 * Add a Column value to the Model
 	 */
 	public void addColumnValue(String property, Object value)
 	{
 		model.getViewHandler().addColumnValue(property, value);
 	}
 
 	/***
 	 * Find out how many rows have been added to the Model.
 	 */
 	public int getModelRowsSize()
 	{
 		return model.getViewHandler().rowcount();
 	}
 
 	public TableModel getModel()
 	{
 		return model;
 	}
 
 	/***
 	 * The start of the tag. First fire up the Model and
 	 * then make a copy of the table tag attributes to
 	 * send to the model.
 	 */
 	public int doStartTag()
 		throws JspException
 	{
 		model = new TableModel(pageContext); //just fire up the tablemodel
 
 		if (action != null)
 		{
 			action = (String) ExpressionEvaluatorManager.evaluate("action", action, String.class, this, pageContext);
 		}
 
 		if (imagePath != null)
 		{
 			imagePath = (String) ExpressionEvaluatorManager.evaluate("imagePath", imagePath, String.class, this, pageContext);
 		}
 
 		Table table = new Table(model); //make a copy
 		table.setId(id);
 		table.setCollection(collection);
 		table.setScope(scope);
 		table.setAction(action);
 		table.setStyleClass(styleClass);
 		table.setHeaderClass(headerClass);
 		table.setBorder(border);
 		table.setCellpadding(cellpadding);
 		table.setCellspacing(cellspacing);
 		table.setMaxRows(maxRows);
 		table.setFilter(filter);
 		table.setPagination(pagination);
 		table.setImagePath(imagePath);
 		table.setSort(sort);
 		table.setTitle(title);
 		table.setStyle(style);
 		table.setWidth(width);
 		model.setTable(table);
 
 		pageContext.setAttribute("ROWCOUNT", "0");
 
 		model.getRegistry().init(pageContext);
 
 		return EVAL_BODY_INCLUDE;
 	}
 
 	/***
 	 * Two things need to be accomplished here.
 	 * First, need to iterate once over the columns to load up all the attributes.
 	 * Second, need to iterate over the columns as many times as specified by the maxRows
 	 * attribute so the columns rows can be resolved. On each iteration over the columns
 	 * the current bean in the Collection is passed via the PageContext.
 	 */
 	public int doAfterBody()
 		throws JspException
 	{
 		try
 		{
 			if (model.getViewHandler().rowcount() == 0)
 			{
 				List rows = model.init();
 				iterator = rows.iterator();
 			}
 		}
 		catch (Exception e)
 		{
 			e.printStackTrace();
 			throw new JspException("TableTag.doAfterBody() Problem: " + ExceptionUtils.formatStackTrace(e));
 		}
 
 		if ((iterator != null) && iterator.hasNext())
 		{
 			model.getViewHandler().addRow();
 			pageContext.setAttribute(collection, iterator.next());
 			pageContext.setAttribute("ROWCOUNT", "" + getModelRowsSize());
 
 			return EVAL_BODY_AGAIN;
 		}
 		else
 		{
 			return SKIP_BODY;
 		}
 	}
 
 	/***
 	 * As a convenience use the EL expression langauge for the columns that need it.
 	 * Also execute the Model so that it can do all its processing and build the table.
 	 */
 	public int doEndTag()
 		throws JspException
 	{
 		try
 		{
 			if (!model.getColumnMetaData().hasMetatData())
 			{
 				List rows = model.init();
 				TagUtils.autoSetColumns(this, rows);
 			}
 
 			Object output = model.getViewHandler().getView().afterBody(model);
 
 			if (output instanceof String)
 			{
 				pageContext.getOut().println(output);
 			}
 
 			pageContext.getRequest().setAttribute(ExportHandler.EXPORT_DATA, output);
 		}
 		catch (Exception e)
 		{
 			throw new JspException("TableTag.doEndTag() Problem: " + ExceptionUtils.formatStackTrace(e));
 		}
 		
 		model.destroy();
 		cleanup();
 
 		return EVAL_PAGE;
 	}
 	
 	public void cleanup()
 	{
 		id = null;
 		collection = null;
 		scope = null;
 		action = null;
 		styleClass = null;
 		headerClass = null;
 		border = null;
 		cellpadding = null;
 		cellspacing = null;
 		maxRows = null;
 		filter = null;
 		pagination = null;
 		imagePath = null;
 		sort = null;
 		title = null;
 		style = null;
 		width = null;
 		model = null;
 		iterator = null;
 	}
 }