/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems;
  
  import java.io.IOException;
  import java.io.ObjectStreamField;
  import java.io.Writer;
  import java.lang.reflect.Array;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.LinkedHashMap;
  import java.util.LinkedHashSet;
  import java.util.Map;
  import java.util.SortedMap;
  import java.util.SortedSet;
  import java.util.TreeMap;
  import java.util.Vector;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * XML Serializer.
   * <p>
   * The main use of this class is to obtain a human-readable representation of
   * a set of objects, for debugging, tests, etc.
   * 
   * <h3>Usage</h3>
   *
   * <pre>
   *   java.io.Writer writer = ...;
   *   GridXMLSerializer ser = new GridXMLSerializer(writer);
   *   try {
   *     ser.begin();
   *     ser.write(obj1);
   *     ser.write(obj2);
   *     ...
   *     ser.end();
   *   } finally {
   *     writer.close();
   *   }
   * </pre>
   *
   * For each object, the serialization works as follows:
   *
   * <ol>
   *   <li>If a static field is found with the following structure:
   *       <pre>
   *         private static final ObjectStreamField[] xmlPersistentFields = {
   *           new ObjectStreamField("myField", myClass.class)
   *         };
   *       </pre>
   *       Only the specified fields in this array will be serialized.</li>
   *   <li>Otherwise, all non-static fields will be serialized, including
   *       those from ancestor classes.</li>
   * </ol>
   *
   * @author Gaston Freire Amoedo
   * @author Rodrigo Ruiz
   * @version 2.0
   */
  public class GridXMLSerializer {
  
    /**
     * Class logger.
     */
    private static Log log = LogFactory.getLog(GridXMLSerializer.class);
  
    /**
     * XML Indentation prefix.
     */
    private static final String SPACER = "  ";
  
    /**
     * Target writer for output.
     */
    private Writer outWriter = null;
  
    /**
     * Creates a new instance.
    *
    * @param output Writer to write to
    */
   public GridXMLSerializer(Writer output) {
     outWriter = output;
 
     log.debug("New GridXMLSerializer created");
   }
 
 
   /**
    * Starts serialization, generating the appropriate XML headers.
    *
    * @throws IOException If an I/O error occurs writing to the writer
    */
   public void begin() throws IOException {
     outWriter.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
     outWriter.write("<main>\n");
 
     log.debug("Serialization started");
   }
 
 
   /**
    * Termina la serializacion, generando el cierre de las cabeceras XML correspondientes
    * Despues de esta operacion se recomienda hacer flush() y close() del writer.
    *
    * @throws IOException If an I/O error occurs writing to the writer
    */
   public void end() throws IOException {
     outWriter.write("</main>\n");
 
     log.debug("Serialization ended");
   }
 
   /**
    * Serializa en XML el objeto pasado por parametro.
    *
    * @param obj objeto a serializar en XML
    * @param excluded para excluir arboles xml que contengan esta palabra,
    *                ya sea en el nodo raiz como en alguno de sus nodos
    *                hijos (con un nivel de profundidad como maximo)
    *
    * @throws IOException If an I/O error occurs writing to the writer
   */
   public void write(Object obj, String excluded) throws IOException {
     outWriter.write(serialize(obj, SPACER, excluded));
   }
 
   /**
    * Serializa en XML el objeto pasado por parametro.
    *
    * @param obj objeto a serializar en XML
    *
    * @throws IOException If an I/O error occurs writing to the writer
    */
   public void write(Object obj) throws IOException {
     outWriter.write(serialize(obj, SPACER, null));
   }
 
 
   /**
    * Obtiene las super clases de una dada (excepto java.lang.Object).
    *
    * @param origin clase origen (hija)
    * @return array de clases, con origin en [0]
    */
   private static Class[] getSuperClasses(Class origin) {
 
     log.debug("getting super classes of " + origin.getName());
 
     if (origin == Object.class) {
       // origin no tiene superclases
       return new Class[0];
     }
     // Cuenta el numero de superclases (excepto Object)
     Class aux = origin;
     int classDepth = 0;
     do {
       classDepth++;
       aux = aux.getSuperclass();
     } while (aux != Object.class);
     // Almacena las superclases en un array
     Class[] superClasses = new Class[classDepth];
     aux = origin;
     int i = 0;
     do {
       superClasses[i++] = aux;
       aux = aux.getSuperclass();
     } while (aux != Object.class);
 
     log.debug("super classes of " + origin.getName() + " got successfully");
 
     return superClasses;
   }
 
 
   /**
    * Devuelve todos los campos del objeto a convertir a XML.
    * Si la clase del objeto tiene una variable
    *   private static final ObjectStreamField[] xmlPersistentFields
    * toma de ella la lista de campos que deben convertirse a XML
    * En caso contrario, toma todos los campos excepto los estaticos
    *
    * @param obj objeto del que queremos obtener la lista de campos a convertir a XML
    * @return array con los campos obtenidos
    */
   private static Field[] getFields(Object obj) {
     Class origin = obj.getClass();
     Field[] fieldsArray;
     Vector<Field> fieldsVector = new Vector<Field>();
     ObjectStreamField[] xmlFields = null;
     Class[] superClasses = getSuperClasses(origin);
     boolean includeField;
 
     log.debug("getting serializable fields from " + origin.getName());
 
     // Busca una declaracion de campos persistentes para xml
     try {
       Field specialField = origin.getDeclaredField("xmlPersistentFields");
       specialField.setAccessible(true);
       xmlFields = (ObjectStreamField[]) specialField.get(obj);
     } catch (NoSuchFieldException e) {
       // El campo no existe, todos los campos se convierten a XML
     } catch (IllegalAccessException e) {
       // No se producira por el Field.setAccessible
     }
     // Recorre la cadena de clases obteniendo sus campos
     for (int i = 0; i < superClasses.length; i++) {
       fieldsArray = superClasses[i].getDeclaredFields();
       // Filtra fieldsArray para que contenga solo los campos deseados
       for (int j = 0; j < fieldsArray.length; j++) {
         // Determina si hay que convertir el campo a XML
         if (xmlFields == null) {
           includeField = !Modifier.isStatic(fieldsArray[j].getModifiers());
         } else {
           includeField = false;
           for (int k = 0; k < xmlFields.length; k++) {
             if (fieldsArray[j].getName().equals(xmlFields[k].getName())) {
               includeField = true;
             }
           }
         }
         if (includeField) {
           fieldsVector.add(fieldsArray[j]);
         }
       }
     }
     // Junta todos los campos obtenidos
     fieldsArray = new Field[fieldsVector.size()];
     fieldsVector.copyInto(fieldsArray);
     //Java 1.2 security MAGIC! para evitar IllegalAccessException
     Arrays.sort(fieldsArray, new Comparator<Field>() {
       public int compare(Field f1, Field f2) {
         String n1 = (f1 == null) ? null : f1.getName();
         String n2 = (f2 == null) ? null : f2.getName();
         if (n1 == null) {
           return -1;
         } else if (n2 == null) {
           return 1;
         } else {
           return n1.compareTo(n2);
         }
       }
     });
     Field.setAccessible(fieldsArray, true);
 
     log.debug("serializable fields from " + origin.getName() + " got successfully");
 
     return fieldsArray;
   }
 
   /**
    * @param c Class to check
    * @return true if the class is a basic type, false otherwise
    */
   private static boolean isBasicType(Class c) {
     if (Number.class.isAssignableFrom(c) || CharSequence.class.isAssignableFrom(c)) {
       return true;
     } else if (c == Boolean.class || c == Character.class) {
       return true;
     }
     return false;
   }
 
   /**
    * Indirect recursion serialization through <tt>serializeField</tt>.
    *
    * @param obj Object to serialize
    * @param indent XML indentation prefix
    * @param excluded XML trees containing this word are excluded (with a maximum
    *                 depth level of one)
    * @return cadena con el objeto serializado en XML
    */
   private static String serialize(Object obj, String indent, String excluded) {
     StringBuffer output = new StringBuffer();
     Class objectClass = obj.getClass();
 
     log.debug("starting serialization of object from class " + objectClass.getName());
 
     output.append(indent);
     output.append("<object class=\"");
     // Si la clase es array debe indicar el tipo de sus componentes
     if (objectClass.isArray()) {
       output.append("Array\" componentType=\"");
       if (objectClass.getComponentType().isArray()) {
         output.append("Array");
       } else {
         output.append(objectClass.getComponentType().getName());
       }
     } else {
       output.append(objectClass.getName());
     }
     output.append("\">");
 
     // El comportamiento varia en funcion de la clase del objeto
     if (isBasicType(objectClass)) {
       // El objeto es un wrapper, un String o una clase numerica
       output.append(encodeXML(obj.toString()));
       output.append("</object>\n");
     } else {
       // Hay que "desglosar" el objeto
       output.append("\n");
       if (objectClass.isArray()) {
         serializeArray(obj, indent, excluded, output, objectClass);
       } else {
         //superClasses = getSuperClasses(objectClass);
         //rootClass = superClasses[superClasses.length - 1];
         if (obj instanceof Collection) {
           serializeCollection((Collection)obj, indent, excluded, output);
         } else if (obj instanceof Map) {
           serializeMap((Map)obj, indent, excluded, output);
         } else {
           serializeObject(obj, indent, excluded, output);
         }
       }
       output.append(indent);
       output.append("</object>\n");
     }
 
     log.debug("serialization of object from class " + objectClass.getName()
                + " successfully");
 
     return output.toString();
   }
 
 
   /**
    * @param obj object to serialize
    * @param indent indentation
    * @param excluded excluded elements
    * @param output StringBuffer to write to
    * @param objectClass object class
    */
   private static void serializeArray(Object obj, String indent, String excluded,
                                      StringBuffer output, Class objectClass) {
     Object item;
     boolean exclude = false;
     // El objeto es un array: hay que mostrar sus componentes
     // Determina si el tipo de los componentes es primitivo (caso especial)
     log.debug("serializing array...");
     if (objectClass.getComponentType().isPrimitive()) {
       // Comprobamos que ningun componente del array sea la cadena a excluir
       for (int i = 0; i < Array.getLength(obj); i++) {
         item = Array.get(obj, i);
         if (item.toString().equalsIgnoreCase(excluded)) {
           exclude = true;
           break;
         }
       }
       if (!exclude) {
         for (int i = 0; i < Array.getLength(obj); i++) {
           item = Array.get(obj, i);
           output.append(indent + SPACER);
           output.append("<arrayItem index=\"");
           output.append(i);
           output.append("\">");
           output.append(encodeXML(item.toString()));
           output.append("</arrayItem>\n");
         }
       }
     } else {
       for (int i = 0; i < Array.getLength(obj); i++) {
         item = Array.get(obj, i);
         output.append(indent + SPACER);
         output.append("<arrayItem index=\"");
         output.append(i);
         output.append("\">\n");
         if (item != null) {
           output.append(serialize(item, indent + SPACER + SPACER, excluded));
         }
         output.append(indent + SPACER);
         output.append("</arrayItem>\n");
       }
     }
     log.debug("...array serialized");
   }
 
 
   /**
    * @param obj the object to serialize
    * @param indent indentation
    * @param excluded excluded elements
    * @param output StringBuffer to write to
    */
   private static void serializeObject(Object obj, String indent, String excluded,
                                       StringBuffer output) {
 
     log.debug("serializing " + obj.getClass().getName() + "...");
 
     Field[] fields = getFields(obj);
     // Check the instance for exclusion
     for (int i = 0; i < fields.length; i++) {
       if (fields[i].getType().isPrimitive() && fields[i].toString().equals(excluded)) {
         log.debug("...object not serialized. Excluded because it has a "
             + excluded + " component");
         return;
       }
     }
 
     for (int i = 0; i < fields.length; i++) {
       output.append(serializeField(obj, fields[i], indent + SPACER, excluded));
     }
   }
 
 
   /**
    * @param map the map to serialize
    * @param indent indentation
    * @param excluded excluded elements
    * @param output StringBuffer to write to
    */
   private static void serializeMap(Map map, String indent, String excluded,
                                    StringBuffer output) {
     Object item;
     // El objeto es un "mapeo": hay que mostrar la relacion clave-valor
     log.debug("serializing map...");
 
     if (excluded != null) {
       if (map.containsKey(excluded) || map.containsValue(excluded)) {
         log.debug("...map not serialized. Excluded because it has a "
             + excluded + " component");
         return;
       }
     }
 
     // Store the keys in a sorted set to facilitate later comparisons
     Map sorted = sort(map);
 
     final String spacer = indent + "      ";
 
     for (Object key : sorted.keySet()) {
       Map myMap = (Map) map;
       item = myMap.get(key);
       output.append(indent).append("  <mapItem>\n");
       output.append(indent).append("    <key>\n");
       output.append(serialize(key, spacer, excluded));
       output.append(indent).append("    </key>\n");
       if (item != null) {
         output.append(indent).append("    <value>\n");
         output.append(serialize(item, spacer, excluded));
         output.append(indent).append("    </value>\n");
       }
       output.append(indent).append("  </mapItem>\n");
     }
     log.debug("...map serialized");
   }
 
 
   /**
    * @param col the Collection to serialize
    * @param indent the indentation
    * @param excluded excluded elements
    * @param output the StringBuffer to write to
    */
   private static void serializeCollection(Collection col,
     String indent, String excluded, StringBuffer output) {
 
     // El objeto es una coleccion: hay que mostrar sus elementos, si no
     // contiene ningun elemento de tipo String con valor igual al excluido
     log.debug("serializing collection...");
 
     // Filter instances containing 'excluded'
     if (excluded != null && col.contains(excluded)) {
       log.debug("...collection not serialized. Excluded because it has a "
           + excluded + " component");
       return;
     }
 
     // Sort "unsorted" collections to allow easier comparisons
     Collection sorted = sort(col);
     for (Object item : sorted) {
       if (item != null) {
         output.append(indent).append(SPACER).append("<collectionItem>\n");
         output.append(serialize(item, indent + SPACER + SPACER, excluded));
         output.append(indent).append(SPACER).append("</collectionItem>\n");
       }
     }
     log.debug("...collection serialized");
   }
 
 
   /**
    * Serializa un campo de un objeto.
    * Realiza la recursion si no es un tipo primitivo
    *
    * @param obj Objeto propietario del campo
    * @param classField campo a serializar
    * @param indent cadena de indentacion a emplear
    * @param excluded para excluir arboles xml que contengan esta palabra,
    *                ya sea en el nodo raiz como en alguno de sus nodos
    *                hijos (con un nivel de profundidad como maximo)
    * @return cadena con el campo serializado
    */
   private static String serializeField(Object obj, Field classField,
     String indent, String excluded) {
 
 
     log.debug("starting serialization of field " + classField.getName()
               + " from class " + obj.getClass().getName());
 
     StringBuffer output = new StringBuffer();
     try {
       Object field = classField.get(obj);
 
       output.append(indent).append("<field name=\"");
       output.append(classField.getName());
       if (field != null && classField.getType().isPrimitive()) {
         output.append("\" type=\"");
         output.append(classField.getType().getName());
       }
       output.append("\">");
 
       if (field == null) {
         output.append("</field>\n");
       } else if (classField.getType().isPrimitive()) {
         output.append(encodeXML(field.toString()) + "</field>\n");
       } else {
         output.append("\n");
         output.append(serialize(field, indent + SPACER, excluded));
         output.append(indent).append("</field>\n");
       }
 
       log.debug("serialization of field " + classField.getName()
                 + " from class " + obj.getClass().getName() + " successful");
     } catch (IllegalAccessException e) {
       log.error("Field " + obj.getClass().getName()
         + "#" + classField.getName() + " not available.");
     }
     return output.toString();
   }
 
 
 
   /**
    * Codifica los caracteres susceptibles de confundir el codigo xml.
    *
    * @param in Cadena con los caracteres a sustituir
    *
    * @return a String containing the encoded data
    */
   public static String encodeXML(String in) {
     StringBuffer out = new StringBuffer(in.length());
     for (int i = 0; i < in.length(); i++) {
       char c = in.charAt(i);
       switch (c) {
         case '&':
           out.append("&amp;");
           break;
         case '<':
           out.append("&lt;");
           break;
         case '>':
           out.append("&gt;");
           break;
         case '\'':
           out.append("&apos;");
           break;
         case '"':
           out.append("&quot;");
           break;
         default:
           out.append(c);
       }
     }
     return out.toString();
   }
 
   /**
    * Tries to sort the elements in a list, assuming they are Comparable.
    *
    * @param c The elements to sort.
    *
    * @return The ordered list (if no exception was thrown
    * when trying to compare the elements) or the original one (if an exception
    * did made the sorting impossible.
    */
   @SuppressWarnings("unchecked")
   private static Collection sort(Collection c) {
     try {
       if (c instanceof SortedSet || c instanceof LinkedHashSet) {
         return c;
       } else {
         ArrayList list = new ArrayList(c);
         Collections.sort(list);
         return list;
       }
     } catch (Throwable t) {
       // We do not want to throw any kind of error from here.
       return c;
     }
   }
 
   /**
    * Sorts a map, if it is possible.
    * <p>
    * If the map is "sorted" it returns map itself. If not, it tries to
    * create a TreeMap and fill it with the contents of map.
    * <p>
    * If an error occurs, the original map instance is returned
    *
    * @param map The map to be sorted
    * @return A sorted instance with the same contents as map
    */
   @SuppressWarnings("unchecked")
   private static Map sort(Map map) {
     try {
       if (map instanceof SortedMap || map instanceof LinkedHashMap) {
         return map;
       } else {
         return new TreeMap(map);
       }
     } catch (Exception e) {
       return map;
     }
   }
 }