/*
    *  Copyright (c) 2008 Rodrigo Ruiz
    *
    *  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.apache.axis.message.addressing.handler;
  
  import org.apache.axis.AxisFault;
  import org.apache.axis.Handler;
  import org.apache.axis.Message;
  import org.apache.axis.MessageContext;
  import org.apache.axis.message.addressing.AddressingHeaders;
  import org.apache.axis.message.addressing.Constants;
  import org.apache.axis.message.addressing.EndpointReference;
  import org.apache.ws.addressing.handler.ServerSideAddressingHandler;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  import javax.xml.namespace.QName;
  import javax.xml.rpc.Call;
  import javax.xml.rpc.JAXRPCException;
  import javax.xml.rpc.Service;
  import javax.xml.rpc.ServiceException;
  import javax.xml.rpc.handler.soap.SOAPMessageContext;
  import javax.xml.soap.SOAPBody;
  import javax.xml.soap.SOAPException;
  
  import java.io.IOException;
  import java.util.Hashtable;
  import java.util.List;
  
  /**
   * Axis-specific server-side WS-Addressing handler.
   *
   * @author Davanum Srinivas
   * @author Ian P. Springer
   * @version $Revision: 14 $
   */
  public class AxisServerSideAddressingHandler extends ServerSideAddressingHandler
    implements Handler {
  
    /**
     * <code>serialVersionUID</code> attribute.
     */
    private static final long serialVersionUID = 7912643926095186786L;
  
    /**
     * Wrapped handler.
     */
    private GenericAxisHandler axisHelperHandler = new GenericAxisHandler(this);
  
    /**
     * {@inheritDoc}
     */
    public void init() {
      axisHelperHandler.init();
    }
  
    /**
     * {@inheritDoc}
     */
    public void cleanup() {
      axisHelperHandler.cleanup();
    }
  
    /**
     * {@inheritDoc}
     */
    public boolean canHandleBlock(QName qname) {
      return (axisHelperHandler.canHandleBlock(qname));
    }
  
    /**
     * {@inheritDoc}
     */
    public void setOption(String name, Object value) {
      axisHelperHandler.setOption(name, value);
    }
  
    /**
     * Set a default value for the given option:
     * if the option is not already set, then set it.
     * if the option is already set, then do not set it.
     * <p>
     * If this is called multiple times, the first with a non-null value
     * if 'value' will set the default, remaining calls will be ignored.
     *
     * @param name  Option name
     * @param value Default value
    * @return true if value set (by this call), otherwise false;
    */
   public boolean setOptionDefault(String name, Object value) {
     return axisHelperHandler.setOptionDefault(name, value);
   }
 
   /**
    * {@inheritDoc}
    */
   public Object getOption(String name) {
     return axisHelperHandler.getOption(name);
   }
 
   /**
    * {@inheritDoc}
    */
   public Hashtable<?, ?> getOptions() {
     return axisHelperHandler.getOptions();
   }
 
   /**
    * {@inheritDoc}
    */
   public void setOptions(Hashtable opts) {
     axisHelperHandler.setOptions(opts);
   }
 
   /**
    * {@inheritDoc}
    */
   public void setName(String name) {
     axisHelperHandler.setName(name);
   }
 
   /**
    * {@inheritDoc}
    */
   public String getName() {
     return axisHelperHandler.getName();
   }
 
   /**
    * {@inheritDoc}
    */
   public Element getDeploymentData(Document doc) {
     return axisHelperHandler.getDeploymentData(doc);
   }
 
   /**
    * {@inheritDoc}
    */
   public List<?> getUnderstoodHeaders() {
     return axisHelperHandler.getUnderstoodHeaders();
   }
 
   /**
    * {@inheritDoc}
    */
   public void generateWSDL(MessageContext msgContext) throws AxisFault {
     axisHelperHandler.generateWSDL(msgContext);
   }
 
   /**
    * {@inheritDoc}
    */
   public void invoke(MessageContext msgContext) throws AxisFault {
     axisHelperHandler.invoke(msgContext);
   }
 
   /**
    * {@inheritDoc}
    */
   public void onFault(MessageContext msgContext) {
     axisHelperHandler.onFault(msgContext);
   }
 
   /**
    * Use the UUID generator that comes with Axis.
    *
    * @return a UUID
    */
   protected String generateUUId() {
     return axisHelperHandler.generateUUId();
   }
 
   /**
    * {@inheritDoc}
    */
   protected void forwardMessage(SOAPMessageContext soapMsgContext,
       EndpointReference endpointRef) {
     // TODO: not sure if overriding this method is even necessary.
     try {
       Service service = getService(soapMsgContext);
       Call call = service.createCall();
       call.setTargetEndpointAddress(endpointRef.getAddress().toString());
       ((org.apache.axis.client.Call) call).setRequestMessage((Message) soapMsgContext
           .getMessage());
       AddressingHeaders addrHeaders = buildAddressingHeadersForMessageForward(
           soapMsgContext, endpointRef);
       call.setProperty(Constants.ENV_ADDRESSING_REQUEST_HEADERS, addrHeaders);
       configureCall(call, soapMsgContext);
       call.invoke(new Object[0]);
       SOAPBody responseBody = soapMsgContext.getMessage().getSOAPPart().getEnvelope()
       .getBody();
       removeAllChildElements(responseBody);
     } catch (IOException e) {
       throw new JAXRPCException("Failed to forward SOAP message", e);
     } catch (ServiceException e) {
       throw new JAXRPCException("Failed to forward SOAP message", e);
     } catch (SOAPException e) {
       throw new JAXRPCException("Failed to forward SOAP message", e);
     }
 
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   protected void setTargetService(SOAPMessageContext soapMsgContext,
     AddressingHeaders headers) throws Exception {
     org.apache.axis.MessageContext axisMsgContext
       = (org.apache.axis.MessageContext) soapMsgContext;
 
     // TODO: why is the below code necessary? - add comments
     if (axisMsgContext.getService() == null
         && axisMsgContext.getTargetService() == null) {
       axisMsgContext.setTargetService(getTargetServiceName(headers));
       // This is to ensure the SOAPEnvelope is rebuilt with the right type mappings and
       // MessageContext is set with the right properties.
       if (axisMsgContext.getTargetService() != null) {
         ((Message) axisMsgContext.getMessage()).getSOAPPartAsString();
       }
     }
   }
 
   /**
    * AddressingHeaders factory method.
    *
    * @param soapMsgContext Context information
    * @param endpointRef    EPR
    * @return Headers container instance
    */
   private AddressingHeaders buildAddressingHeadersForMessageForward(
       SOAPMessageContext soapMsgContext, EndpointReference endpointRef) {
     AddressingHeaders headers = null;
     if (soapMsgContext != null) {
       headers = (AddressingHeaders) soapMsgContext
       .getProperty(Constants.ENV_ADDRESSING_RESPONSE_HEADERS);
     }
     if (headers == null) {
       headers = new AddressingHeaders(endpointRef);
     }
     return headers;
   }
 
 }