/**
    * Copyright 2010, CSIRO Australia.
    *
    * 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 au.csiro.netcdf.util;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.StringTokenizer;
  
  /**
   * Specialised StringTokenizer proxy to handle lines from a CSV file.
   * 
   * Copyright 2010, CSIRO Australia
   * All rights reserved.
   * 
   * @author      James Dempsey on 10/06/2010
   * @version     $Revision: 78 $  $Date: 2010-07-24 16:23:13 +1000 (Sat, 24 Jul 2010) $
   */
  public class CSVTokenizer  extends StringTokenizer
  {
      /** flag indicating whether to return the delimiters as tokens. */
  	private boolean returnTokens;
  	/** The major delimiter of the string to be parsed. */
  	private String majorDelimiter;
  
  	/** A delimiter that is being held for the next request. */
  	private String cachedToken = null;
  	/** Do we have a cached token? */
  	private boolean haveCachedToken = false;
  	/** A token that has been returned for processing. Null if none currently available. */
  	private String pushedBackToken = null;
  	/** Are we at the end of the line yet */
  	private boolean atEOL = false;
  
  	
  	/**
  	 * Constructs a CSV string tokenizer for the specified string. Delimiter characters themselves 
  	 * will not be treated as tokens.
  	 *
  	 * @param str a string to be parsed.
  	 */
  	public CSVTokenizer(String str)
  	{
  		this(str, ',', false);
  	}
  
  
  	/**
  	 * Constructs a CSV string tokenizer for the specified string. Delimiter characters themselves 
  	 * will not be treated as tokens.<P>
  	 * If the returnTokens flag is true, then the delimiter characters are also returned as tokens. 
  	 * Each delimiter is returned as a string of length one. If the flag is false, the delimiter 
  	 * characters are skipped and only serve as separators between tokens. NB: The quotes around 
  	 * some strings will never come out as delimiters. 
  	 *
  	 * @param str a string to be parsed.
  	 * @param returnTokens flag indicating whether to return the delimiters as tokens.
  	 */
  	public CSVTokenizer(String str, boolean returnTokens)
  	{
  		this(str, ',', returnTokens);
  	}
  
  
  	/**
  	 * Constructs a CSV string tokenizer for the specified string. Delimiter characters themselves 
  	 * will not be treated as tokens.<P>
  	 * The majorDelimiter value can be used to change the major delimiter used. Normally this will 
  	 * be a comma, but a tab could be supplied for a tab delimited file.<P>
  	 * If the returnTokens flag is true, then the delimiter characters are also returned as tokens. 
  	 * Each delimiter is returned as a string of length one. If the flag is false, the delimiter 
  	 * characters are skipped and only serve as separators between tokens. NB: The quotes around 
  	 * some strings will never come out as delimiters. 
  	 *
  	 * @param str a string to be parsed.
  	 * @param majorDelimiter The major delimiter of the string to be parsed.
  	 * @param returnTokens flag indicating whether to return the delimiters as tokens.
  	 */
  	public CSVTokenizer(String str, char majorDelimiter, boolean returnTokens)
  	{
  		super(str, "\"\n\015"+ majorDelimiter, true);
  
  		this.returnTokens = returnTokens;
  		this.majorDelimiter = String.valueOf(majorDelimiter);
  	}
  
      /**
      * Returns all remaining columns for this tokenizer as a string. This is 
      * similar to the split function for a string.
      *   
      * @return An array of all remaining columns as strings.
      */
     public String[] getAllColumns()
     {
         List<String> columns = new ArrayList<String>();
         while (hasMoreElements())
         {
             columns.add(nextToken());
         }
         
         return columns.toArray(new String[]{});
     }
 	
 	/**
 	 * We have deliberately excluded the count token method as it would require caching.
 	 *
 	 * @return 0
 	 */
 	public int countTokens()
 	{
 		return 0;
 	}
 
 	public boolean hasMoreElements()
 	{
 		return super.hasMoreElements() || haveCachedToken || pushedBackToken != null;
 	}
 
 	public boolean hasMoreTokens()
 	{
 		return super.hasMoreTokens() || haveCachedToken || pushedBackToken != null;
 	}
 
 	public boolean atEOL()
 	{
 		return atEOL || !hasMoreTokens();
 	}
 
 	public Object nextElement()
 	{
 		return nextToken();
 	}
 
 	public String nextToken()
 	{
 		// If we returned the delimiter last time, return the token this time
 		if (returnTokens && haveCachedToken)
 		{
 			String temp = cachedToken;
 			cachedToken = null;
 			haveCachedToken = false;
 			return temp;
 		}
 
 		// tokenise by comma
 		boolean inQuoteBlock = false;
 		boolean wordFinished = false;
 		String currWord = "";
 		String token = null;
 		atEOL = false;
 
 		while ((pushedBackToken != null || super.hasMoreTokens()) && !wordFinished) 
 		{
 			if (pushedBackToken != null)
 			{
 				token = pushedBackToken;
 				pushedBackToken = null;
 			}
 			else
 			{
 				token = super.nextToken();
 			}
 
 			//Debug.log("CSVT: got token (" + token + ")");
 			if (token.equals("\""))
 			{
 				if (inQuoteBlock)
 				{
 					if (!super.hasMoreTokens())
 					{
 						inQuoteBlock = false;
 						wordFinished = true;
 						token = null;
 					}
 					else
 					{
 						String nextToken = super.nextToken();
 						if (nextToken.equals("\""))
 						{
 							currWord += "\"";
 						}
 						else 
 						{
 							inQuoteBlock = false;
 							pushedBackToken = nextToken;
 						}
 					}
 				}
 				else
 				{
 					inQuoteBlock = true;
 				}
 			}
  			else if (token.equals(majorDelimiter))
 			{
 				if (inQuoteBlock)
 				{
 					currWord += token;
 				}
 				else
 				{
 					wordFinished = true;
 				}
 			}
 			else if (token.equals("\n"))
 			{
 				if (inQuoteBlock)
 				{
 					currWord += "\n";
 				}
 				else
 				{
 					wordFinished = true;
 					atEOL = true;
 				}
 			}
 			else if (token.equals("\015"))
 			{
 				if (inQuoteBlock)
 				{
 					currWord += "\015";
 				}
 				else
 				{
 					if (super.hasMoreTokens())
 					{
 						String nextToken = super.nextToken();
 						if (!nextToken.equals("\n"))
 						{
 							currWord += "\015";
 						}
 						pushedBackToken = nextToken;
 					}
 				}
 			}
 			else
 			{
 			    currWord += token;
 			    token = null;
 			}
 		}
 
 		if (returnTokens)
 		{
 			cachedToken = token;
 			haveCachedToken = cachedToken != null;
 			return currWord;
 		}
 		else
 		{
 			cachedToken = null;
 			return currWord;
 		}
 	}
 }