/*
    * 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.model;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.jsp.PageContext;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.extremecomponents.table.bean.Table;
  import org.extremecomponents.table.bean.TableSection;
  import org.extremecomponents.table.cell.Cell;
  import org.extremecomponents.util.ExtremeUtils;
  
  
  
  /***
   * Build up a Model that represents the table. This is the main reference point to all objects
   * that are needed to build the table display up.
   *
   * @author Jeff Johnston
   */
  public class TableModel
  {
  	private static Log logger = LogFactory.getLog(TableModel.class);
  	private PageContext pageContext;
  
  	//stuff that the model should know about
  	private Table table;
  	private Object tableCollection;
  	private TableSection tableSection;
  	private TableProperties properties = new TableProperties();
  	private ColumnMetaData columnMetaData = new ColumnMetaData(this);
  	private SortHandler sortHandler = new SortHandler(this);
  	private FilterHandler filterHandler = new FilterHandler(this);
  	private PageHandler pageHandler = new PageHandler(this);
  	private ExportHandler exportHandler = new ExportHandler(this);
  	private FormHandler formHandler = new FormHandler(this);
  	private ViewHandler viewHandler = new ViewHandler(this);
  	private ParameterRegistry registry = new ParameterRegistry(this);
  	
  	private Map cellCache = new HashMap(); //a simple cell cache
  
  	public TableModel(PageContext pageContext)
  	{
  		this.pageContext = pageContext;
  	}
  
  	public PageContext getPageContext()
  	{
  		return pageContext;
  	}
  	
  	public void setTable(Table table)
  	{
  		this.table = table;
  	}
  
  	public Table getTable()
  	{
  		return table;
  	}
  	
  	public String getTableKey()
  	{
  		return getTable().getId() + "_";
  	}
  	
  	public SortHandler getSortHandler()
  	{
  		return sortHandler;
  	}
  
  	public FilterHandler getFilterHandler()
  	{
  		return filterHandler;
  	}
  
  	public PageHandler getPageHandler()
  	{
  		return pageHandler;
  	}
 
 	public FormHandler getFormHandler()
 	{
 		return formHandler;
 	}
 
 	public ViewHandler getViewHandler()
 	{
 		return viewHandler;
 	}
 
 	public ExportHandler getExportHandler()
 	{
 		return exportHandler;
 	}
 
 	public TableSection getTableSection()
 	{
 		return tableSection;
 	}
 
 	public ColumnMetaData getColumnMetaData()
 	{
 		return columnMetaData;
 	}
 
 	public TableProperties getProperties()
 	{
 		return properties;
 	}
 	
 	public ParameterRegistry getRegistry() 
 	{
 		return registry;
 	}
 
 	public List getTableCollection()
 	{
 		return (List) tableCollection;
 	}
 
 	public void setTableCollection(Object tableCollection)
 		throws Exception
 	{
 		if (tableCollection instanceof List)
 		{
 			this.tableCollection = tableCollection;
 		}
 		else
 		{
 			throw new Exception("The eXtremeTable could not find the List of Beans (or Map) identified by the collection and scope attributes.");
 		}
 	}
 	
 	/***
 	 * A simple implementation of a cache 
 	 * so that do not have to keep loading up the same eXtremeTable
 	 */
 	public Cell getCachedCell(Class classDefinition)
 	{
 		Cell cell = (Cell)cellCache.get(classDefinition);
 		
 		if (cell == null)
 		{
 			try
 			{
 				//Class classDefinition = Class.forName(className);
 				Object object = classDefinition.newInstance();
 				cell = (Cell) object;
 				cellCache.put(classDefinition, cell);
 			}
 			catch (Exception e)
 			{
 				logger.error("Model.build()", e);
 			}
 		}
 		
 		return cell;
 	}
 
 	/***
 	 * Do all the filtering and sorting and return the rows of the table
 	 * that need to be displayed.
 	 */
 	public List init()
 		throws Exception
 	{
 		setTableCollection(ExtremeUtils.retrieveFromScope(pageContext, getTable().getCollection(), getTable().getScope()));
 
 		List filteredSortedRows = new ArrayList();
 
 		filteredSortedRows.addAll(getTableCollection()); //Make a copy for thread safety
 		
 		filteredSortedRows = filterHandler.filterRows(this, filteredSortedRows);
 
 		sortHandler.sort(filteredSortedRows);
 
 		tableSection = TableModelUtils.getTableSection(this, filteredSortedRows.size());
 		
 		viewHandler.setView();
 
 		return TableModelUtils.splitIntoTableSectionRows(this, filteredSortedRows, tableSection);
 	}
 	
 	public void destroy()
 	{
 		properties.destroy();
 		columnMetaData.destroy();
 		filterHandler.destroy();
 		exportHandler.destroy();
 		formHandler.destroy();
 		registry.destroy();
 		cellCache.clear();
 		table = null;
 		tableCollection = null;
 		tableSection = null;
 		properties = null;
 		columnMetaData = null;
 		sortHandler = null;
 		filterHandler = null;
 		pageHandler = null;
 		exportHandler = null;
 		formHandler = null;
 		viewHandler = null;
 		registry = null;
 		cellCache = null;
 	}
 }