/*
    * Copyright 2005-2010 the original author or authors.
    *
    * 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.springframework.ws.server.endpoint.adapter.method;
  
  import java.io.ByteArrayInputStream;
  import javax.xml.stream.Location;
  import javax.xml.stream.XMLInputFactory;
  import javax.xml.stream.XMLStreamException;
  import javax.xml.stream.XMLStreamReader;
  import javax.xml.stream.util.StreamReaderDelegate;
  import javax.xml.transform.Source;
  import javax.xml.transform.dom.DOMResult;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.sax.SAXSource;
  import javax.xml.transform.stax.StAXSource;
  import javax.xml.transform.stream.StreamSource;
  
  import org.springframework.core.MethodParameter;
  import org.springframework.xml.JaxpVersion;
  
  import org.w3c.dom.Document;
  import org.w3c.dom.Node;
  import org.xml.sax.InputSource;
  
  /**
   * Implementation of {@link MethodArgumentResolver} and {@link MethodReturnValueHandler} that supports {@link Source}
   * objects.
   *
   * @author Arjen Poutsma
   * @since 2.0
   */
  public class SourcePayloadMethodProcessor extends AbstractPayloadSourceMethodProcessor {
  
      private XMLInputFactory inputFactory = createXmlInputFactory();
  
      // MethodArgumentResolver
  
      @Override
      protected boolean supportsRequestPayloadParameter(MethodParameter parameter) {
          return supports(parameter);
      }
  
      @Override
      protected Source resolveRequestPayloadArgument(MethodParameter parameter, Source requestPayload) throws Exception {
          Class<?> parameterType = parameter.getParameterType();
          if (parameterType.isAssignableFrom(requestPayload.getClass())) {
              return requestPayload;
          }
          if (DOMSource.class.isAssignableFrom(parameterType)) {
              DOMResult domResult = new DOMResult();
              transform(requestPayload, domResult);
              Node node = domResult.getNode();
              if (node.getNodeType() == Node.DOCUMENT_NODE) {
                  return new DOMSource(((Document) node).getDocumentElement());
              }
              else {
                  return new DOMSource(domResult.getNode());
              }
          }
          else if (SAXSource.class.isAssignableFrom(parameterType)) {
              ByteArrayInputStream bis = convertToByteArrayInputStream(requestPayload);
              InputSource inputSource = new InputSource(bis);
              return new SAXSource(inputSource);
          }
          else if (StreamSource.class.isAssignableFrom(parameterType)) {
              ByteArrayInputStream bis = convertToByteArrayInputStream(requestPayload);
              return new StreamSource(bis);
          }
          else if (JaxpVersion.isAtLeastJaxp14() && Jaxp14StaxHandler.isStaxSource(parameterType)) {
              XMLStreamReader streamReader;
              try {
                  streamReader = inputFactory.createXMLStreamReader(requestPayload);
              } catch (UnsupportedOperationException ignored) {
                  streamReader = null;
              }
              catch (XMLStreamException ignored) {
                  streamReader = null;
              }
              if (streamReader == null) {
                  ByteArrayInputStream bis = convertToByteArrayInputStream(requestPayload);
                  streamReader = inputFactory.createXMLStreamReader(bis);
              }
              return Jaxp14StaxHandler.createStaxSource(streamReader, requestPayload.getSystemId());
          }
          throw new IllegalArgumentException("Unknown Source type: " + parameterType);
     }
 
     // MethodReturnValueHandler
 
     @Override
     protected boolean supportsResponsePayloadReturnType(MethodParameter returnType) {
         return supports(returnType);
     }
 
     @Override
     protected Source createResponsePayload(MethodParameter returnType, Object returnValue) {
         return (Source) returnValue;
     }
 
     private boolean supports(MethodParameter parameter) {
         return Source.class.isAssignableFrom(parameter.getParameterType());
     }
 
     /**
      * Create a {@code XMLInputFactory} that this resolver will use to create {@link javax.xml.stream.XMLStreamReader}
      * and {@link javax.xml.stream.XMLEventReader} objects.
      * <p/>
      * Can be overridden in subclasses, adding further initialization of the factory. The resulting factory is cached,
      * so this method will only be called once.
      *
      * @return the created factory
      */
     protected XMLInputFactory createXmlInputFactory() {
         return XMLInputFactory.newInstance();
     }
 
     /** Inner class to avoid a static JAXP 1.4 dependency. */
     private static class Jaxp14StaxHandler {
 
         private static boolean isStaxSource(Class<?> clazz) {
             return StAXSource.class.isAssignableFrom(clazz);
         }
 
         private static Source createStaxSource(XMLStreamReader streamReader, String systemId) {
             return new StAXSource(new SystemIdStreamReaderDelegate(streamReader, systemId));
         }
 
     }
 
     private static class SystemIdStreamReaderDelegate extends StreamReaderDelegate {
 
         private final String systemId;
 
         private SystemIdStreamReaderDelegate(XMLStreamReader reader, String systemId) {
             super(reader);
             this.systemId = systemId;
         }
 
         @Override
         public Location getLocation() {
             final Location parentLocation = getParent().getLocation();
             return new Location() {
                 public int getLineNumber() {
                     return parentLocation != null ? parentLocation.getLineNumber() : -1;
                 }
 
                 public int getColumnNumber() {
                     return parentLocation != null ? parentLocation.getColumnNumber() : -1;
                 }
 
                 public int getCharacterOffset() {
                     return parentLocation != null ? parentLocation.getLineNumber() : -1;
                 }
 
                 public String getPublicId() {
                     return parentLocation != null ? parentLocation.getPublicId() : null;
                 }
 
                 public String getSystemId() {
                     return systemId;
                 }
             };
         }
     }
 
 }