/**
    * Copyright 2005-2012 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.kuali.rice.core.api.criteria;
  
  import org.kuali.rice.core.api.mo.ModelBuilder;
  
  import java.io.Serializable;
  
  /**
   * This class works withe the lookup framework to customize a query.  It currently can do the following things:
   *
   * <ul>
   *  <li>transform/remove predicates</li>
   *  <li>transform/remove query results</li>
   * </ul>
   *
   * <p>
   * The predicate transform will applied to the predicates in the incoming query yielding a
   * a predicate.  If the predicate does not need to be transformed then the function can return the
   * incoming argument.  If the predicate should be removed the transform should return null.
   * This is a way to remove or change a predicate before the query is executed.
   * This is a good way to add new predicates to a query or to limit the result of the query before
   * it is executed. Transforms also allow a predicate referencing a property path that does not exist
   * on database mapped object to be changed to something that is valid.
   * </p>
   *
   * <p>
   * The result transform will be applied to the results of the query after the query is executed.
   * If the result does not need to be transformed then the function can return the
   * incoming argument. This is a way to remove or change a result after the query is executed.
   * </p>
   *
   * <p>transformers should not have to deal with null items</p>
   */
  public class LookupCustomizer<T> {
  
      //FIXME: add wilcards to make predicate transform more flexible ie. EqualsPredicate to AndPredicate
      private final Transform<Predicate,Predicate> predicateTransform;
      private final Transform<T, T> resultTransform;
  
      private LookupCustomizer(Builder<T> builder) {
          this.predicateTransform = builder.getPredicateTransform() != null ? builder.getPredicateTransform() : IndentityTransform.<Predicate, Predicate>getInstance();
          this.resultTransform = builder.getResultTransform() != null ? builder.getResultTransform() : IndentityTransform.<T, T>getInstance();
      }
  
      public Transform<Predicate, Predicate> getPredicateTransform() {
          return predicateTransform;
      }
  
      public Transform<T, T> getResultTransform() {
          return resultTransform;
      }
  
      public static final class Builder<T> implements ModelBuilder, Serializable {
  
          private Transform<Predicate, Predicate> predicateTransform;
          private Transform<T, T> resultTransform;
  
          private Builder() {
  
          }
  
          public static <T> Builder<T> create() {
              return new Builder<T>();
          }
  
          public Transform<Predicate, Predicate> getPredicateTransform() {
              return predicateTransform;
          }
  
          public void setPredicateTransform(final Transform<Predicate, Predicate> predicateTransform) {
              this.predicateTransform = predicateTransform;
          }
  
          public Transform<T, T> getResultTransform() {
              return resultTransform;
          }
  
          public void setResultTransform(final Transform<T, T> resultTransform) {
              this.resultTransform = resultTransform;
          }
  
          @Override
          public LookupCustomizer<T> build() {
              return new LookupCustomizer<T>(this);
          }
     }
     public interface Transform<P, R> {
         R apply(P input);
     }
 
     /**
      * f: x -> x.  This function just returns the passed in parameter.
      *
      * @param <I> the type the function acts on.
      */
     private static final class IndentityTransform<I> implements Transform<I, I> {
 
         @SuppressWarnings("unchecked")
         private static final Transform INSTANCE = new IndentityTransform();
 
         @SuppressWarnings("unchecked")
         public static <P, R> Transform<P, R> getInstance() {
             return INSTANCE;
         }
 
         @Override
         public I apply(final I input) {
             return input;
         }
     }
 }