/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * Java-Common 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 Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.util;
  
  import com.cosylab.introspection.ClassIntrospector;
  
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.lang.reflect.Array;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  
  
  /**
   * Usefull methods for working with strings.
   *
   * @author <a href="mailto:miha.kadunc@cosylab.com">Miha Kadunc</a>
   * @author Ales Pucelj
   * @version $id$
   */
  public final class StringUtilities
  {
  	private static final PrintfFormat byteFormat= new PrintfFormat("%.1f");
  
  	// FP number segments  sign*decPart.fracPartEexpSign*expPart
  	private static final int ERROR_STATE = 99;
  
  	// Parser state transitions: transitions[Current State][Symbol]
  	private static final int[][] transitions = {
  			{ 99, 1, 1, 2, 3 },
  			{ 99, 99, 1, 2, 3 },
  			{ 99, 99, 2, 99, 3 },
  			{ 99, 4, 4, 99, 99 },
  			{ 99, 99, 4, 99, 99 }
  		};
  	private static char decimalSeparator = '.';
  
  	/**
  	 * Constructor for StringHelper.
  	 */
  	private StringUtilities()
  	{
  		//
  	}
  
  	/**
  	 * DOCUMENT ME!
  	 *
  	 * @param sValue DOCUMENT ME!
  	 * @param targetClass DOCUMENT ME!
  	 *
  	 * @return DOCUMENT ME!
  	 *
  	 * @throws CommonException DOCUMENT ME!
  	 */
  	public static Object fromString(String sValue, Class targetClass)
  		throws CommonException
  	{
  		try {
  			if ((sValue == null) || (sValue.equals(""))) {
  				return targetClass.newInstance();
  			}
  
  			if (targetClass.isArray()) {
  				return arrayFromString(sValue, targetClass);
  			}
  
  			if (targetClass.equals(String.class)) {
  				return sValue;
  			} else if (Number.class.isAssignableFrom(targetClass)
  			    || Boolean.class.isAssignableFrom(targetClass)) {
  				return targetClass.getMethod("valueOf",
  				    new Class[]{ String.class }).invoke(null,
  				    new Object[]{ sValue });
  			} else if (targetClass.isPrimitive()) {
  				// we are not able to return Object of a primitive type so use its class implementation
  				if (Boolean.TYPE.equals(targetClass)) {
  					return Boolean.valueOf(sValue);
  				}
  
  				if (Short.TYPE.equals(targetClass)) {
  					return Short.valueOf(sValue);
 				}
 
 				if (Byte.TYPE.equals(targetClass)) {
 					return Byte.valueOf(sValue);
 				}
 
 				if (Character.TYPE.equals(targetClass)) {
 					return new Character(sValue.charAt(0));
 				}
 
 				if (Integer.TYPE.equals(targetClass)) {
 					return Integer.valueOf(sValue);
 				}
 
 				if (Long.TYPE.equals(targetClass)) {
 					return Long.valueOf(sValue);
 				}
 
 				if (Float.TYPE.equals(targetClass)) {
 					return Float.valueOf(sValue);
 				}
 
 				if (Double.TYPE.equals(targetClass)) {
 					return Double.valueOf(sValue);
 				}
 
 				return null;
 			} else if (Class.class == targetClass) {
 				// in case of primitive types return its class
 				return classFromString(sValue);
 			}
 			// check if the class has the valueOf(String) method and call it with given parameter if so
 			// the example is in case of DataProducer which is instantiated by the parameters from the xml file
 			else {
 				Method met = ClassIntrospector.getMethod(targetClass,
 					    "valueOf", new Class[]{ String.class });
 
 				if (met != null) {
 					return met.invoke(null, new String[]{ sValue });
 				}
 
 				return targetClass.newInstance();
 			}
 		} catch (NoSuchMethodException e) {
 			throw new CommonException(ArrayHelper.class,
 			    "Objects could not be instantiated from strings", e);
 		} catch (IllegalAccessException e) {
 			throw new CommonException(ArrayHelper.class,
 			    "Objects could not be instantiated from strings", e);
 		} catch (InvocationTargetException e) {
 			throw new CommonException(ArrayHelper.class,
 			    "Objects could not be instantiated from strings", e);
 		} catch (InstantiationException e) {
 			throw new CommonException(ArrayHelper.class,
 			    "Objects could not be instantiated from strings", e);
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param sValue DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 *
 	 * @throws CommonException DOCUMENT ME!
 	 */
 	public static Class classFromString(String sValue)
 		throws CommonException
 	{
 		try {
 			if (sValue.equals(Boolean.TYPE.getName())) {
 				return Boolean.TYPE;
 			}
 
 			if (sValue.equals(Short.TYPE.getName())) {
 				return Short.TYPE;
 			}
 
 			if (sValue.equals(Byte.TYPE.getName())) {
 				return Byte.TYPE;
 			}
 
 			if (sValue.equals(Character.TYPE.getName())) {
 				return Character.TYPE;
 			}
 
 			if (sValue.equals(Integer.TYPE.getName())) {
 				return Integer.TYPE;
 			}
 
 			if (sValue.equals(Long.TYPE.getName())) {
 				return Long.TYPE;
 			}
 
 			if (sValue.equals(Float.TYPE.getName())) {
 				return Float.TYPE;
 			}
 
 			if (sValue.equals(Double.TYPE.getName())) {
 				return Double.TYPE;
 			}
 
 			if (sValue.equals(Void.TYPE.getName())) {
 				return Void.TYPE;
 			}
 
 			return Class.forName(sValue);
 		} catch (ClassNotFoundException e) {
 			throw new CommonException(ArrayHelper.class,
 			    "Class could not be instantiated from a String", e);
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param arrayString DOCUMENT ME!
 	 * @param arrayClass DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 *
 	 * @throws CommonException DOCUMENT ME!
 	 */
 	public static Object arrayFromString(String arrayString, Class arrayClass)
 		throws CommonException
 	{
 		return arrayFromString(arrayString, arrayClass, ",", true);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param arrayString DOCUMENT ME!
 	 * @param arrayClass DOCUMENT ME!
 	 * @param separator DOCUMENT ME!
 	 * @param parentheses DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 *
 	 * @throws CommonException DOCUMENT ME!
 	 */
 	public static Object arrayFromString(String arrayString, Class arrayClass,
 	    String separator, boolean parentheses) throws CommonException
 	{
 		String[] pStrings = arrayString.split(separator);
 
 		if (parentheses) {
 			pStrings[0] = pStrings[0].substring(1);
 			pStrings[pStrings.length - 1] = pStrings[pStrings.length - 1]
 				.substring(0, pStrings[pStrings.length - 1].length() - 1);
 		}
 
 		Object retArray = Array.newInstance(arrayClass.getComponentType(),
 			    pStrings.length);
 
 		for (int i = 0; i < pStrings.length; i++) {
 			Array.set(retArray, i,
 			    StringUtilities.fromString(pStrings[i],
 			        arrayClass.getComponentType()));
 		}
 
 		return retArray;
 	}
 
 	/**
 	 * Simple, robust floating point number parsing, it returns
 	 * <code>NaN</code> if parsing fails, no exception thrown.
 	 * 
 	 * <p>
 	 * The parser is derived from the following regular expression:
 	 * </p>
 	 * 
 	 * <p>
 	 * <code>[+-]?[0-9](\.[0-9])?((e[+-]?)[0-9])?</code>
 	 * </p>
 	 *
 	 * @param s input string
 	 *
 	 * @return double value
 	 */
 	public static final double parseDouble(final String s)
 	{
 		double decPart = 0.0;
 		double sign = 1.0;
 
 		double fracPart = 0.0;
 		double fracDiv = 10.0;
 
 		double expPart = 0.0;
 		double expSign = 1.0;
 
 		char[] chars = s.trim().toCharArray();
 		int n = chars.length;
 
 		int currState = 0;
 		int nextState = ERROR_STATE;
 		int symbol = 0;
 		char ch = ' ';
 
 		int c = 0;
 
 		while ((c < n) && (currState != ERROR_STATE)) {
 			ch = chars[c++];
 			symbol = getNextSymbol(ch);
 			nextState = transitions[currState][symbol];
 
 			//doAction(nextState, nextSymbol, nextChar);
 			switch (nextState) {
 			case 1:
 
 				if (symbol == 1) {
 					if (ch == '-') {
 						sign = -1.0;
 					}
 				} else {
 					decPart *= 10;
 					decPart += (ch - '0');
 				}
 
 				break;
 
 			case 2:
 
 				if (symbol != 3) {
 					fracPart += (ch - '0') / fracDiv;
 					fracDiv *= 10;
 				}
 
 				break;
 
 			case 4:
 
 				if (symbol == 1) {
 					if (ch == '-') {
 						expSign = -1.0;
 					}
 				} else {
 					expPart *= 10;
 					expPart += (ch - '0');
 				}
 			}
 
 			currState = nextState;
 		}
 
 		if (currState != ERROR_STATE) {
 			expPart = Math.pow(10, expSign * expPart);
 
 			return sign * (decPart + fracPart) * expPart;
 		}
 
 		return Double.NaN;
 	}
 
 	private static final int getNextSymbol(final char ch)
 	{
 		if (Character.isDigit(ch)) {
 			return 2;
 		}
 
 		if ((ch == '+') || (ch == '-')) {
 			return 1;
 		}
 
 		if (ch == decimalSeparator) {
 			return 3;
 		}
 
 		if ((ch == 'e') || (ch == 'E')) {
 			return 4;
 		}
 
 		return 0;
 	}
 
 	/**
 	 * Checks if string unambiguously represents double value. If string can
 	 * not be transformed to unique double, then <code>false</code> is
 	 * returned. Method <code>parseDouble</code> tries to convert to double
 	 * any
 	 *
 	 * @param value the String to be tested
 	 *
 	 * @return <code>true</code> only if string unambiguously represents double
 	 *         value
 	 */
 	public static boolean isTrueNumber(String value)
 	{
 		if (value == null) {
 			return false;
 		}
 
 		String s = value.trim();
 
 		if (s.length() == 0) {
 			return false;
 		}
 
 		if (s.length() == 1 && !Character.isDigit(s.charAt(0))) {
 			return false;
 		}
 
 		double d = parseDouble(s);
 
 		if (Double.isNaN(d) || Double.isInfinite(d)) {
 			return false;
 		}
 
 		return true;
 	}
 	
 	/**
 	 * Prints bytes with human readable format.
 	 * @param bytes file or memory size in bytes
 	 * @param pr print writer
 	 */
 	public static void printBytes(long bytes, PrintWriter pr) {
 		
 		if (bytes>=900000000) {
 			pr.print(byteFormat.sprintf(bytes/1000000000.0));
 			pr.print('G');
 			pr.print('B');
 			return;
 		}
 		if (bytes>=900000) {
 			pr.print(byteFormat.sprintf(bytes/1000000.0));
 			pr.print('M');
 			pr.print('B');
 			return;
 		}
 		if (bytes>900) {
 			pr.print(byteFormat.sprintf(bytes/1000.0));
 			pr.print('M');
 			pr.print('B');
 			return;
 		}
 		
 		pr.print(bytes);
 		pr.print('B');
 	}
 	
 	/**
 	 * Prints bytes with human readable format.
 	 * @param bytes file or memory size in bytes
 	 *
      */
 	public static String printBytes(long bytes) {
 		StringWriter sw= new StringWriter(8);
 		printBytes(bytes,new PrintWriter(sw));
 		return sw.toString();
 	}
 }
 
 /* __oOo__ */