/*
    * 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.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.extremecomponents.table.bean.Column;
  import org.extremecomponents.table.cell.Cell;
  import org.extremecomponents.table.cell.FilterCell;
  
  
  
  /***
   * Deal with the filtering.
   *
   * @author Jeff Johnston
   */
  public class FilterHandler
  {
  	private static Log logger = LogFactory.getLog(FilterHandler.class);
  	public final static String DO_CLEAR = "DoClear";
  	public final static String DO_SEARCH = "DoSearch";
  	public final static String BUTTON = "button";
  	public final static String SEARCH_IMAGE = "search";
  	public final static String CLEAR_IMAGE = "clear";
  	private String button;
  	
  	private TableModel model;
  	
  	public FilterHandler(TableModel model)
  	{
  		this.model = model;
  	}
  
  	public boolean doFilter()
  	{
  		Map parameters = model.getRegistry().getParameters(ParameterRegistry.FILTER) ;
  		return parameters.size() > 0;
  	}
  	
  	public boolean doClear()
  	{
  		if (!StringUtils.isEmpty(getButton()) && getButton().equals(DO_CLEAR)) return true;
  		return false;
  	}
  	
  	public String getButton()
  	{
  		if (button == null) button = model.getRegistry().getParameter(ParameterRegistry.FILTER + BUTTON);
  		return button;
  	}
  	
  	/***
  	 * Filter out the table using the Predicate pattern.
  	 */
  	public List filterRows(TableModel model, List rows)
  	{
  		//we pressed the clear button
  		if (doClear())
  		{
  			model.getRegistry().clearParameters(ParameterRegistry.FILTER);
  			return rows;
  		}
  
  		if (!doFilter())
  		{
  			return rows;
  		}
  		else
  		{
  			List results = new ArrayList();
  			FilterPredicate filterPredicate = new FilterPredicate(model);
  			CollectionUtils.select(rows, filterPredicate, results);
  
  			return results;
  		}
  	}
 	
 	/***
 	 * Get the Filter
 	 */
 	public List getFilter(TableModel model)
 	{
 		List filter = new ArrayList();
 
 		if (!model.getTable().doFilter()) //if the filter is not turned on
 		{
 			return filter;
 		}
 
 		Map droplists = getFilterDropLists(model);
 
 		Iterator columns = model.getColumnMetaData().getColumns();
 
 		for (Iterator iter = columns; iter.hasNext();)
 		{
 			Column column = (Column) iter.next();
 			String value = model.getRegistry().getParameter(ParameterRegistry.FILTER + column.getProperty());
 
 			if ((!StringUtils.isEmpty(button) && button.equals(DO_CLEAR)) || StringUtils.isEmpty(value)) //pressed a button and its to clear value
 			{
 				value = "";
 			}
 
 			column.setValue(value);
 
 			Object obj = droplists.get(column.getProperty());
 
 			if (obj != null)
 			{
 				column.setFilterDroplist((List) obj);
 			}
 			
 			Cell cell = model.getCachedCell(FilterCell.class);
 			cell.init(model, column, null);
 			filter.add(cell.html());
 			cell.destroy();
 		}
 
 		return filter;
 	}
 
 	/***
 	 * Make up the droplists that will be used for the filter. The droplists will be a distinct
 	 * set of the data in a column.
 	 * This could be very painful if the list is long so be careful about using for larger sets.
 	 * Trying to make this faster by running through bean only once.
 	 */
 	public Map getFilterDropLists(TableModel model)
 	{
 		Map droplists = new HashMap();
 
 		Iterator columns = model.getColumnMetaData().getColumns(); //make up the distinct list of droplists
 
 		while (columns.hasNext())
 		{
 			Column column = (Column) columns.next();
 
 			if (column.getFilter().equals("droplist"))
 			{
 				List values = new ArrayList();
 				droplists.put(column.getProperty(), values);
 			}
 		}
 
 		if (droplists.isEmpty()) //do not need any droplists, so stop right here
 		{
 			return droplists;
 		}
 
 		List list = model.getTableCollection(); //iterate though the beans
 
 		for (Iterator iter = list.iterator(); iter.hasNext();)
 		{
 			Object bean = (Object) iter.next();
 
 			Iterator keys = droplists.keySet().iterator();
 
 			while (keys.hasNext())
 			{
 				String property = (String) keys.next();
 				List values = (List) droplists.get(property);
 
 				try
 				{
 					Object obj = PropertyUtils.getProperty(bean, property);
 
 					if ((obj != null) && !values.contains(obj))
 					{
 						values.add(obj);
 					}
 				}
 				catch (Exception e)
 				{
 					logger.debug("FilterHandler.getFilterDropLists()", e);
 				}
 			}
 		}
 
 		return droplists;
 	}
 	
 	public void destroy()
 	{
 		button = null;
 	}	
 }