package org.jmage.filterchain;
   
   import org.apache.log4j.Logger;
   import org.jmage.filter.ConfigurableImageFilter;
   import org.jmage.filter.FilterException;
   import org.jmage.filter.ImageFilter;
   import org.jmage.filter.TwinResourceImageFilter;
   
   import javax.media.jai.PlanarImage;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.UndeclaredThrowableException;
  import java.util.*;
  
  /***
   * A FilterChain processes an image by passing it through a preconfigured, ordered set of filters.
   */
  public class FilterChain {
      protected final String name;
      protected List filters;
  
      protected static Logger log = Logger.getLogger(FilterChain.class.getName());
      private static final String FILTER_REMOVE_ERROR = "unable to remove filter from FilterChain, cannot find this filter.";
      private static final String UNSUPPORTED_PROPERTY = "unable to configure filter with unsupported property: ";
      private static final String UNSUPPORTED_VALUE = "unable to configure filter with unsupported value: ";
      private static final String PROPERTY_CONFIG = "configured filter with property: ";
  
      /***
       * Use this to construct an empty FilterChain. FilterChains need a unique name.
       */
      public FilterChain(String name) {
          filters = new ArrayList();
          this.name = name;
      }
  
      /***
       * Gets the FilterChain's unique name.
       *
       * @return the unique name
       */
      public String getName() {
          return this.name;
      }
  
      /***
       * Add a filter to the FilterChain's end.
       *
       * @param filter           the filter
       * @param filterProperties the filter's properties
       * @throws org.jmage.filter.FilterException
       *          if the filter can't be properly initialized
       */
      public void addFilter(ConfigurableImageFilter filter, Properties filterProperties) throws FilterException {
          filter.initialize(filterProperties);
          this.filters.add(filter);
      }
  
      /***
       * Add a filter to the FilterChain at the given position.
       *
       * @param filter           the filter
       * @param filterProperties the filter's properties
       * @param position         the position in the filter filterchain
       * @throws FilterException           if the filter can't be properly initialized
       * @throws IndexOutOfBoundsException if the FilterChain can't add the filter at the position.
       */
      public void addFilter(ConfigurableImageFilter filter, Properties filterProperties, int position) throws FilterException, IndexOutOfBoundsException {
          filter.initialize(filterProperties);
          this.filters.add(position, filter);
      }
  
      /***
       * Add a filter to the FilterChain at the given position.
       *
       * @param filter   the filter
       * @param position the position in the filter filterchain
       * @throws IndexOutOfBoundsException if the FilterChain can't add the filter at the position.
       */
      public void addFilter(ImageFilter filter, int position) throws IndexOutOfBoundsException {
          this.filters.add(position, filter);
      }
  
      /***
       * Add a filter to the FilterChain at the end.
       *
       * @param filter the filter
       */
      public void addFilter(ImageFilter filter) {
          this.filters.add(filter);
      }
  
      /***
       * Removes a filter from a FilterChain.
       *
       * @param filter the filter
       */
      public void removeFilter(ImageFilter filter) throws FilterException {
          if (this.filters.contains(filter)) {
              this.filters.remove(filter);
         } else {
             throw new FilterException(FILTER_REMOVE_ERROR);
         }
     }
 
     /***
      * Iterates through all configurable image filters in the filter filterchain and applies
      * additional filterProperties to them. Filters must declare public constants with the
      * property name to be able to for this to work.
      *
      * @param filterProperties
      * @throws FilterException
      */
     public void updateConfigurableFilters(Properties filterProperties) throws FilterException {
         //Filters should decide whether they need params
         if (filterProperties == null) filterProperties = new Properties();
 
         Iterator it = this.filters.iterator();
 
         //iterate through filters
         while (it.hasNext()) {
             ImageFilter filter = (ImageFilter) it.next();
             if (filter instanceof ConfigurableImageFilter) {
                 //cast to configurable
                 ConfigurableImageFilter configurableImageFilter = (ConfigurableImageFilter) filter;
                 Class filterClass = configurableImageFilter.getClass();
 
                 Properties filterLocal = configurableImageFilter.getFilterProperties();
                 //for previously uninitialized filters
                 if (filterLocal == null) filterLocal = new Properties();
                 boolean hasChanged = false;
 
                 //iterate through properties
                 Enumeration propertyNames = filterProperties.propertyNames();
                 while (propertyNames.hasMoreElements()) {
                     String propertyName = (String) propertyNames.nextElement();
 
                     //inspect filter to verify if property is supported.
                     try {
                         Field propertyConstant = filterClass.getField(propertyName);
                         filterLocal.setProperty(propertyName, filterProperties.getProperty(propertyName));
                         if (log.isDebugEnabled()) log.debug(PROPERTY_CONFIG + filter + " " + propertyName);
                         hasChanged = true;
                     } catch (NoSuchFieldException e) {
                         if (log.isDebugEnabled()) log.debug(UNSUPPORTED_PROPERTY + filter + " " + propertyName);
                     } catch (UndeclaredThrowableException e) {
                         if (log.isDebugEnabled()) log.debug(UNSUPPORTED_VALUE + filter + " " + propertyName);
                     } catch (Exception e) {
                         if (log.isDebugEnabled()) log.debug(UNSUPPORTED_PROPERTY + filter + " " + propertyName);
                     }
                 }
 
                 //update if property changes occured for this filter
                 if (hasChanged || filter instanceof TwinResourceImageFilter) {
                     configurableImageFilter.initialize(filterLocal);
                 }
             }
         }
     }
 
     /***
      * Filters the image by passing it through all filters in the filterchain.
      *
      * @param image the image
      * @return the filtered image
      * @throws FilterException
      */
     public PlanarImage filter(PlanarImage image) throws FilterException {
         for (Iterator it = filters.iterator(); it.hasNext();) {
             ImageFilter filter = (ImageFilter) it.next();
             image = filter.filter(image);
         }
         if (log.isInfoEnabled()) log.info(" filtered image in filterchain: " + this.getName());
         return image;
     }
 
     /***
      * Override equals to check for unique name
      *
      * @param o the FilterChain
      * @return true | false
      */
     public boolean equals(Object o) {
         if (this == o) return true;
         if (!(o instanceof FilterChain)) return false;
 
         final FilterChain filterChain = (FilterChain) o;
 
         if (!name.equals(filterChain.name)) return false;
 
         return true;
     }
 
     /***
      * Override hashCode to generate for "name" uniqueness
      *
      * @return the hashcode
      */
     public int hashCode() {
         return name.hashCode();
     }
 }