package org.jmage.filterchain;
   
   import org.apache.log4j.Logger;
   import org.apache.log4j.Priority;
   import org.jmage.ApplicationContext;
   import org.jmage.ImageRequest;
   import org.jmage.JmageException;
   import org.jmage.RequestHandler;
   import org.jmage.filter.FilterException;
  
  import javax.media.jai.PlanarImage;
  import java.net.URI;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Properties;
  
  /***
   * FilterChainManager controls all FilterChains and acts as a delegate to all it's attached
   * FilterChainFactories. Create FilterChains by specifying a URI filterchain:com.package.FilterChain
   * and let the delegates work out how to create it. FilterChains can be constructed out of
   * single filters, in which case the class name of that Filter should be provided.<p>
   * <p/>
   * A more sophisticated way to create chains is to serialize them into XML format. See
   * resources/xml for examples.
   */
  public class FilterChainManager implements RequestHandler {
      protected List filterChainFactories;
      protected ApplicationContext applicationContext = null;
  
      protected static Logger log = Logger.getLogger(FilterChainManager.class.getName());
      private static final String CHAIN = "chain";
      private static final String SCHEME_ERROR = "unable to create FilterChain, need to specify a uri, chain:package.FilterChain";
      private static final String FACTORIES_EMPTY_ERROR = "error, no FilterChainFactories configured";
      private static final String FACTORY_FAILED_WARNING = "unable to create filter chain with factory, skipping: ";
      private static final String FILTERCHAIN_ERROR = "unable to create filter chain, all factories failed to handle: ";
      private static final String FILTERCHAIN_SUCCESS = " created FilterChain for: ";
  
      /***
       * Default Constructor
       */
      protected FilterChainManager() {
          //do nothing
      }
  
      /***
       * Configure FilterChainManager
       *
       * @param context
       */
      public void configure(ApplicationContext context) {
          applicationContext = context;
      }
  
      /***
       * Creates a EncoderManager for an array of given FilterChainFactories
       *
       * @param filterChainFactories
       */
      public FilterChainManager(List filterChainFactories) {
          this.filterChainFactories = filterChainFactories;
      }
  
      /***
       * Filters an ImageRequest with an existing Filterchain
       *
       * @param request the request
       * @throws FilterChainException
       * @throws FilterException
       */
      public void handle(ImageRequest request) throws JmageException {
          request.setImage(this.filter(request));
      }
  
      /***
       * Creates a FilterChain object to use for a given unique chainUri, denoted by a URI
       * following the convention filterchain:com.package.FilterChain
       *
       * @param request the ImageRequest
       * @return the FilterChain object.
       * @throws FilterChainException if the filterchain cannot be constructed or handled properly
       */
      protected FilterChain[] create(ImageRequest request) throws FilterChainException, FilterException {
          FilterChain[] chains = null;
  
          //validation
          assert (filterChainFactories.size() > 0) : FACTORIES_EMPTY_ERROR;
  
          //see how many chains
          int chainSize = request.getFilterChainURI().length;
          chains = new FilterChain[chainSize];
  
          //iterate over them
          for (int i = 0; i < chainSize; i++) {
              Iterator it = filterChainFactories.iterator();
              //for each chain, iterate over factories and try to create
              if (!CHAIN.equals(request.getFilterChainURI()[i].getScheme())) {
                  throw new FilterChainException(SCHEME_ERROR);
              }
              String filterChain = request.getFilterChainURI()[i].getSchemeSpecificPart();
             do {
                 FilterChainFactory factory = (FilterChainFactory) it.next();
                 try {
                     //create a single filterchain and update it's properties
                     chains[i] = factory.createFrom(URI.create(this.lookupFilterChainName(filterChain)));
                     chains[i].updateConfigurableFilters(request.getFilterChainProperties() != null ? request.getFilterChainProperties() : new Properties());
                     chains[i].updateConfigurableFilters(
                             request.getFilterChainProperties().get(filterChain) != null ? (Properties) request.getFilterChainProperties().get(filterChain) : new Properties());
                 } catch (FilterChainException e) {
                     if (log.isDebugEnabled()) log.debug(FACTORY_FAILED_WARNING + factory.getClass().getName());
                 }
             } while (chains[i] == null && it.hasNext());
         }
 
         if (chains[0] != null) {
             if (log.isInfoEnabled()) log.info(FILTERCHAIN_SUCCESS + request.getFilterChainURI().toString());
         } else {
             if (log.isEnabledFor(Priority.ERROR)) log.error(FILTERCHAIN_ERROR + request.getFilterChainURI().toString());
             throw new FilterChainException(FILTERCHAIN_ERROR + request.getFilterChainURI().toString());
         }
         return chains;
     }
 
     /***
      * Filters an image through an existing FilterChain[].
      *
      * @param chains the FilterChain[]
      * @param image  the image
      * @return the filtered image
      * @throws FilterException
      */
     protected PlanarImage doFilter(FilterChain[] chains, PlanarImage image) throws FilterException {
         //iterate over all filterchains and pipe the image through them
         for (int i = 0; i < chains.length; i++) {
             image = chains[i].filter(image);
         }
         return image;
     }
 
     /***
      * Convenience method combining filter creation and image filtering. Use this if you need the FilterChain
      * only for one ImageRequest. Builds an unconfigured FilterChain and filters an image through it instantly.
      *
      * @param imageRequest the request
      * @return the filtered image
      * @throws FilterChainException if the filterchain can't be created or found
      * @throws FilterException      if the filterchain can't filter the image.
      */
     protected PlanarImage filter(ImageRequest imageRequest) throws FilterChainException, FilterException {
         FilterChain[] chains = this.create(imageRequest);
         return this.doFilter(chains, imageRequest.getImage());
     }
 
     protected String lookupFilterChainName(String filterChain) {
         String filterChainName = applicationContext.getProperty(filterChain);
         return filterChainName != null ? filterChainName : filterChain;
     }
 
     public String toString() {
         return "[" + this.getClass().getName() + "#" + this.hashCode() + "]";
     }
 }