/*
    * Copyright 2010 Philipp Erlacher
    *
    * 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 org.exolab.castor.xml;
  
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.List;
  import java.util.Locale;
  import java.util.ResourceBundle;
  import java.util.StringTokenizer;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.exolab.castor.mapping.FieldHandler;
  import org.exolab.castor.mapping.MapItem;
  import org.exolab.castor.xml.UnmarshalHandler.ArrayHandler;
  import org.exolab.castor.xml.util.XMLFieldDescriptorImpl;
  import org.xml.sax.ContentHandler;
  import org.xml.sax.SAXException;
  
  /**
   * A processor that assists {@link UnmarshalHandler} in dealing with the SAX 2
   * {@link ContentHandler#endElement(String, String, String)} callback method.
   * 
   * @author <a href=" mailto:philipp.erlacher AT gmail DOT com">Philipp Erlacher</a>
   * @since 1.3.2
   */
  public class EndElementProcessor {
  
    /**
     * Standard logger to use.
     */
    private static final Log LOG = LogFactory.getLog(EndElementProcessor.class);
  
    /**
     * resource bundle
     */
    protected static ResourceBundle resourceBundle;
  
    /**
     * Callback {@link UnmarshalHandler} reference to set the actual state on this instance.
     */
    private final UnmarshalHandler _unmarshalHandler;
  
    static {
      resourceBundle = ResourceBundle.getBundle("UnmarshalHandlerMessages", Locale.getDefault());
    }
  
    /**
     * Creates an instance of this class, with a reference to the actual {@link UnmarshalHandler} for
     * which this processor deals with the SAX 2 endElement() callback method.
     * 
     * @param unmarshalHandler The {@link UnmarshalHandler} instance on which the results of
     *        processing the endElement method will be 'persisted'/set.
     */
    public EndElementProcessor(final UnmarshalHandler unmarshalHandler) {
      _unmarshalHandler = unmarshalHandler;
    }
  
    public void compute(String name) throws org.xml.sax.SAXException {
      if (LOG.isTraceEnabled()) {
        String trace = MessageFormat.format(
            resourceBundle.getString("unmarshalHandler.log.trace.endElement"), new Object[] {name});
        LOG.trace(trace);
      }
  
      // -- If we are skipping elements that have appeared in the XML but for
      // -- which we have no mapping, decrease the ignore depth counter and
      // return
      if (_unmarshalHandler.getStrictElementHandler().skipEndElement()) {
        return;
      }
  
      // -- Do delagation if necessary
      if (_unmarshalHandler.getAnyNodeHandler().hasAnyUnmarshaller()) {
        _unmarshalHandler.getAnyNodeHandler().endElement(name);
        // we are back to the starting node
        if (_unmarshalHandler.getAnyNodeHandler().isStartingNode()) {
          _unmarshalHandler.setAnyNode(_unmarshalHandler.getAnyNodeHandler().getStartingNode());
        } else
          return;
      }
  
      if (_unmarshalHandler.getStateStack().isEmpty()) {
        String err = MessageFormat.format(
           resourceBundle.getString("unmarshalHandler.error.missing.startElement"),
           new Object[] {name});
       throw new SAXException(err);
     }
 
     // -- * Begin Namespace Handling
     // -- XXX Note: This code will change when we update the XML event API
 
     int idx = name.indexOf(':');
     if (idx >= 0) {
       name = name.substring(idx + 1);
     }
     // -- * End Namespace Handling
 
     UnmarshalState state = _unmarshalHandler.getStateStack().removeLastState();
 
     // -- make sure we have the correct closing tag
     XMLFieldDescriptor descriptor = state.getFieldDescriptor();
 
     if (!state.getElementName().equals(name)) {
 
       // maybe there is still a container to end
       if (descriptor.isContainer()) {
         _unmarshalHandler.getStateStack().pushState(state);
         // -- check for possible characters added to
         // -- the container's state that should
         // -- really belong to the parent state
         StringBuffer tmpBuffer = null;
         if (state.getBuffer() != null) {
           if (!UnmarshalHandler.isWhitespace(state.getBuffer())) {
             if (state.getClassDescriptor().getContentDescriptor() == null) {
               tmpBuffer = state.getBuffer();
               state.setBuffer(null);
             }
           }
         }
         // -- end container
         _unmarshalHandler.endElement(state.getElementName());
 
         if (tmpBuffer != null) {
           state = _unmarshalHandler.getStateStack().getLastState();
           if (state.getBuffer() == null)
             state.setBuffer(tmpBuffer);
           else
             state.getBuffer().append(tmpBuffer.toString());
         }
         _unmarshalHandler.endElement(name);
         return;
       }
       String err = MessageFormat.format(
           resourceBundle.getString("unmarshalHandler.error.different.endElement.expected"),
           new Object[] {state.getElementName(), name});
       throw new SAXException(err);
     }
 
     // -- clean up current Object
     Class<?> type = state.getType();
 
     if (type == null) {
       if (!state.isWrapper()) {
         // -- this message will only show up if debug
         // -- is turned on...how should we handle this case?
         // -- should it be a fatal error?
         String info = MessageFormat.format(
             resourceBundle.getString("unmarshalHandler.log.info.no.Descriptor.found"),
             new Object[] {state.getElementName()});
         LOG.info(info);
       }
 
       // -- handle possible location text content
       // -- TODO: cleanup location path support.
       // -- the following code needs to be improved as
       // -- for searching descriptors in this manner can
       // -- be slow
       StringBuffer tmpBuffer = null;
       if (state.getBuffer() != null) {
         if (!UnmarshalHandler.isWhitespace(state.getBuffer())) {
           tmpBuffer = state.getBuffer();
           state.setBuffer(null);
         }
       }
       if (tmpBuffer != null) {
         UnmarshalState targetState = state;
         String locPath = targetState.getElementName();
         while ((targetState = targetState.getParent()) != null) {
           if ((targetState.isWrapper()) || (targetState.getClassDescriptor() == null)) {
             locPath = targetState.getElementName() + "/" + locPath;
             continue;
           }
 
           XMLFieldDescriptor tmpDesc = targetState.getClassDescriptor().getContentDescriptor();
           if (tmpDesc != null && locPath.equals(tmpDesc.getLocationPath())) {
             if (targetState.getBuffer() == null)
               targetState.setBuffer(tmpBuffer);
             else
               targetState.getBuffer().append(tmpBuffer.toString());
           }
         }
       }
 
       // -- remove current namespace scoping
       _unmarshalHandler.getNamespaceHandling().removeCurrentNamespaceInstance();
       return;
     }
 
     // -- check for special cases
     boolean byteArray = false;
     if (type.isArray()) {
       byteArray = (type.getComponentType() == Byte.TYPE);
     }
 
     // -- If we don't have an instance object and the Class type
     // -- is not a primitive or a byte[] we must simply return
     if ((state.getObject() == null) && (!state.isPrimitiveOrImmutable())) {
       // -- remove current namespace scoping
       _unmarshalHandler.getNamespaceHandling().removeCurrentNamespaceInstance();
       return;
     }
 
     // / DEBUG System.out.println("end: " + name);
 
     if (state.isPrimitiveOrImmutable()) {
 
       String str = null;
 
       if (state.getBuffer() != null) {
         str = state.getBuffer().toString();
         state.getBuffer().setLength(0);
       }
 
       if (type == String.class && !((XMLFieldDescriptorImpl) descriptor).isDerivedFromXSList()) {
         if (str != null)
           state.setObject(str);
         else if (state.isNil()) {
           state.setObject(null);
         } else {
           state.setObject("");
         }
       }
       // -- special handling for byte[]
       else if (byteArray && !descriptor.isDerivedFromXSList()) {
         if (str == null)
           state.setObject(new byte[0]);
         else {
           state.setObject(_unmarshalHandler.decodeBinaryData(descriptor, str));
         }
       } else if (state.getConstructorArguments() != null) {
         state.setObject(
             _unmarshalHandler.createInstance(state.getType(), state.getConstructorArguments()));
       } else if (descriptor.isMultivalued() && descriptor.getSchemaType() != null
           && descriptor.getSchemaType().equals("list")
           && ((XMLFieldDescriptorImpl) descriptor).isDerivedFromXSList()) {
         StringTokenizer attrValueTokenizer = new StringTokenizer(str);
         List<Object> primitives = new ArrayList<Object>();
         while (attrValueTokenizer.hasMoreTokens()) {
           String tokenValue = attrValueTokenizer.nextToken();
           if (MarshalFramework.isPrimitive(descriptor.getFieldType())) {
             primitives.add(
                 _unmarshalHandler.toPrimitiveObject(type, tokenValue, state.getFieldDescriptor()));
           } else {
             Class<?> valueType = descriptor.getFieldType();
             // -- handle base64/hexBinary
             if (valueType.isArray() && (valueType.getComponentType() == Byte.TYPE)) {
               primitives.add(_unmarshalHandler.decodeBinaryData(descriptor, tokenValue));
             }
           }
 
         }
         state.setObject(primitives);
       } else {
         if (state.isNil()) {
           state.setObject(null);
         } else {
           state.setObject(
               _unmarshalHandler.toPrimitiveObject(type, str, state.getFieldDescriptor()));
         }
       }
     } else if (ArrayHandler.class.isAssignableFrom(state.getType())) {
       state.setObject(((ArrayHandler) state.getObject()).getObject());
       state.setType(state.getObject().getClass());
 
     }
 
     // -- check for character content
     if ((state.getBuffer() != null) && (state.getBuffer().length() > 0)
         && (state.getClassDescriptor() != null)) {
       XMLFieldDescriptor cdesc = state.getClassDescriptor().getContentDescriptor();
       if (cdesc != null) {
         Object value = state.getBuffer().toString();
         if (MarshalFramework.isPrimitive(cdesc.getFieldType()))
           value = _unmarshalHandler.toPrimitiveObject(cdesc.getFieldType(), (String) value,
               state.getFieldDescriptor());
         else {
           Class<?> valueType = cdesc.getFieldType();
           // -- handle base64/hexBinary
           if (valueType.isArray() && (valueType.getComponentType() == Byte.TYPE)) {
             value = _unmarshalHandler.decodeBinaryData(descriptor, (String) value);
           }
         }
 
         try {
           FieldHandler handler = cdesc.getHandler();
           boolean addObject = true;
           if (_unmarshalHandler.isReuseObjects()) {
             // -- check to see if we need to
             // -- add the object or not
             Object tmp = handler.getValue(state.getObject());
             if (tmp != null) {
               // -- Do not add object if values
               // -- are equal
               addObject = (!tmp.equals(value));
             }
           }
           if (addObject)
             handler.setValue(state.getObject(), value);
         } catch (java.lang.IllegalStateException ise) {
           String err = MessageFormat.format(
               resourceBundle.getString("unmarshalHandler.error.unable.add.text"),
               new Object[] {descriptor.getXMLName(), ise.toString()});
           throw new SAXException(err, ise);
         }
       }
       // -- Handle references
       else if (descriptor.isReference()) {
         UnmarshalState pState = _unmarshalHandler.getStateStack().getLastState();
         _unmarshalHandler.processIDREF(state.getBuffer().toString(), descriptor,
             pState.getObject());
         _unmarshalHandler.getNamespaceHandling().removeCurrentNamespaceInstance();
         return;
       } else {
         // -- check for non-whitespace...and report error
         if (!UnmarshalHandler.isWhitespace(state.getBuffer())) {
           String err =
               MessageFormat.format(resourceBundle.getString("unmarshalHandler.error.illegal.text"),
                   new Object[] {name, state.getBuffer()});
           throw new SAXException(err);
         }
       }
     }
 
     // -- We're finished processing the object, so notify the
     // -- Listener (if any).
     Object stateObject = state.getObject();
     Object parentObject = (state.getParent() == null) ? null : state.getParent().getObject();
     _unmarshalHandler.getDelegateUnmarshalListener().unmarshalled(stateObject, parentObject);
 
     // -- if we are at root....just validate and we are done
     if (_unmarshalHandler.getStateStack().isEmpty()) {
       if (_unmarshalHandler.isValidating()) {
         ValidationException first = null;
         ValidationException last = null;
 
         // -- check unresolved references
         if (_unmarshalHandler.getResolveTable() != null
             && !_unmarshalHandler.getInternalContext().getLenientIdValidation()) {
           Enumeration enumeration = _unmarshalHandler.getResolveTable().keys();
           while (enumeration.hasMoreElements()) {
             Object ref = enumeration.nextElement();
             // if
             // (ref.toString().startsWith(MapItem.class.getName()))
             // continue;
             String msg = "unable to resolve reference: " + ref;
             if (first == null) {
               first = new ValidationException(msg);
               last = first;
             } else {
               last.setNext(new ValidationException(msg));
               last = last.getNext();
             }
           }
         }
         try {
           Validator validator = new Validator();
           ValidationContext context = new ValidationContext();
           context.setInternalContext(_unmarshalHandler.getInternalContext());
           validator.validate(state.getObject(), context);
           if (!_unmarshalHandler.getInternalContext().getLenientIdValidation()) {
             validator.checkUnresolvedIdrefs(context);
           }
           context.cleanup();
         } catch (ValidationException vEx) {
           if (first == null)
             first = vEx;
           else
             last.setNext(vEx);
         }
         if (first != null) {
           throw new SAXException(first);
         }
       }
       return;
     }
 
     // -- Add object to parent if necessary
 
     if (descriptor.isIncremental()) {
       // -- remove current namespace scoping
       _unmarshalHandler.getNamespaceHandling().removeCurrentNamespaceInstance();
       return; // -- already added
     }
 
     Object val = state.getObject();
 
     // --special code for AnyNode handling
     if (_unmarshalHandler.getAnyNode() != null) {
       val = _unmarshalHandler.getAnyNode();
       _unmarshalHandler.setAnyNode(null);
     }
 
     // -- save fieldState
     UnmarshalState fieldState = state;
 
     // -- have we seen this object before?
     boolean firstOccurance = false;
 
     // -- get target object
     state = _unmarshalHandler.getStateStack().getLastState();
     if (state.isWrapper()) {
       state = fieldState.getTargetState();
     }
 
     // -- check to see if we have already read in
     // -- an element of this type.
     // -- (Q: if we have a container, do we possibly need to
     // -- also check the container's multivalued status?)
     if (!descriptor.isMultivalued()) {
 
       if (state.isUsed(descriptor)) {
 
         String location = name;
         while (!_unmarshalHandler.getStateStack().isEmpty()) {
           UnmarshalState tmpState = _unmarshalHandler.getStateStack().removeLastState();
           if (!tmpState.isWrapper()) {
             if (tmpState.getFieldDescriptor().isContainer())
               continue;
           }
           location = state.getElementName() + "/" + location;
         }
 
         String err = MessageFormat.format(
             resourceBundle.getString("unmarshalHandler.error.element.occurs.more.than.once"),
             new Object[] {name, state.getType().getName(), location});
 
         ValidationException vx = new ValidationException(err);
 
         throw new SAXException(vx);
       }
       state.markAsUsed(descriptor);
       // -- if this is the identity then save id
       if (state.getClassDescriptor().getIdentity() == descriptor) {
         state.setKey(val);
       }
     } else {
       // -- check occurance of descriptor
       if (!state.isUsed(descriptor)) {
         firstOccurance = true;
       }
 
       // -- record usage of descriptor
       state.markAsUsed(descriptor);
     }
 
     try {
       FieldHandler handler = descriptor.getHandler();
       // check if the value is a QName that needs to
       // be resolved (ns:value -> {URI}value)
       String valueType = descriptor.getSchemaType();
       if ((valueType != null) && (valueType.equals(MarshalFramework.QNAME_NAME))) {
         val = _unmarshalHandler.getNamespaceHandling().resolveNamespace(val);
       }
 
       boolean addObject = true;
       if (_unmarshalHandler.isReuseObjects() && fieldState.isPrimitiveOrImmutable()) {
         // -- check to see if we need to
         // -- add the object or not
         Object tmp = handler.getValue(state.getObject());
         if (tmp != null) {
           // -- Do not add object if values
           // -- are equal
           addObject = (!tmp.equals(val));
         }
       }
 
       // -- special handling for mapped objects
       if (descriptor.isMapped()) {
         if (!(val instanceof MapItem)) {
           MapItem mapItem = new MapItem(fieldState.getKey(), val);
           val = mapItem;
         } else {
           // -- make sure value exists (could be a reference)
           MapItem mapItem = (MapItem) val;
           if (mapItem.getValue() == null) {
             // -- save for later...
             addObject = false;
             _unmarshalHandler.addReference(mapItem.toString(), state.getObject(), descriptor);
           }
         }
       }
 
       if (addObject) {
         // -- clear any collections if necessary
         if (firstOccurance && _unmarshalHandler.isClearCollections()) {
           handler.resetValue(state.getObject());
         }
 
         if (descriptor.isMultivalued() && descriptor.getSchemaType() != null
             && descriptor.getSchemaType().equals("list")
             && ((XMLFieldDescriptorImpl) descriptor).isDerivedFromXSList()) {
           List<Object> values = (List<Object>) val;
           for (Object value : values) {
             // -- finally set the value!!
             handler.setValue(state.getObject(), value);
 
             // If there is a parent for this object, pass along
             // a notification that we've finished adding a child
             _unmarshalHandler.getDelegateUnmarshalListener().fieldAdded(descriptor.getFieldName(),
                 state.getObject(), fieldState.getObject());
           }
         } else {
 
           // -- finally set the value!!
           handler.setValue(state.getObject(), val);
 
           // If there is a parent for this object, pass along
           // a notification that we've finished adding a child
           _unmarshalHandler.getDelegateUnmarshalListener().fieldAdded(descriptor.getFieldName(),
               state.getObject(), fieldState.getObject());
         }
       }
 
     }
     /*
      * catch(java.lang.reflect.InvocationTargetException itx) {
      * 
      * Throwable toss = itx.getTargetException(); if (toss == null) toss = itx;
      * 
      * String err = "unable to add '" + name + "' to <"; err += state.descriptor.getXMLName(); err
      * += "> due to the following exception: " + toss; throw new SAXException(err); }
      */
     catch (Exception ex) {
       StringWriter sw = new StringWriter();
       PrintWriter pw = new PrintWriter(sw);
       ex.printStackTrace(pw);
       pw.flush();
       String err = MessageFormat.format(
           resourceBundle.getString("unmarshalHandler.error.unable.add.element"),
           new Object[] {name, state.getFieldDescriptor().getXMLName(), sw.toString()});
       throw new SAXException(err, ex);
     }
 
     // -- remove current namespace scoping
     _unmarshalHandler.getNamespaceHandling().removeCurrentNamespaceInstance();
 
     // remove additional (artifical aka container) state introduced for
     // single-valued (iow maxOccurs="1") choices.
     if (state.getFieldDescriptor().isContainer() && state.getClassDescriptor().isChoice()
         && !state.getFieldDescriptor().isMultivalued()) {
       _unmarshalHandler.endElement(state.getElementName());
     }
 
   }
 }