/*
    * 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.introspection;
  
  import java.beans.FeatureDescriptor;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Member;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  
  /**
   * This class helps create String representations of
   * given objects using introspection. It also contains some
   * methods that facilitate String manipulation.
   * 
   * @author  Miha Kadunc (miha.kadunc@cosylab.com)
   * @version @@VERSION@@
   */
  public class DataFormatter {
  
  	/**
  	 * Returns short name of the given Class object. Appends
  	 * the appropriate number of "[]" sequences for arrays. 
  	 * 
  	 * @param aClass Class
  	 * @return java.lang.String
  	 */
  	public static String toString(Class aClass) {
  		if (aClass == null)
  			return "null";
  		StringBuffer t = new StringBuffer();
  		if (aClass.isArray()) {
  			t.append(toString(aClass.getComponentType()));
  			int dim = aClass.getName().lastIndexOf("[") - aClass.getName().indexOf("[") + 1;
  			for (int i = 0; i < dim; i++)
  				t.append("[ ]");
  		} else {
  			t.append(aClass.getName());
  			int i = aClass.getName().lastIndexOf(".") + 1;
  			if (i > 0)
  				t.delete(0, i);
  		}
  		return t.toString();
  	}
  
  	/**
  	 * Returns a String representing an array of Class objects,
  	 * separated by ","
  	 * 
  	 * @param array Class[]
  	 * @return parameter names
  	*/
  	public static String toString(Class[] array) {
  		StringBuffer result = new StringBuffer(" ");
  		for (int i = 0; i < array.length; i++) {
  			if (i > 0)
  				result.append(", ");
  			result.append(toString(array[i]));
  		}
  		result.append(" ");
  		return result.toString();
  	}
  
  	/**
  	 * Returns a String representation of a constructor.
  	 * 
  	 * @param aConstructor Constructor
  	 * @param showParameters boolean
  	 * @return java.lang.String
  	*/
  	public static String toString(Constructor aConstructor, boolean showParameters) {
  		String ret = aConstructor.getName();
  		if (showParameters)
  			ret = ret + " (" + toString(aConstructor.getParameterTypes()) + ")";
  		return ret;
  	}
  
  	/**
  	 * Returns a String representation of the given field, 
  	 * showing its type and its name.
 	 * 
 	 * @param aField Field
 	 * @return java.lang.String
 	 */
 	public static String toString(Field aField) {
 		return toString(aField, true);
 	}
 
 	/**
 	 * Returns a String representation of the given field,
 	 * showing its type iff the showType parameter is set
 	 * to true.
 	 * 
 	 * @param aField Field
 	 * @param showType boolean
 	 * @return java.lang.String
 	 */
 	public static String toString(Field aField, boolean showType) {
 		String ret = "";
 		if (showType)
 			ret = ret + toString(aField.getType()) + " ";
 		ret = ret + aField.getName();
 		return ret;
 	}
 
 	/**
 	 * Returns a String representation of the specified member,
 	 * and its return and parameter types.
 	 * 
 	 * @param aMember Member
 	 * @return java.lang.String
 	 */
 	public static String toString(Member aMember) {
 		return toString(aMember, true, true);
 	}
 
 	/**
 	 * Returns a String representation of the specified member,
 	 * and its return and parameter types only if specified so by
 	 * the showType and showParameters flags.
 	 * 
 	 * @param aMember Member
 	 * @param showType boolean
 	 * @param showParameters boolean
 	 * @return java.lang.String
 	*/
 	public static String toString(Member aMember, boolean showType, boolean showParameters) {
 		if (aMember == null)
 			return "null";
 		if (aMember.getClass().equals(Field.class))
 			return toString((Field)aMember, showType);
 		if (aMember.getClass().equals(Method.class))
 			return toString((Method)aMember, showType, showParameters);
 		if (aMember.getClass().equals(Constructor.class))
 			return toString((Constructor)aMember, showParameters);
 		else
 			return "";
 	}
 
 	/**
 	 * Returns a String representation of the given method, 
 	 * showing also its type and parameter types.
 	 * 
 	 * @param aMethod Method
 	 * @return java.lang.String
 	 */
 	public static String toString(Method aMethod) {
 		return toString(aMethod, true, true);
 	}
 
 	/**
 	 * Returns a String representation of the given method, 
 	 * showing also its type and parameter types iff specified.
 	 * 
 	 * @param aMethod Method
 	 * @param showType boolean
 	 * @param showParameters boolean
 	 * @return java.lang.String
 	 */
 	public static String toString(Method aMethod, boolean showType, boolean showParameters) {
 		String ret = "";
 		if (showType)
 			ret = ret + toString(aMethod.getReturnType()) + " ";
 		ret = ret + aMethod.getName();
 		if (showParameters)
 			ret = ret + " (" + toString(aMethod.getParameterTypes()) + ") ";
 		return ret;
 	}
 
 	/**
 	 * Returns an array of String representations of Class objects
 	 * contained in the given array.
 	 * 
 	 * @param array Class[]
 	 * @return parameter names
 	 */
 	public static String[] toStringArray(Class[] array) {
 		String[] result = new String[array.length];
 		for (int i = 0; i < array.length; i++) {
 			result[i] = (toString(array[i]));
 		}
 		return result;
 	}
 
 	/**
 	 * Returns an array of String representations of 
 	 * members in the given array. Parameters can be set to
 	 * show return or parameter types.
 	 * 
 	 * @param array Member[]
 	 * @param showType boolean
 	 * @param showParameters boolean
 	 * @return String[] array of string representations of the members
 	 */
 	public static String[] toStringArray(Member[] array, boolean showType, boolean showParameters) {
 		String[] result = new String[array.length];
 		for (int i = 0; i < array.length; i++) {
 			result[i] = (toString(array[i], showType, showParameters));
 		}
 		return result;
 	}
 
 	/**
 	 * Returns an array of String representations of 
 	 * feature descriptors in the given array.
 	 * 
 	 * @param array FeatureDescriptor[]
 	 * @param showType boolean
 	 * @param showParameters boolean
 	 * @return String[] array of string representations of the members
 	 */
 	public static String[] toStringArray(
 		FeatureDescriptor[] array,
 		boolean showType,
 		boolean showParameters) {
 
 		return toStringArray(array);
 	}
 
 	/**
 	 * Returns an array of String representations of 
 	 * objects in the given array.
 	 * 
 	 * @param array Object[]
 	 * @return String[]
 	 */
 	public static String[] toStringArray(Object[] array) {
 		if (array == null)
 			return new String[0];
 		String[] result = new String[array.length];
 		for (int i = 0; i < array.length; i++) {
 			result[i] = array[i].toString();
 		}
 		return result;
 	}
 
 	/**
 	 * Returns a default String representation of an array.
 	 * 
 	 * @param array java.lang.Object
 	 * @return java.lang.String
 	 */
 	public static String arrayToString(Object array) {
 		return arrayToString(array, "");
 	}
 	/**
 	 * Returns a String representation of an array with
 	 * the specified text in the beginning of each line.
 	 * 
 	 * @param array java.lang.Object
 	 * @param lineStart java.lang.String
 	 * @return java.lang.String
 	 */
 	public static String arrayToString(Object array, String lineStart) {
 		if (array.getClass().isArray()) {
 			Object[] fixedArray;
 			StringBuffer result = new StringBuffer();
 
 			result.append(lineStart);
 			result.append("Array of class: ");
 			result.append(array.getClass().getComponentType().getName());
 			if (array.getClass().getComponentType().isPrimitive())
 				fixedArray = convertPrimitiveArray(array);
 			else
 				fixedArray = (Object[])array;
 			result.append(" length: ");
 			result.append(fixedArray.length);
 			result.append("\n");
 
 			for (int i = 0; i < fixedArray.length; i++) {
 				result.append(lineStart);
 				result.append(" [");
 				result.append(i);
 				result.append("] ");
 				result.append(fixedArray[i].toString());
 				result.append("\n");
 			}
 			return result.toString();
 		} else
 			throw new IllegalArgumentException("array parameter is not an array");
 	}
 	/**
 	 * Converts an array of primitive values into Java
 	 * wrappers.
 	 * @param value Object
 	 * @return Object[]
 	 */
 	public static Object[] convertPrimitiveArray(Object value) {
 		if (!(value.getClass().isArray() && value.getClass().getComponentType().isPrimitive()))
 			throw new IllegalArgumentException("value is not a primitive Array");
 		try {
 			Class type = value.getClass().getComponentType();
 			Object[] retVal = null;
 			if (type.toString().equals("int")) {
 				int[] tempVal = (int[])value;
 				retVal = new Integer[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Integer(tempVal[i]);
 			}
 			if (type.toString().equals("double")) {
 				double[] tempVal = (double[])value;
 				retVal = new Double[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Double(tempVal[i]);
 			}
 			if (type.toString().equals("long")) {
 				long[] tempVal = (long[])value;
 				retVal = new Long[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Long(tempVal[i]);
 			}
 			if (type.toString().equals("short")) {
 				short[] tempVal = (short[])value;
 				retVal = new Short[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Short(tempVal[i]);
 			}
 			if (type.toString().equals("byte")) {
 				byte[] tempVal = (byte[])value;
 				retVal = new Byte[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Byte(tempVal[i]);
 			}
 			if (type.toString().equals("char")) {
 				char[] tempVal = (char[])value;
 				retVal = new Character[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Character(tempVal[i]);
 			}
 			if (type.toString().equals("float")) {
 				float[] tempVal = (float[])value;
 				retVal = new Float[tempVal.length];
 				for (int i = 0; i < tempVal.length; i++)
 					retVal[i] = new Float(tempVal[i]);
 			}
 			return retVal;
 		} catch (Exception e) {
 			throw new IllegalArgumentException("value could not be converted");
 		}
 	}
 	/**
 	 * Returns number of lines (separated by \n)
 	 * contained in the given String.
 	 * 
 	 * @param lines java.lang.String
 	 * @return int
 	 */
 	public static int getLineCount(String lines) {
 		int count = 0;
 		int pos = -1;
 		int maxPos = lines.length();
 
 		do {
 			pos = lines.indexOf(10, pos + 1);
 			count++;
 		} while ((pos > -1) && (pos < maxPos));
 
 		return count;
 	}
 
 	/**
 	 * Splits a given string into multiple strings, each containing
 	 * a single line (separated by \n)
 	 * 
 	 * @param stringToSplit String
 	 * @return int
 	 */
 	public static String[] splitStringByLines(String stringToSplit) {
 		int end = -1;
 		int start = 0;
 		int maxPos = stringToSplit.length();
 		java.util.ArrayList list = new java.util.ArrayList();
 		do {
 			end = stringToSplit.indexOf(10, start);
 			if ((end >= 0) && (end < maxPos) && (start >= 0) && (start < maxPos))
 				list.add(stringToSplit.substring(start, end));
 			start = end + 1;
 		} while ((end > -1) && (end < maxPos));
 		String[] retVal = new String[list.size()];
 		list.toArray(retVal);
 		return retVal;
 	}
 
 	public static String[] splitStringOnCapitals(String stringToSplit) {
 		String[] rez = stringToSplit.split("[A-Z]");
 		int prev = 0;
 		for (int i = 1; i < rez.length; i++) {
 			prev = prev + rez[i - 1].length();
 			rez[i] = stringToSplit.charAt(prev) + rez[i];
 		}
 		return rez;
 	}
 	/**
 	 * Creates a default String representation of an array.
 	 * 
 	 * @param array java.lang.Object
 	 * @return java.lang.String
 	 */
 	public static String unpackArray(Object array) {
 		return unpackArray(array, "", 0);
 	}
 	/**
 	 * Creates a String representation of an array, putting
 	 * the passed lineStart at the beginning of each line.
 	 *
 	 * @param array java.lang.Object
 	 * @param lineStart java.lang.String
 	 * @return java.lang.String
 	 */
 	public static String unpackArray(Object array, String lineStart) {
 		return unpackArray(array, lineStart, 0);
 	}
 	/**
 	 * Creates a String representation of an array, putting
 	 * the passed lineStart at the beginning of each line. Level
 	 * specifies the recursion depth.
 	 *
 	 * @param array java.lang.Object
 	 * @param lineStart java.lang.String
 	 * @param level int
 	 * @return java.lang.String
 	 */
 	public static String unpackArray(Object array, String lineStart, int level) {
 		StringBuffer result = new StringBuffer();
 		Class type = array.getClass().getComponentType();
 		result.append("[Array of " + type + "], length = " + java.lang.reflect.Array.getLength(array));
 		Object[] list = null;
 		if (type.isPrimitive()) {
 			list = convertPrimitiveArray(array);
 		} else
 			list = (Object[])array;
 		for (int i = 0; i < list.length; i++)
 			result.append(
 				"\n"
 					+ lineStart
 					+ "   |("
 					+ i
 					+ ") "
 					+ unpackReturnValue(list[i], lineStart + "  ", level - 1,true));
 		return result.toString();
 	}
 	/**
 	 * Uses introspection to unpack any type of return value operations might
 	 * return. It does that recursively to the level of max_recursion_level. 
 	 * It omitts methods, such as hashCode, clone etc.
 	 *
 	 * @param value Object
 	 * @param start String
 	 * @param level int
 	 * @return String
 	 */
 	public static String unpackReturnValue(Object value, String start, int level) {
 		return unpackReturnValue(value, start, level, false);
 	}
 	/**
 	 * Uses introspection to unpack any type of return value operations might
 	 * return. If expand is true, it does that recursively to the level of max_recursion_level. 
 	 * It omitts methods, such as hashCode.
 	 *
 	 * @param value Object
 	 * @param start String
 	 * @param level int
 	 * @param expand boolean
 	 * @return String
 	 */
 	public static String unpackReturnValue(Object value, String start, int level, boolean expand) {
 		StringBuffer result = new StringBuffer(500);
 		if (value != null) {
 			Class type = value.getClass();
 			if (type.isArray()) {
 				result.append(unpackArray(value, start, level));
 			} else {
 				if (value instanceof java.lang.String || 
 						ClassIntrospector.isPrimitiveWrapper(value.getClass()) ||
 						value instanceof java.lang.Class
 						) {
 					result.append(value.toString());
 				} else {
 					if (level < 0)
 						return (value.getClass() + " (Recursion level exceeded)");
 					else {
 						result.append(value.toString());
 						if (expand) {
 							result.append('\n');
 							result.append(start);
 							result.append("  (" + type.getName() + ")");
 							java.lang.reflect.Field[] fields = type.getFields();
 
 							for (int j = 0; j < fields.length; j++) {
 								if (!Modifier.isStatic(fields[j].getModifiers())
 									&& Modifier.isPublic(fields[j].getModifiers())) {
 
 									Field curField = fields[j];
 									curField.setAccessible(true);
 
 									result.append('\n');
 									result.append(start);
 									result.append("  |- ");
 									result.append(curField.getName());
 									result.append(": ");
 
 									try {
 										result.append(
 											unpackReturnValue(curField.get(value), start + "  | ", level - 1,expand));
 									} catch (IllegalArgumentException e) {
 										result.append("Exception: ");
 										result.append(e.toString());
 									} catch (IllegalAccessException e) {
 										result.append("Exception: ");
 										result.append(e.toString());
 									}
 								}
 							}
 
 							java.lang.reflect.Method[] methods = type.getMethods();
 							for (int j = 0; j < methods.length; j++) {
 								if (java.lang.reflect.Modifier.isPublic(methods[j].getModifiers())) {
 									java.lang.reflect.Method curMet = methods[j];
 									if ((curMet.getParameterTypes().length == 0)
 										&& (curMet.getReturnType().isPrimitive() || level > 0)
 										&& (!curMet.getReturnType().equals(Void.TYPE))
 										&& (curMet.getName().startsWith("is") || curMet.getName().startsWith("get"))
 										&& (!curMet.getName().equals("getClass"))) {
 
 										curMet.setAccessible(true);
 										
 										result.append("\n");
 										result.append(start);
 										result.append("  |- ");
 										result.append(curMet.getName());
 										result.append(" : ");
 										try {
 											result.append(
 												unpackReturnValue(curMet.invoke(value, null), start + "  | ", level - 1,expand));
 										} catch (IllegalArgumentException e) {
 											result.append("Exception: ");
 											result.append(e.toString());
 										} catch (IllegalAccessException e) {
 											result.append("Exception: ");
 											result.append(e.toString());
 										} catch (InvocationTargetException e) {
 											result.append("Exception: ");
 											result.append(e.getCause().toString());
 										}
 									}
 								}
 							}
 						}
 					}
 				}
 			}
 			return result.toString();
 		} else
 			return ("null");
 	}
 	/**
 	 * Unpacks the given values and creates their String representations.
 	 * 
 	 * 
 	 * @param names java.lang.String[]
 	 * @param values java.lang.Object[]
 	 * @return java.lang.String
 	 */
 	public static String unpackValues(String[] names, Object[] values) {
 		return unpackValues(names, values, ":");
 	}
 	/**
 	 * Unpacks the given values and creates their String representations.
 	 * The names and values are separated by the specified delimiter
 	 * 
 	 * @param names java.lang.String[]
 	 * @param values java.lang.Object[]
 	 * @param delimiter String
 	 * @return java.lang.String
 	 */
 	public static String unpackValues(String[] names, Object[] values, String delimiter) {
 		return unpackValues(names, values, delimiter, false);
 	}
 	/**
 	 * Unpacks the given values and creates their String representations.
 	 * The names and values are separated by the specified delimiter and the
 	 * values are expanded and analyzed recursively, if specified.
 	 * 
 	 * @param names java.lang.String[]
 	 * @param values java.lang.Object[]
 	 * @param delimiter String
 	 * @param expand boolean
 	 * @return java.lang.String
 	 */
 	public static String unpackValues(
 		String[] names,
 		Object[] values,
 		String delimiter,
 		boolean expand) {
 		StringBuffer result = new StringBuffer();
 		for (int i = 0; i < values.length; i++) {
 			result.append("    ");
 			result.append(names[i]);
 			result.append(delimiter);
 			result.append(" ");
 			result.append(unpackReturnValue(values[i], "      ", 0, expand));
 			result.append("\n");
 		}
 		return result.toString();
 	}
 }