/*
    * Copyright 2004-2005 Dan Washusen
    *
    * 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.reactive.beans.factory.config;
  
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /***
   * The default implementation of {@link PlaceholderMatcher} that uses the "standard" format of "${valueToBeEveluated}".
   * <p>The default format can be overwritten by using the {@link #setPlaceholderRegex(String)} and {@link #setPlaceholderSuffix(String)} methods.</p>
   *
   * @author Dan Washusen
   * @version $Id: DefaultPlaceholderMatcher.java,v 1.1 2004/12/26 23:42:29 dan_washusen Exp $
   * @since 16.12.2004
   */
  public class DefaultPlaceholderMatcher
          implements PlaceholderMatcher {
      /*** The default regex to determine if the value contains a placeholder. */
      public static final String DEFAULT_PLACEHOLDER_REGEX = "//$//{.*?//}";
      public static final String DEFAULT_PLACEHOLDER_PREFIX = "${";
  	public static final String DEFAULT_PLACEHOLDER_SUFFIX = "}";
  
      /*** The prefix for a placeholder value. */
      protected String placeholderRegex = DEFAULT_PLACEHOLDER_REGEX;
      private String placeholderPrefix = DEFAULT_PLACEHOLDER_PREFIX;
  	private String placeholderSuffix = DEFAULT_PLACEHOLDER_SUFFIX;
  
      protected String value;
      protected Pattern pattern;
      protected Matcher matcher;
      protected boolean placeholderPresent = false;
      /*** If multple placeholders are present in the value then it must evaluate to a string */
      protected boolean multiplePlaceholdersPresent = false;
      protected Placeholder placeholder = null;
      protected int proceedingTextBeginIndex = 0;
      protected String proceedingText = null;
      protected String trailingText = null;
  
      /***
       * Returns the prefix for a placeholder value.
       * @return the prefix for a placeholder value
       */
      public String getPlaceholderRegex() {
          return placeholderRegex;
      }
  
      /***
       * Sets the prefix for a placeholder value.
       * @param placeholderRegex the prefix for a placeholder value
       */
      public void setPlaceholderRegex(String placeholderRegex) {
          this.placeholderRegex = placeholderRegex;
      }
  
      public String getPlaceholderPrefix() {
          return placeholderPrefix;
      }
  
      public void setPlaceholderPrefix(String placeholderPrefix) {
          this.placeholderPrefix = placeholderPrefix;
      }
  
      public String getPlaceholderSuffix() {
          return placeholderSuffix;
      }
  
      public void setPlaceholderSuffix(String placeholderSuffix) {
          this.placeholderSuffix = placeholderSuffix;
      }
  
      public String getValue() {
          return value;
      }
  
      public void init(String value) {
          // reset the previous values
          this.placeholder = null;
          this.proceedingText = null;
          this.trailingText = null;
          this.proceedingTextBeginIndex = 0;
  
          this.value = value;
          this.pattern = Pattern.compile(getPlaceholderRegex());
          this.matcher = this.pattern.matcher(getValue());
  
         // determine if a place holder is present in this value
         this.placeholderPresent = this.matcher.find();
 
         // check for multiple placeholders
         this.multiplePlaceholdersPresent = this.matcher.find();
 
         // reset the matcher for the evalution
         this.matcher.reset();
     }
 
     public boolean isPlaceholderPresent() {
         return this.placeholderPresent;
     }
 
     public boolean isMultiplePlaceholdersPresent() {
         return this.multiplePlaceholdersPresent;
     }
 
     public Placeholder next() {
         return this.placeholder;
     }
 
     public boolean hasNext() {
         boolean hasNext = this.matcher.find();
         if (hasNext) {
             this.placeholder = new DefaultPlaceholder(stripPlaceholderWrappers(this.matcher.group()));
 
             // if we need the proceeding text allocate it
             int proceedingTextEndIndex = this.matcher.start();
             if (proceedingTextBeginIndex != proceedingTextEndIndex)
                 this.proceedingText = value.substring(proceedingTextBeginIndex, proceedingTextEndIndex);
 
             // if we need the trailing text allocate it
             int trailingTextBeginIndex = this.matcher.end();
             int trailingTextEndIndex = this.value.length();
             if (trailingTextBeginIndex != trailingTextEndIndex)
                 this.trailingText = value.substring(this.matcher.end(), this.value.length());
 
             // increment the proceedingTextBeginIndex for the next time this method is called
             proceedingTextBeginIndex = this.matcher.end();
         }
         else {
             this.placeholder = null;
         }
 
         return hasNext;
     }
 
     /***
      * This method returns the placeholder with the prefix and suffix removed.
      * <p>e.g. a value of "${placeholder}" would return the value "placeholder".</p>
      * @param placeholderText The placeholder text
      * @return The placeholder text without the prefix and suffix
      */
     protected String stripPlaceholderWrappers(String placeholderText) {
         return placeholderText.substring(getPlaceholderPrefix().length(), (placeholderText.length() - getPlaceholderSuffix().length()));
     }
 
     public String getProceedingText() {
         return this.proceedingText;
     }
 
     public String getTrailingText() {
         return this.trailingText;
     }
 
 }