/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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 de.smartics.properties.spi.core.constraint.jsr303;
  
  import java.lang.annotation.Annotation;
  import java.util.StringTokenizer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * A helper class to make JSR-303 constraints human readable in the context of
   * smartics properties.
   */
  final class ConstraintPrettifier
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The pattern to match constraints in their native, typical
     * {@link Annotation#toString()} representation.
     */
    private static final Pattern PATTERN = Pattern
        .compile("@([^(]+)\\(([^)]+)\\)");
  
    // --- members --------------------------------------------------------------
  
    /**
     * The annotation prettified by this instance.
     */
    private final Annotation annotation;
  
    /**
     * The prettified instance of the annotation.
     */
    private final String pretty;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param annotation the annotation prettified by this instance.
     * @throws NullPointerException if {@code annotation} is <code>null</code>.
     */
    ConstraintPrettifier(final Annotation annotation) throws NullPointerException
    {
      this.pretty = prettify(annotation);
      this.annotation = annotation;
    }
  
    // ****************************** Inner Classes *****************************
  
    /**
     * A parameter token.
     */
    private static final class ParameterToken
    {
      /**
       * The name of the token.
       */
      private String name;
  
      /**
       * Flag to check if the token a name/value pair.
       */
      private boolean isNameValue;
  
      /**
       * The original token.
       */
      private String token;
  
      private boolean isRelevantParameter()
      {
        return !("message".equals(name) || "groups".equals(name) || "payload"
            .equals(name)) && !tokenIsEmptyArray();
      }
  
      private boolean tokenIsEmptyArray()
      {
        return token.endsWith("=[]");
      }
 
     private void append(final StringBuilder buffer)
     {
       buffer.append(' ').append(token.trim()).append(',');
     }
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   private static String prettify(final Annotation annotation)
     throws NullPointerException
   {
     final String plain = annotation.toString();
 
     final Matcher matcher = PATTERN.matcher(plain);
     if (matcher.matches())
     {
       final StringBuilder buffer = new StringBuilder(128);
       final String constraint = matcher.group(1);
       addConstraint(buffer, constraint);
       final String parameter = matcher.group(2);
       addParameter(buffer, parameter);
       return buffer.toString();
     }
     else
     {
       return plain;
     }
   }
 
   private static void addConstraint(final StringBuilder buffer,
       final String constraint)
   {
     final int index = constraint.lastIndexOf('.');
     if (index > -1 && index < constraint.length() - 1)
     {
       final String shortName = constraint.substring(index + 1);
       buffer.append(shortName);
     }
     else
     {
       buffer.append(constraint);
     }
   }
 
   private static void addParameter(final StringBuilder buffer,
       final String parameter)
   {
     final int initialLength = buffer.length();
     final StringTokenizer tokenizer = new StringTokenizer(parameter, ",");
     while (tokenizer.hasMoreTokens())
     {
       final ParameterToken token = fetchToken(tokenizer);
       if (token.isNameValue)
       {
         if (token.isRelevantParameter())
         {
           token.append(buffer);
         }
       }
       else
       {
         token.append(buffer);
       }
     }
 
     if (initialLength < buffer.length())
     {
       buffer.setCharAt(initialLength, '(');
       buffer.setCharAt(buffer.length() - 1, ')');
     }
   }
 
   private static ParameterToken fetchToken(final StringTokenizer tokenizer)
   {
     final ParameterToken result = new ParameterToken();
 
     String token = tokenizer.nextToken();
     final int index = token.indexOf('=');
     result.isNameValue = index != -1;
     if (result.isNameValue)
     {
       final StringBuilder buffer = new StringBuilder(24);
       if (token.charAt(index + 1) == '[')
       {
         while (tokenizer.hasMoreTokens() && !token.endsWith("]"))
         {
           buffer.append(token).append(',');
           token = tokenizer.nextToken();
         }
         buffer.append(token);
         result.token = buffer.toString();
       }
       else
       {
         result.token = token;
       }
 
       result.name = result.token.substring(0, index).trim();
     }
 
     return result;
   }
 
   /**
    * Returns the annotation prettified by this instance.
    *
    * @return the annotation prettified by this instance.
    */
   public Annotation getAnnotation()
   {
     return annotation;
   }
 
   /**
    * Returns the prettified instance of the annotation.
    *
    * @return the prettified instance of the annotation.
    */
   public String getPretty()
   {
     return pretty;
   }
 
   // --- business -------------------------------------------------------------
 
   // --- object basics --------------------------------------------------------
 
   @Override
   public String toString()
   {
     return pretty;
   }
 }