/*
    * Copyright 2011-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.tagcloud.collector;
  
  import static java.io.StreamTokenizer.TT_EOF;
  import static java.io.StreamTokenizer.TT_WORD;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.StreamTokenizer;
  
  import org.codehaus.plexus.util.IOUtil;
  
  import de.smartics.tagcloud.TagCloud;
  
  /**
   * Collects words by using a tokenizer.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public final class TokenizerTagCollector implements TagCollector // NOPMD
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The encoding to use to read from the input stream.
     */
    private final String encoding;
  
    /**
     * The tag cloud to collect for.
     */
    private final TagCloud tagCloud;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     */
    public TokenizerTagCollector(final String encoding, final TagCloud tagCloud)
    {
      this.encoding = encoding;
      this.tagCloud = tagCloud;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * {@inheritDoc}
     *
     * @see de.smartics.tagcloud.collector.TagCollector#collect(java.io.InputStream)
     */
    @Override
    public void collect(final InputStream input) throws IOException
    {
      final Reader reader =
          new BufferedReader(new InputStreamReader(input, encoding));
      try
      {
        final StreamTokenizer tokenizer = createTokenizer(reader);
        tokenize(tokenizer);
      }
      finally
      {
        IOUtil.close(reader);
      }
    }
  
   private static StreamTokenizer createTokenizer(final Reader reader)
   {
     final StreamTokenizer tokenizer = new StreamTokenizer(reader);
     tokenizer.slashSlashComments(true);
     tokenizer.slashStarComments(true);
     return tokenizer;
   }
 
   private void tokenize(final StreamTokenizer tokenizer) throws IOException // NOPMD
   {
     boolean parsingStringLiteral = false;
     boolean parsingCharacterLiteral = false;
     boolean parsingAnnotationLiteral = false;
     for (int token = tokenizer.nextToken(); token != TT_EOF; token =
         tokenizer.nextToken())
     {
       switch (token)
       {
         case TT_WORD:
           if (!(parsingStringLiteral || parsingCharacterLiteral))
           {
             if (!parsingAnnotationLiteral)
             {
               addToken(tokenizer.sval);
             }
             else
             {
               parsingAnnotationLiteral = false;
             }
           }
           break;
         case '"':
           if (!parsingCharacterLiteral)
           {
             parsingStringLiteral = !parsingStringLiteral;
           }
           break;
         case '\'':
           if (!parsingStringLiteral)
           {
             parsingCharacterLiteral = !parsingCharacterLiteral;
           }
           break;
         case '@':
           parsingAnnotationLiteral = true;
           break;
         default:
           break;
       }
     }
   }
 
   private void addToken(final String token)
   {
     if (hasMoreThanOneChar(token) && doesNotContainDot(token))
     {
       tagCloud.addTag(token);
     }
   }
 
   private static boolean doesNotContainDot(final String token)
   {
     return token.indexOf('.') == -1;
   }
 
   private static boolean hasMoreThanOneChar(final String token)
   {
     return token.length() > 1;
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.tagcloud.collector.TagCollector#getTagCloud()
    */
   @Override
   public TagCloud getTagCloud()
   {
     return tagCloud;
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.tagcloud.collector.TagCollector#clear()
    */
   @Override
   public void clear()
   {
     tagCloud.clear();
   }
 
   // --- object basics --------------------------------------------------------
 
 }