/*
    * Grapht, an open source dependency injector.
    * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
    * Copyright 2010-2014 Regents of the University of Minnesota
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as
    * published by the Free Software Foundation; either version 2.1 of the
    * License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
   * details.
   *
   * You should have received a copy of the GNU General Public License along with
   * this program; if not, write to the Free Software Foundation, Inc., 51
   * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
   */
  package org.grouplens.grapht.solver;
  
  import com.google.common.base.Preconditions;
  import org.grouplens.grapht.CachePolicy;
  import org.grouplens.grapht.reflect.QualifierMatcher;
  import org.grouplens.grapht.reflect.Qualifiers;
  import org.grouplens.grapht.reflect.Satisfaction;
  
  import java.util.EnumSet;
  
  /**
   * Builder for bind rules.
   *
   * @since 0.7
   * @author <a href="http://www.grouplens.org">GroupLens Research</a>
   */
  public class BindRuleBuilder {
      private Class<?> dependencyType;
      private QualifierMatcher qualifierMatcher = Qualifiers.matchAny();
  
      private Satisfaction satisfaction;
      private Class<?> implementation;
  
      private CachePolicy cachePolicy = CachePolicy.NO_PREFERENCE;
      private EnumSet<BindingFlag> flags = BindingFlag.emptySet();
  
      public static BindRuleBuilder create() {
          return new BindRuleBuilder();
      }
  
      /**
       * Get the dependency type to match.
       * @return The dependency type to match.
       */
      public Class<?> getDependencyType() {
          return dependencyType;
      }
  
      /**
       * Set the dependency type to match.
       * @param type The dependency type to match.
       */
      public BindRuleBuilder setDependencyType(Class<?> type) {
          dependencyType = type;
          return this;
      }
  
      /**
       * Get the configured qualifer matcher.  The initial qualifier matcher is {@link org.grouplens.grapht.reflect.Qualifiers#matchAny()}.
       * @return The qualifier matcher.
       */
      public QualifierMatcher getQualifierMatcher() {
          return qualifierMatcher;
      }
  
      /**
       * Set the qualifier matcher.
       * @param qm The qualifier matcher.
       */
      public BindRuleBuilder setQualifierMatcher(QualifierMatcher qm) {
          qualifierMatcher = qm;
          return this;
      }
  
      /**
       * Get the target satisfaction.
       * @return The configured satisfaction, or {@code null} if none is configured.
       */
      public Satisfaction getSatisfaction() {
          return satisfaction;
      }
  
      /**
       * Set the satisfaction to bind to.  This will unset the implementation class and result in
       * a satisfaction binding.
       *
       * @param sat The satisfaction.
       */
      public BindRuleBuilder setSatisfaction(Satisfaction sat) {
          satisfaction = sat;
         return this;
     }
 
     /**
      * Get the target implementation.
      * @return The target implementation, or {@code null} if none is configured.
      */
     public Class<?> getImplementation() {
         return implementation;
     }
 
     /**
      * Set the target implementation. This will unset the satisfaction and result in an implementation
      * class binding.
      *
      * @param type The implementation class.
      */
     public BindRuleBuilder setImplementation(Class<?> type) {
         implementation = type;
         return this;
     }
 
     /**
      * Query whether the binding will be terminal.
      * @return {@code true} if the binding will be terminal.
      */
     public boolean isTerminal() {
         return flags.contains(BindingFlag.TERMINAL);
     }
 
     /**
      * Set whether the binding will be terminal.
      *
      * @param term {@code true} to create a terminal binding.
      * @see BindingFlag#TERMINAL
      */
     public BindRuleBuilder setTerminal(boolean term) {
         if (term) {
             flags.add(BindingFlag.TERMINAL);
         } else {
             flags.remove(BindingFlag.TERMINAL);
         }
         return this;
     }
 
     /**
      * Set the flags on this bind rule.
      * @param fs The flags.
      * @return The builder (for chaining).
      */
     public BindRuleBuilder setFlags(EnumSet<BindingFlag> fs) {
         flags = fs.clone();
         return this;
     }
 
     /**
      * Add a flag to the constructed bind rule.
      * @param flag The flag to add.
      * @return The builder (for chaining).
      */
     public BindRuleBuilder addFlag(BindingFlag flag) {
         flags.add(flag);
         return this;
     }
 
     /**
      * Get the cache policy.
      * @return The cache policy.
      */
     public CachePolicy getCachePolicy() {
         return cachePolicy;
     }
 
     /**
      * Set the cache policy.
      * @param policy The cache policy.
      */
     public BindRuleBuilder setCachePolicy(CachePolicy policy) {
         cachePolicy = policy;
         return this;
     }
 
     public BindRule build() {
         Preconditions.checkState(dependencyType != null, "no dependency type specified");
         if (implementation != null) {
             assert satisfaction == null;
             return new BindRuleImpl(dependencyType, implementation, cachePolicy, qualifierMatcher, flags);
         } else if (satisfaction != null) {
             return new BindRuleImpl(dependencyType, satisfaction, cachePolicy, qualifierMatcher, flags);
         } else {
             throw new IllegalStateException("no binding target specified");
         }
     }
 }