package org.apache.axis2.description;

import com.ibm.wsdl.util.xml.DOM2Writer;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.AddressingConstants;
import org.apache.axis2.addressing.AddressingHelper;
import org.apache.axis2.addressing.wsdl.WSDL11ActionHelper;
import org.apache.axis2.util.PolicyUtil;
import org.apache.axis2.util.XMLUtils;
import org.apache.axis2.wsdl.SOAPHeaderMessage;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.axis2.wsdl.WSDLUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.neethi.Constants;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyReference;
import org.apache.ws.commons.schema.utils.NamespaceMap;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;

import javax.wsdl.*;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.UnknownExtensibilityElement;
import javax.wsdl.extensions.schema.Schema;
import javax.wsdl.extensions.soap.*;
import javax.wsdl.extensions.soap12.*;
import javax.wsdl.factory.WSDLFactory;
import javax.wsdl.xml.WSDLLocator;
import javax.wsdl.xml.WSDLReader;
import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

/*
 * Copyright 2004,2005 The Apache Software Foundation.
 *
 * 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.
 *
 *
 */

public class WSDL11ToAxisServiceBuilder extends WSDLToAxisServiceBuilder {

    protected static final Log log = LogFactory
            .getLog(WSDL11ToAxisServiceBuilder.class);

    protected String portName;

    private static final String BINDING = "Binding";

    private static final String SERVICE = "Service";

    private static final String PORT = "Port";

    private static final String PORT_TYPE = "PortType";

    private static final String PORT_TYPE_OPERATION = "PortType.Operation";

    private static final String PORT_TYPE_OPERATION_INPUT = "PortType.Operation.Input";

    private static final String PORT_TYPE_OPERATION_OUTPUT = "PortType.Operation.Output";

    private static final String PORT_TYPE_OPERATION_FAULT = "PortType.Operation.Fault";

    private static final String BINDING_OPERATION = "Binding.Operation";

    private static final String BINDING_OPERATION_INPUT = "Binding.Operation.Input";

    private static final String BINDING_OPERATION_OUTPUT = "Binding.Operation.Output";

    protected Definition wsdl4jDefinition = null;

    private WSDLLocator customWSLD4JResolver;

    public static final String RPC_STYLE = "rpc";

    public static final String DOCUMENT_STYLE = "document";

    /**
     * Keeps a list of processable operations initiate to an empty list
     */
    private List wrappableOperations = new ArrayList();

    public static final String WRAPPED_OUTPUTNAME_SUFFIX = "Response";

    public static final String XML_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";

    public static final String NAMESPACE_DECLARATION_PREFIX = "xmlns:";

    private static int prefixCounter = 0;

    public static final String NAMESPACE_URI = "namespace";

    public static final String TRAGET_NAMESPACE = "targetNamespace";

    /**
     * keep track of whether setup code related to the entire wsdl is complete.
     * Note that WSDL11ToAllAxisServices will call setup multiple times, so this
     * field is used to make subsequent calls no-ops.
     */
    private boolean setupComplete = false;

    private Map schemaMap = null;

    private static final String JAVAX_WSDL_VERBOSE_MODE_KEY = "javax.wsdl.verbose";

    private static final String JAVAX_WSDL_IMPORT_DOCUMENTS_MODE_KEY = "javax.wsdl.importDocuments";

    /**
     * constructor taking in the service name and the port name
     *
     * @param in
     * @param serviceName
     * @param portName
     */
    public WSDL11ToAxisServiceBuilder(InputStream in, QName serviceName,
                                      String portName) {
        super(in, serviceName);
        this.portName = portName;
    }

    /**
     * @param def
     * @param serviceName
     * @param portName
     */
    public WSDL11ToAxisServiceBuilder(Definition def, QName serviceName,
                                      String portName) {
        super(null, serviceName);
        this.wsdl4jDefinition = def;
        this.portName = portName;
    }

    /**
     * @param in
     * @param service
     */
    public WSDL11ToAxisServiceBuilder(InputStream in, AxisService service) {
        super(in, service);
    }

    /**
     * @param in
     */
    public WSDL11ToAxisServiceBuilder(InputStream in) {
        this(in, null, null);
    }

    /**
     * sets a custem WSDL4J locator
     *
     * @param customWSLD4JResolver
     */
    public void setCustomWSLD4JResolver(WSDLLocator customWSLD4JResolver) {
        this.customWSLD4JResolver = customWSLD4JResolver;
    }

    /**
     * populates a given service This is the only publicly accessible method in
     * this class
     *
     * @throws AxisFault
     */
    public AxisService populateService() throws AxisFault {
        try {
            setup();
            // Setting wsdl4jdefintion to axisService , so if some one want
            // to play with it he can do that by getting the parameter
            Parameter wsdlDefinitionParameter = new Parameter();
            wsdlDefinitionParameter.setName(WSDLConstants.WSDL_4_J_DEFINITION);
            wsdlDefinitionParameter.setValue(wsdl4jDefinition);
            axisService.addParameter(wsdlDefinitionParameter);

            if (wsdl4jDefinition == null) {
                return null;
            }

            // setting target name space
            axisService.setTargetNamespace(wsdl4jDefinition
                    .getTargetNamespace());

            axisService.setNameSpacesMap(new NamespaceMap(wsdl4jDefinition
                    .getNamespaces()));

            Binding binding = findBinding(wsdl4jDefinition);

            if (binding.getPortType() == null) {
                throw new AxisFault("Unable to find wsdl:binding named " + binding.getQName());
            }

            // create new Schema extensions element for wrapping
            // (if its present)
            Element[] schemaElements = generateWrapperSchema(schemaMap, binding);

            // we might have modified the schemas by now so the addition should
            // happen here
            Types wsdl4jTypes = wsdl4jDefinition.getTypes();
            if (null != wsdl4jTypes) {
                this.copyExtensibleElements(wsdl4jTypes
                        .getExtensibilityElements(), wsdl4jDefinition,
                        axisService, TYPES);
            }

            // add the newly created schemas
            if (schemaElements != null && schemaElements.length > 0) {
                for (int i = 0; i < schemaElements.length; i++) {
                    Element schemaElement = schemaElements[i];
                    if (schemaElement != null) {
                        axisService
                                .addSchema(getXMLSchema(schemaElement, null));
                    }
                }
            }
            // copy the documentation element content to the description
            Element documentationElement = wsdl4jDefinition
                    .getDocumentationElement();
            if (documentationElement != null) {
                Node firstChild = documentationElement.getFirstChild();
                String serviceDes;
                if (firstChild.getNodeType() == Node.TEXT_NODE) {
                    serviceDes = firstChild.getNodeValue();
                } else {
                    serviceDes = DOM2Writer.nodeToString(firstChild);
                }
                axisService.setServiceDescription(serviceDes);
            }
            processBinding(binding, wsdl4jDefinition);

            return axisService;
        } catch (WSDLException e) {
            log.error(e);
            throw new AxisFault(e);
        } catch (Exception e) {
            log.error(e);
            throw new AxisFault(e);
        }
    }

    /**
     * contains all code which gathers non-service specific information from the
     * wsdl. <p/> After all the setup completes successfully, the setupComplete
     * field is set so that any subsequent calls to setup() will result in a
     * no-op. Note that subclass WSDL11ToAllAxisServicesBuilder will call
     * populateService for each port in the WSDL. Separating the non-service
     * specific information here allows WSDL11ToAllAxisServicesBuilder to only
     * do this work 1 time per WSDL, instead of for each port on each service.
     *
     * @throws WSDLException if readInTheWSDLFile fails
     */
    protected void setup() throws WSDLException {
        if (setupComplete) { // already setup, just do nothing and return
            return;
        }
        if (wsdl4jDefinition == null) {
            wsdl4jDefinition = readInTheWSDLFile(in);
        }
        if (wsdl4jDefinition == null) {
            return; // can't continue without wsdl
        }

        // process the imports
        // send an empty list as the processed namespace list since this
        // is the first call
        processImports(wsdl4jDefinition, new ArrayList());

        // Adding the policies in the Definition to the the PolicyRegistry
        processPoliciesInDefintion(wsdl4jDefinition);

        // setup the schemaMap
        schemaMap = populateSchemaMap(wsdl4jDefinition.getTypes());

        setupComplete = true; // if any part of setup fails, don't mark
        // setupComplete
    }

    /**
     * Populate a map of targetNamespace vs DOM schema element This is used to
     * grab the correct schema element when adding a new element
     *
     * @param wsdl4jTypes
     */

    private Map populateSchemaMap(Types wsdl4jTypes) {
        Map schemaMap = new HashMap();
        if (wsdl4jTypes != null) {
            List typesExtensibilityElements = wsdl4jTypes
                    .getExtensibilityElements();
            for (int i = 0; i < typesExtensibilityElements.size(); i++) {
                Object o = typesExtensibilityElements.get(i);
                if (o instanceof Schema) {
                    Schema s = (Schema) o;
                    String targetNamespace = s.getElement().getAttribute(
                            TRAGET_NAMESPACE);
                    schemaMap.put(targetNamespace, s.getElement());
                }
            }
        }
        return schemaMap;
    }

    /**
     * Look for the relevant binding!
     *
     * @param dif
     * @throws AxisFault
     */
    private Binding findBinding(Definition dif) throws AxisFault {
        Map services = dif.getServices();
        Service service = null;
        Binding binding = null;
        Port port = null;
        if (serviceName != null) {
            service = (Service) services.get(serviceName);
            if (service == null) {
                throw new AxisFault("Service " + serviceName + " was not found in the WSDL");
            }
        } else {
            if (services.size() > 0) {
                // pick the first service - we don't really have a choice here
                service = (Service) services.values().toArray()[0];
            }
        }
        if (service != null) {
            copyExtensibleElements(service.getExtensibilityElements(), dif,
                    axisService, SERVICE);
            if (portName != null) {
                port = service.getPort(portName);
                if (port == null) {
                    throw new AxisFault("No port found for the given name :"
                            + portName);
                }
            } else {
                Map ports = service.getPorts();
                if (ports != null && ports.size() > 0) {
                    // pick the port with the SOAP address as the default port
                    port = findSOAPPort(ports);
                    if (port == null) {
                        // a SOAP port was not found - log a warning
                        // and use the first port in the list
                        log.info("A SOAP port was not found - "
                                + "picking a random port!");
                        port = (Port) ports.values().toArray()[0];
                    }
                }
            }

            axisService.setName(service.getQName().getLocalPart());

            if (port != null) {
                copyExtensibleElements(port.getExtensibilityElements(), dif,
                        axisService, PORT);
                binding = dif.getBinding(port.getBinding().getQName());
                if (binding == null) {
                    binding = port.getBinding();
                }
            }
        } else {
            log.info("A service element was not found - "
                    + "picking a random binding!");
            Collection bindings = dif.getBindings().values();
            if (bindings == null || bindings.isEmpty()) {
                throw new AxisFault("No bindings found in wsdl");
            }
            binding = (Binding) bindings.iterator().next();
            axisService.setName(binding.getQName().getLocalPart() + "Service");
        }
        return binding;
    }

    /**
     * Finds a SOAP port given the port map
     *
     * @param ports
     */
    private Port findSOAPPort(Map ports) {
        Port port;
        for (Iterator portsIterator = ports.values().iterator(); portsIterator
                .hasNext();) {
            port = (Port) portsIterator.next();
            List extensibilityElements = port.getExtensibilityElements();
            for (int i = 0; i < extensibilityElements.size(); i++) {
                Object extElement = extensibilityElements.get(i);
                if (extElement instanceof SOAPAddress) {
                    // SOAP 1.1 address found - return that port and we are done
                    return port;
                }

                if (extElement instanceof SOAP12Address) {
                    // SOAP 1.2 address found - return that port and we are done
                    return port;
                }

            }

        }
        // None found - just return null.
        return null;
    }

    /**
     * Process the binding
     *
     * @param binding
     * @param dif
     * @throws Exception
     */
    private void processBinding(Binding binding, Definition dif)
            throws Exception {
        if (binding != null) {
            copyExtensibleElements(binding.getExtensibilityElements(), dif,
                    axisService, BINDING);

            PortType portType = dif.getPortType(binding.getPortType().getQName());
            processPortType(portType, dif);

            axisService.setBindingName(binding.getQName().getLocalPart());

            // String portTypeNs = portType.getQName().getNamespaceURI();
            List list = binding.getBindingOperations();
            for (int i = 0; i < list.size(); i++) {
                BindingOperation wsdl4jBindingOperation = (BindingOperation) list
                        .get(i);

                AxisOperation operation = axisService.getOperation(new QName(
                        wsdl4jBindingOperation.getName()));

                // this should first check the style of the binding
                // and then set the style in the axis operation
                // if that is not present, then only the global style applies
                // this style is either rpc or doc

                String style = getSOAPStyle(wsdl4jBindingOperation);
                if (style != null) {
                    operation.setStyle(style);
                } else if (this.style != null) {
                    operation.setStyle(this.style);
                }

                copyExtensibleElements(wsdl4jBindingOperation
                        .getExtensibilityElements(), dif, operation,
                        BINDING_OPERATION);

                BindingInput bindingInput = wsdl4jBindingOperation
                        .getBindingInput();
                BindingOutput bindingOutput = wsdl4jBindingOperation
                        .getBindingOutput();
                Map bindingFaultsMap = wsdl4jBindingOperation
                        .getBindingFaults();

                Operation wsdl4jOperation = findOperation(portType, wsdl4jBindingOperation);

                String MEP = operation.getMessageExchangePattern();

                /* Process the binding inputs */

                if (bindingInput != null) {
                    if (WSDLUtil.isInputPresentForMEP(MEP)) {

                        AxisMessage inAxisMessage = operation
                                .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
                        // Add the Qname reference - this has to be done by
                        // looking at the
                        // binding
                        AddQNameReference(inAxisMessage, wsdl4jOperation,
                                bindingInput, wrappableOperations
                                .contains(wsdl4jBindingOperation
                                .getOperation()));
                        copyExtensibleElements(bindingInput
                                .getExtensibilityElements(), dif,
                                inAxisMessage, BINDING_OPERATION_INPUT);
                    }
                }

                /*
                 * Process the binding outputs
                 */

                if (bindingOutput != null) {
                    if (WSDLUtil.isOutputPresentForMEP(MEP)) {
                        AxisMessage outAxisMessage = operation
                                .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);

                        // Add the Qname reference - this has to be done by
                        // looking at the
                        // binding
                        AddQNameReference(outAxisMessage, wsdl4jOperation,
                                bindingOutput, wrappableOperations
                                .contains(wsdl4jBindingOperation
                                .getOperation()));

                        copyExtensibleElements(bindingOutput
                                .getExtensibilityElements(), dif,
                                outAxisMessage, BINDING_OPERATION_OUTPUT);
                    }
                }

                /* process the binding faults */
                for (Iterator faultKeys = bindingFaultsMap.keySet().iterator(); faultKeys
                        .hasNext();) {
                    Object faultMapKey = faultKeys.next();
                    BindingFault bindingFault = (BindingFault) bindingFaultsMap
                            .get(faultMapKey);
                    Fault wsdl4jFault = wsdl4jOperation.getFault(bindingFault
                            .getName());
                    if (wsdl4jFault == null || wsdl4jFault.getMessage().getParts().size() == 0) {
                        throw new AxisFault("fault \"" + bindingFault.getName()
                                + "\" not found in the Operation "
                                + wsdl4jOperation.getName());
                    }
                    AxisMessage faultMessage = findFaultMessage(wsdl4jFault
                            .getMessage().getQName().getLocalPart(), operation
                            .getFaultMessages());

                    AddQNameReference(faultMessage, wsdl4jFault.getMessage());

                }
                Iterator iterator = operation.getFaultMessages().iterator();
                while (iterator.hasNext()) {
                    AxisMessage faultMessage = (AxisMessage) iterator.next();
                    if (faultMessage.getElementQName() == null) {
                        log.warn("Unable to find a wsdl:binding/wsdl:operation/wsdl:fault for fault named " + faultMessage.getName() + " defined in wsdl:portType/wsdl:operation/@name=" + operation.getName().getLocalPart());
                    }
                }
            }

        }
    }

    private Operation findOperation(PortType portType, BindingOperation wsdl4jBindingOperation) {
        Operation op = wsdl4jBindingOperation
                .getOperation();
        String input = null;
        if (op != null && op.getInput() != null) {
            input = op.getInput().getName();
            if (":none".equals(input)) {
                input = null;
            }
        }
        String output = null;
        if (op != null && op.getOutput() != null) {
            output = op.getOutput().getName();
            if (":none".equals(output)) {
                output = null;
            }
        }
        Operation op2 = portType.getOperation(op.getName(), input, output);
        return ((op2 == null) ? op : op2);
    }

    /**
     * Find the fault message relevant to a given name from the fault message
     * list
     *
     * @param name
     * @param faultMessages
     */
    private AxisMessage findFaultMessage(String name, ArrayList faultMessages) {
        AxisMessage tempMessage;
        for (int i = 0; i < faultMessages.size(); i++) {
            tempMessage = (AxisMessage) faultMessages.get(i);
            if (name.equals(tempMessage.getName())) {
                return tempMessage;
            }

        }
        return null;
    }

    /**
     * Add the QName for the binding input
     *
     * @param inMessage
     * @param wsdl4jOperation
     * @param bindingInput
     * @param isWrapped
     */
    private void AddQNameReference(AxisMessage inMessage,
                                   Operation wsdl4jOperation, BindingInput bindingInput,
                                   boolean isWrapped) {

        List extensibilityElements = bindingInput.getExtensibilityElements();
        Message wsdl4jMessage = wsdl4jOperation.getInput().getMessage();

        for (int i = 0; i < extensibilityElements.size(); i++) {
            ExtensibilityElement extElement = (ExtensibilityElement) extensibilityElements
                    .get(i);

            // SOAP 1.1 body element found!
            if (extElement instanceof SOAPBody) {
                SOAPBody soapBody = (SOAPBody) extElement;
                List bindingPartsList = soapBody.getParts();
                if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
                    // we can process a single part only
                    processPartsList(bindingPartsList, wsdl4jMessage, inMessage);
                    // there are no parts named in the binding - process the
                    // items normally
                    // by looking at the single message part - or the wrapped
                    // items if wrapped by us
                } else {
                    // for the wrapped types we need to find this from the
                    // wrapper schema map
                    if (isWrapped) {
                        // The schema for this should be already made ! Find the
                        // QName from
                        // the list and add it - the name for this is just the
                        inMessage
                                .setElementQName((QName) resolvedRpcWrappedElementMap
                                        .get(wsdl4jOperation.getName()));

                    } else if (wsdl4jMessage != null) {
                        // pick the first part from the list and take that as
                        // the relevant part
                        // it is somewhat questionnable whether the first part
                        // gets picked
                        // but we'll have to take a chance here
                        Map wsdl4jPartsMap = wsdl4jMessage.getParts();
                        if (!wsdl4jPartsMap.isEmpty()) {
                            Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
                                    .toArray()[0];
                            if (wsdl4jPart.getElementName() != null) {
                                inMessage.setElementQName(wsdl4jPart
                                        .getElementName());
                            }
                        }
                    }
                }
                break;
            } else if (extElement instanceof SOAP12Body) {
                SOAP12Body soapBody = (SOAP12Body) extElement;
                List bindingPartsList = soapBody.getParts();
                if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
                    // we can process a single part only
                    processPartsList(bindingPartsList, wsdl4jMessage, inMessage);
                    // there are no parts named in the binding - process the
                    // items normally
                    // by looking at the single message part - or the wrapped
                    // items if wrapped by us
                } else {
                    // for the wrapped types we need to find this from the
                    // wrapper schema map
                    if (isWrapped) {
                        // The schema for this should be already made ! Find the
                        // QName from
                        // the list and add it - the name for this is just the
                        inMessage
                                .setElementQName((QName) resolvedRpcWrappedElementMap
                                        .get(wsdl4jOperation.getName()));
                    } else if (wsdl4jMessage != null) {
                        // pick the first part from the list and take that as
                        // the relevant part
                        // it is somewhat questionnable whether the first part
                        // gets picked
                        // but we'll have to take a chance here
                        Map wsdl4jPartsMap = wsdl4jMessage.getParts();
                        if (!wsdl4jPartsMap.isEmpty()) {
                            Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
                                    .toArray()[0];
                            if (wsdl4jPart.getElementName() != null) {
                                inMessage.setElementQName(wsdl4jPart
                                        .getElementName());
                            }
                        }
                    }
                }
                break;
            }
        }

    }

    /**
     * A reusable method to both the input and output QName populators
     *
     * @param bindingPartsList
     * @param wsdl4jMessage
     * @param axisMessage
     */
    private void processPartsList(List bindingPartsList, Message wsdl4jMessage,
                                  AxisMessage axisMessage) {
        if (bindingPartsList.size() > 1) {
            // do something here - perhaps throw and exception
        } else {
            // find the part from the relevant message
            Part wsdl4jMessagePart = wsdl4jMessage
                    .getPart((String) bindingPartsList.get(0));
            // the part name better be there - if not throw an exception
            if (wsdl4jMessagePart == null) {
                throw new WSDLProcessingException("Missing part named \""
                        + bindingPartsList.get(0) + "\"");
            }
            QName name = wsdl4jMessagePart.getElementName();
            if (name == null) {
                name = wsdl4jMessagePart.getTypeName();
            }
            if (name == null) {
                throw new WSDLProcessingException(
                        "Element reference / Type name  missing for "
                                + bindingPartsList.get(0) + "!");
            }
            axisMessage.setElementQName(wsdl4jMessagePart.getElementName());
        }
    }

    /**
     * Add the QName for the binding output
     *
     * @param outMessage
     * @param wsdl4jOperation
     * @param isWrapped
     */
    private void AddQNameReference(AxisMessage outMessage,
                                   Operation wsdl4jOperation, BindingOutput bindingOutput,
                                   boolean isWrapped) {

        List extensibilityElements = bindingOutput.getExtensibilityElements();
        if (wsdl4jOperation.getOutput() == null) {
            return;
        }
        Message wsdl4jMessage = wsdl4jOperation.getOutput().getMessage();

        for (int i = 0; i < extensibilityElements.size(); i++) {
            ExtensibilityElement extElement = (ExtensibilityElement) extensibilityElements
                    .get(i);

            // SOAP 1.1 body element found!
            if (extElement instanceof SOAPBody) {
                SOAPBody soapBody = (SOAPBody) extElement;
                List bindingPartsList = soapBody.getParts();
                if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
                    // we can process a single part only so delegate the task
                    // of processing
                    processPartsList(bindingPartsList, wsdl4jMessage,
                            outMessage);
                    // there are no parts named in the binding - process the
                    // items normally
                    // by looking at the single message part - or the wrapped
                    // items if wrapped by us
                } else {
                    // for the wrapped types we need to find this from the
                    // wrapper schema map
                    if (isWrapped) {
                        // The schema for this should be already made ! Find the
                        // QName from
                        // the list and add it
                        outMessage
                                .setElementQName((QName) resolvedRpcWrappedElementMap
                                        .get(wsdl4jOperation.getName()
                                                + WRAPPED_OUTPUTNAME_SUFFIX));

                    } else if (wsdl4jMessage != null) {
                        // pick the first part from the list and take that as
                        // the relevant part
                        // it is somewhat questionable whether the first part
                        // gets picked
                        // but we'll have to take a chance here
                        Map wsdl4jPartsMap = wsdl4jMessage.getParts();
                        if (!wsdl4jPartsMap.isEmpty()) {
                            Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
                                    .toArray()[0];
                            if (wsdl4jPart.getElementName() != null) {
                                outMessage.setElementQName(wsdl4jPart
                                        .getElementName());
                            }
                        }
                    }
                }
            } else if (extElement instanceof SOAP12Body) {
                SOAP12Body soapBody = (SOAP12Body) extElement;
                List bindingPartsList = soapBody.getParts();
                if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
                    // we can process a single part only
                    processPartsList(bindingPartsList, wsdl4jMessage, outMessage);
                    // there are no parts named in the binding - process the
                    // items normally
                    // by looking at the single message part - or the wrapped
                    // items if wrapped by us
                } else {
                    // for the wrapped types we need to find this from the
                    // wrapper schema map
                    if (isWrapped) {
                        // The schema for this should be already made ! Find the
                        // QName from
                        // the list and add it - the name for this is just the
                        outMessage
                                .setElementQName((QName) resolvedRpcWrappedElementMap
                                        .get(wsdl4jOperation.getName()
                                                + WRAPPED_OUTPUTNAME_SUFFIX));
                    } else if (wsdl4jMessage != null) {
                        // pick the first part from the list and take that as
                        // the relevant part
                        // it is somewhat questionnable whether the first part
                        // gets picked
                        // but we'll have to take a chance here
                        Map wsdl4jPartsMap = wsdl4jMessage.getParts();
                        if (!wsdl4jPartsMap.isEmpty()) {
                            Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
                                    .toArray()[0];
                            if (wsdl4jPart.getElementName() != null) {
                                outMessage.setElementQName(wsdl4jPart
                                        .getElementName());
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Add the QName for the binding output
     */
    private void AddQNameReference(AxisMessage faultMessage,
                                   Message wsdl4jMessage) throws AxisFault {

        // for a fault this is trivial - All faults are related directly to a
        // message by the name and are supposed to have a single part. So it is
        // a matter of copying the right QName from the message part

        // get the part
        Part wsdl4jMessagePart = (Part) wsdl4jMessage.getParts().values()
                .toArray()[0];
        if (wsdl4jMessagePart == null) {
            throw new WSDLProcessingException();
        }
        QName name = wsdl4jMessagePart.getElementName();
        if (name == null) {
            String message = "Part '" + wsdl4jMessagePart.getName() +
                    "' of fault message '" + wsdl4jMessage.getQName()
                    + "' must be defined with 'element=QName' and not 'type=QName'";
            log.error(message);
            throw new AxisFault(message);

        }

        faultMessage.setElementQName(name);

    }

    /**
     * A util method that returns the SOAP style included in the binding
     * operation
     *
     * @param bindingOp
     */
    private String getSOAPStyle(BindingOperation bindingOp) {
        List extensibilityElements = bindingOp.getExtensibilityElements();
        for (int i = 0; i < extensibilityElements.size(); i++) {
            Object extElement = extensibilityElements.get(i);
            if (extElement instanceof SOAPOperation) {
                return ((SOAPOperation) extElement).getStyle();
            } else if (extElement instanceof SOAP12Operation) {
                return ((SOAP12Operation) extElement).getStyle();
            }

        }

        return null;

    }

    /**
     * Simply Copy information.
     *
     * @param wsdl4jPortType
     */
    // FIXME Evaluate a way of injecting features and priperties with a general
    // formatted input
    private void processPortType(PortType wsdl4jPortType, Definition dif)
            throws Exception {

        copyExtensionAttributes(wsdl4jPortType.getExtensionAttributes(),
                axisService, PORT_TYPE);

        // set port the type name
        axisService.setPortTypeName(wsdl4jPortType.getQName().getLocalPart());

        Iterator wsdl4JOperationsIterator = wsdl4jPortType.getOperations()
                .iterator();
        Operation wsdl4jOperation;
        while (wsdl4JOperationsIterator.hasNext()) {
            wsdl4jOperation = (Operation) wsdl4JOperationsIterator.next();
            axisService.addOperation(populateOperations(wsdl4jOperation,
                    wsdl4jPortType, dif));
        }
    }

    /**
     * Copy the component from the operation
     *
     * @param wsdl4jOperation
     * @param dif
     * @throws Exception
     */
    private AxisOperation populateOperations(Operation wsdl4jOperation,
                                             PortType wsdl4jPortType, Definition dif) throws Exception {
        QName opName = new QName(wsdl4jOperation.getName());
        // Copy Name Attribute
        AxisOperation axisOperation = axisService.getOperation(opName);
        if (axisOperation == null) {
            String MEP = getMEP(wsdl4jOperation);
            axisOperation = AxisOperationFactory.getOperationDescription(MEP);
            axisOperation.setName(opName);

            // setting the PolicyInclude property of the AxisOperation
            PolicyInclude policyInclude = new PolicyInclude(axisOperation);
            axisOperation.setPolicyInclude(policyInclude);
        }

        copyExtensibleElements(wsdl4jOperation.getExtensibilityElements(), dif,
                axisOperation, PORT_TYPE_OPERATION);

        Input wsdl4jInputMessage = wsdl4jOperation.getInput();

        if (isServerSide) {
            if (null != wsdl4jInputMessage) {
                AxisMessage inMessage = axisOperation
                        .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
                Message message = wsdl4jInputMessage.getMessage();
                if (null != message) {
                    inMessage.setName(message.getQName().getLocalPart());
                    copyExtensibleElements(message.getExtensibilityElements(),
                            dif, inMessage, PORT_TYPE_OPERATION_INPUT);

                }
                // Check if the action is already set as we don't want to
                // override it
                // with the Default Action Pattern
                ArrayList inputActions = axisOperation.getWsamappingList();
                String action = null;
                if (inputActions == null || inputActions.size() == 0) {
                    action = WSDL11ActionHelper
                            .getActionFromInputElement(dif, wsdl4jPortType,
                                    wsdl4jOperation, wsdl4jInputMessage);
                }
                if (action != null) {
                    if (inputActions == null) {
                        inputActions = new ArrayList();
                        axisOperation.setWsamappingList(inputActions);
                    }
                    inputActions.add(action);
                }
            }
            // Create an output message and add
            Output wsdl4jOutputMessage = wsdl4jOperation.getOutput();
            if (null != wsdl4jOutputMessage) {
                AxisMessage outMessage = axisOperation
                        .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
                Message message = wsdl4jOutputMessage.getMessage();
                if (null != message) {

                    outMessage.setName(message.getQName().getLocalPart());
                    copyExtensibleElements(message.getExtensibilityElements(),
                            dif, outMessage, PORT_TYPE_OPERATION_OUTPUT);

                    // wsdl:portType -> wsdl:operation -> wsdl:output
                }
                // Check if the action is already set as we don't want to
                // override it
                // with the Default Action Pattern
                String action = axisOperation.getOutputAction();
                if (action == null) {
                    action = WSDL11ActionHelper.getActionFromOutputElement(dif,
                            wsdl4jPortType, wsdl4jOperation,
                            wsdl4jOutputMessage);
                }
                if (action != null) {
                    axisOperation.setOutputAction(action);
                }
            }
        } else {

            // for the client side we have to do something that is a bit
            // weird. The in message is actually taken from the output
            // and the output is taken from the in

            if (null != wsdl4jInputMessage) {
                AxisMessage inMessage = axisOperation
                        .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
                Message message = wsdl4jInputMessage.getMessage();
                if (null != message) {

                    inMessage.setName(message.getQName().getLocalPart());
                    copyExtensibleElements(message.getExtensibilityElements(),
                            dif, inMessage, PORT_TYPE_OPERATION_OUTPUT);

                }
                // Check if the action is already set as we don't want to
                // override it
                // with the Default Action Pattern
                String action = axisOperation.getOutputAction();
                if (action == null) {
                    action = WSDL11ActionHelper
                            .getActionFromInputElement(dif, wsdl4jPortType,
                                    wsdl4jOperation, wsdl4jInputMessage);
                }
                if (action != null) {
                    axisOperation.setOutputAction(action);
                }
            }
            // Create an output message and add
            Output wsdl4jOutputMessage = wsdl4jOperation.getOutput();
            if (null != wsdl4jOutputMessage) {
                AxisMessage outMessage = axisOperation
                        .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
                Message message = wsdl4jOutputMessage.getMessage();
                if (null != message) {

                    outMessage.setName(message.getQName().getLocalPart());
                    copyExtensibleElements(message.getExtensibilityElements(),
                            dif, outMessage, PORT_TYPE_OPERATION_INPUT);

                    // wsdl:portType -> wsdl:operation -> wsdl:output
                }
                // Check if the action is already set as we don't want to
                // override it
                // with the Default Action Pattern
                ArrayList inputActions = axisOperation.getWsamappingList();
                String action = null;
                if (inputActions == null || inputActions.size() == 0) {
                    action = WSDL11ActionHelper.getActionFromOutputElement(dif,
                            wsdl4jPortType, wsdl4jOperation,
                            wsdl4jOutputMessage);
                }
                if (action != null) {
                    if (inputActions == null) {
                        inputActions = new ArrayList();
                        axisOperation.setWsamappingList(inputActions);
                    }
                    inputActions.add(action);
                }
            }
        }

        Map faults = wsdl4jOperation.getFaults();
        Iterator faultKeyIterator = faults.keySet().iterator();

        while (faultKeyIterator.hasNext()) {
            Fault fault = (Fault) faults.get(faultKeyIterator.next());
            AxisMessage axisFaultMessage = new AxisMessage();
            Message faultMessage = fault.getMessage();
            if (null != faultMessage) {
                axisFaultMessage
                        .setName(faultMessage.getQName().getLocalPart());
                copyExtensibleElements(faultMessage.getExtensibilityElements(),
                        dif, axisFaultMessage, PORT_TYPE_OPERATION_FAULT);

            }

            // Check if the action is already set as we don't want to override
            // it
            // with the Default Action Pattern
            String action = axisOperation.getFaultAction(fault.getName());
            if (action == null) {
                action = WSDL11ActionHelper.getActionFromFaultElement(dif,
                        wsdl4jPortType, wsdl4jOperation, fault);
            }
            if (action != null) {
                axisOperation.addFaultAction(fault.getName(), action);
            }
            axisOperation.setFaultMessages(axisFaultMessage);
        }
        return axisOperation;
    }

    /**
     * Generates a list of wrapper schemas
     *
     * @param wsdl4jBinding
     */
    private Element[] generateWrapperSchema(Map schemaMap, Binding wsdl4jBinding) {

        List schemaElementList = new ArrayList();
        // target namespace for this should be the namespace URI for
        // the porttype
        String porttypeNamespaceURI = wsdl4jBinding.getPortType().getQName()
                .getNamespaceURI();

        // //////////////////////////////////////////////////////////////////////
        // if there are any bindings present then we have to process them. we
        // have to generate a schema per wsdl4jBinding (that is the safest
        // option).
        // if not we just resolve to
        // the good old port type
        // list, in which case we'll generate a schema per porttype
        // //////////////////////////////////////////////////////////////////////

        Element schemaElement = createSchemaForPorttype(porttypeNamespaceURI,
                findWrappableOperations(wsdl4jBinding), schemaMap);

        if (schemaElement != null) {
            schemaElementList.add(schemaElement);
        }
        return (Element[]) schemaElementList
                .toArray(new Element[schemaElementList.size()]);
    }

    /**
     * Create a schema by looking at the port type
     *
     * @param namespaceURI
     * @return null if there is no element
     */
    private Element createSchemaForPorttype(String namespaceURI,
                                            List operationListToProcess, Map existingSchemaMap) {
        // first of all look at the operations list
        // we can return immediately if we get the operations list
        // as empty
        if (operationListToProcess.isEmpty()) {
            return null;
        }

        // loop through the messages. We'll populate thins map with the relevant
        // messages
        // from the operations
        Map messagesMap = new HashMap();
        Map inputOperationsMap = new HashMap();
        Map outputOperationsMap = new HashMap();
        Map faultyOperationsMap = new HashMap();
        // this contains the required namespace imports. the key in this
        // map would be the namaspace URI
        Map namespaceImportsMap = new HashMap();
        // generated complextypes. Keep in the list for writing later
        // the key for the complexType map is the message QName
        Map complexTypeElementsMap = new HashMap();
        // generated Elements. Kep in the list for later writing
        List elementElementsList = new ArrayList();
        // list namespace prefix map. This map will include uri -> prefix
        Map namespacePrefixMap = new HashMap();

        // //////////////////////////////////////////////////////////////////////////////////////////////////
        // First thing is to populate the message map with the messages to
        // process.
        // //////////////////////////////////////////////////////////////////////////////////////////////////

        // we really need to do this for a single porttype!
        Operation op;
        for (int k = 0; k < operationListToProcess.size(); k++) {
            op = (Operation) operationListToProcess.get(k);
            Input input = op.getInput();
            Message message;
            if (input != null) {
                message = input.getMessage();
                messagesMap.put(message.getQName(), message);
                inputOperationsMap.put(op.getName(), message);
            }

            Output output = op.getOutput();
            if (output != null) {
                message = output.getMessage();
                messagesMap.put(message.getQName(), message);
                outputOperationsMap.put(op.getName(), message);
            }

            Map faultMap = op.getFaults();
            if (faultMap != null && faultMap.size() > 0) {
                Iterator keys = faultMap.keySet().iterator();
                while (keys.hasNext()) {
                    Object key = keys.next();
                    Fault fault = (Fault) faultMap.get(key);
                    if (fault != null) {
                        message = fault.getMessage();
                        messagesMap.put(message.getQName(), message);
                        faultyOperationsMap.put(key, message);
                    }
                }
            }
        }

        // /////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // check whether there are messages that are wrappable. If there are no
        // messages that are wrappable we'll
        // just return null and endup this process. However we need to take the
        // force flag into account here
        // /////////////////////////////////////////////////////////////////////////////////////////////////////////////

        QName[] keys;

        // just take all the messages and wrap them, we've already selected
        // the relevant messages by looking at the SOAP binding

        keys = (QName[]) messagesMap.keySet().toArray(
                new QName[messagesMap.size()]);

        // /////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Now we have the message list to process - Process the whole list of
        // messages at once
        // since we need to generate one single schema
        // /////////////////////////////////////////////////////////////////////////////////////////////////////////////

        List resolvedMessageQNames = new ArrayList();
        // find the xsd prefix
        String xsdPrefix = findSchemaPrefix();
        Message wsdl4jMessage;
        // DOM document that will be the ultimate creator
        Document document = getDOMDocumentBuilder().newDocument();
        for (int i = 0; i < keys.length; i++) {
            wsdl4jMessage = (Message) messagesMap.get(keys[i]);
            // No need to check the wrappable,

            // This message is wrappabel. However we need to see whether the
            // message is already
            // resolved!
            if (!resolvedMessageQNames.contains(wsdl4jMessage.getQName())) {
                // This message has not been touched before!. So we can go ahead
                // now
                Map parts = wsdl4jMessage.getParts();
                // add the complex type
                Element newComplexType = document.createElementNS(
                        XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                        + XML_SCHEMA_COMPLEX_TYPE_LOCAL_NAME);

                Element cmplxTypeSequence = document.createElementNS(
                        XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                        + XML_SCHEMA_SEQUENCE_LOCAL_NAME);
                Element child;
                Iterator iterator = parts.keySet().iterator();
                while (iterator.hasNext()) {
                    Part part = (Part) parts.get(iterator.next());
                    // the part name
                    String elementName = part.getName();
                    boolean isTyped = true;
                    // the type name
                    QName schemaTypeName;
                    if (part.getTypeName() != null) {
                        schemaTypeName = part.getTypeName();
                    } else if (part.getElementName() != null) {
                        schemaTypeName = part.getElementName();
                        isTyped = false;
                    } else {
                        throw new RuntimeException(" Unqualified Message part!");
                    }

                    child = document.createElementNS(XMLSCHEMA_NAMESPACE_URI,
                            xsdPrefix + ":" + XML_SCHEMA_ELEMENT_LOCAL_NAME);

                    String prefix;
                    if (XMLSCHEMA_NAMESPACE_URI.equals(schemaTypeName
                            .getNamespaceURI())) {
                        prefix = xsdPrefix;
                    } else {
                        // this schema is a third party one. So we need to have
                        // an import statement in our generated schema
                        String uri = schemaTypeName.getNamespaceURI();
                        if (!namespaceImportsMap.containsKey(uri)) {
                            // create Element for namespace import
                            Element namespaceImport = document.createElementNS(
                                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                                    + XML_SCHEMA_IMPORT_LOCAL_NAME);
                            namespaceImport.setAttribute(NAMESPACE_URI, uri);
                            // add this to the map
                            namespaceImportsMap.put(uri, namespaceImport);
                            // we also need to associate this uri with a prefix
                            // and include that prefix
                            // in the schema's namspace declarations. So add
                            // theis particular namespace to the
                            // prefix map as well
                            prefix = getTemporaryNamespacePrefix();
                            namespacePrefixMap.put(uri, prefix);
                        } else {
                            // this URI should be already in the namspace prefix
                            // map
                            prefix = (String) namespacePrefixMap.get(uri);
                        }

                    }
                    // If it's from a type the element we need to add a name and
                    // the type
                    // if not it's the element reference
                    if (isTyped) {
                        child.setAttribute(XSD_NAME, elementName);
                        child.setAttribute(XSD_TYPE, prefix + ":"
                                + schemaTypeName.getLocalPart());
                    } else {
                        child.setAttribute(XSD_REF, prefix + ":"
                                + schemaTypeName.getLocalPart());
                    }
                    cmplxTypeSequence.appendChild(child);
                }
                newComplexType.appendChild(cmplxTypeSequence);
                // add this newly created complextype to the list
                complexTypeElementsMap.put(wsdl4jMessage.getQName(),
                        newComplexType);
                resolvedMessageQNames.add(wsdl4jMessage.getQName());
            }

        }

        Element elementDeclaration;

        // loop through the input op map and generate the elements
        String[] inputOperationtNames = (String[]) inputOperationsMap.keySet()
                .toArray(new String[inputOperationsMap.size()]);
        for (int j = 0; j < inputOperationtNames.length; j++) {
            String inputOpName = inputOperationtNames[j];
            elementDeclaration = document.createElementNS(
                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                    + XML_SCHEMA_ELEMENT_LOCAL_NAME);
            elementDeclaration.setAttribute(XSD_NAME, inputOpName);

            QName typeQName = ((Message) inputOperationsMap.get(inputOpName))
                    .getQName();
            // add the anonymous
            elementDeclaration.appendChild(((Element) complexTypeElementsMap
                    .get(typeQName)).cloneNode(true));

            elementElementsList.add(elementDeclaration);
            resolvedRpcWrappedElementMap.put(inputOpName, new QName(
                    namespaceURI, inputOpName, AXIS2WRAPPED));
        }

        // loop through the output op map and generate the elements
        String[] outputOperationtNames = (String[]) outputOperationsMap
                .keySet().toArray(new String[outputOperationsMap.size()]);
        for (int j = 0; j < outputOperationtNames.length; j++) {

            String baseoutputOpName = outputOperationtNames[j];
            String outputOpName = baseoutputOpName + WRAPPED_OUTPUTNAME_SUFFIX;
            elementDeclaration = document.createElementNS(
                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                    + XML_SCHEMA_ELEMENT_LOCAL_NAME);
            elementDeclaration.setAttribute(XSD_NAME, outputOpName);

            QName typeQName = ((Message) outputOperationsMap
                    .get(baseoutputOpName)).getQName();
            // add the anonymous
            elementDeclaration.appendChild(((Element) complexTypeElementsMap
                    .get(typeQName)).cloneNode(true));
            elementElementsList.add(elementDeclaration);

            resolvedRpcWrappedElementMap.put(outputOpName, new QName(
                    namespaceURI, outputOpName, AXIS2WRAPPED));

        }

        // loop through the faultoutput op map and generate the elements
        String[] faultyOperationtNames = (String[]) faultyOperationsMap
                .keySet().toArray(new String[faultyOperationsMap.size()]);
        for (int j = 0; j < faultyOperationtNames.length; j++) {

            String baseFaultOpName = faultyOperationtNames[j];
            elementDeclaration = document.createElementNS(
                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                    + XML_SCHEMA_ELEMENT_LOCAL_NAME);
            elementDeclaration.setAttribute(XSD_NAME, baseFaultOpName);

            QName typeQName = ((Message) faultyOperationsMap
                    .get(baseFaultOpName)).getQName();
            elementDeclaration.appendChild(((Element) complexTypeElementsMap
                    .get(typeQName)).cloneNode(true));
            elementElementsList.add(elementDeclaration);
            resolvedRpcWrappedElementMap.put(baseFaultOpName, new QName(
                    namespaceURI, baseFaultOpName, AXIS2WRAPPED));
        }

        // /////////////////////////////////////////////////////////////////////
        //
        // Now we are done with processing the messages and generating the right
        // schema object model
        // time to write out the schema
        //
        // There is a catch here - when the target namespace of the generated
        // schema is equivalent to one of the existing schemas we'll have to
        // insert the elements there rather than creating a new Schema element
        // //////////////////////////////////////////////////////////////////////
        //
        if (existingSchemaMap.containsKey(namespaceURI)) {
            // get the relevant schema element
            Element schemaElement = (Element) existingSchemaMap
                    .get(namespaceURI);
            Document ownerDocument = schemaElement.getOwnerDocument();

            // loop through the namespace declarations first and add them
            String[] nameSpaceDeclarationArray = (String[]) namespacePrefixMap
                    .keySet().toArray(new String[namespacePrefixMap.size()]);
            for (int i = 0; i < nameSpaceDeclarationArray.length; i++) {
                String s = nameSpaceDeclarationArray[i];
                checkAndAddNamespaceDeclarations(s, namespacePrefixMap,
                        schemaElement);
            }

            // add imports - check whether it is the targetnamespace before
            // adding
            Element[] namespaceImports = (Element[]) namespaceImportsMap
                    .values().toArray(new Element[namespaceImportsMap.size()]);
            for (int i = 0; i < namespaceImports.length; i++) {
                if (!namespaceURI.equals(namespaceImports[i]
                        .getAttribute(NAMESPACE_URI))) {
                    schemaElement.appendChild(ownerDocument.importNode(
                            namespaceImports[i], true));
                }
            }

            Element[] elementDeclarations = (Element[]) elementElementsList
                    .toArray(new Element[elementElementsList.size()]);
            for (int i = 0; i < elementDeclarations.length; i++) {
                schemaElement.appendChild(ownerDocument.importNode(
                        elementDeclarations[i], true));
            }

            // don't return anything!!
            return null;
        } else {
            // there is no element in the
            Element schemaElement = document.createElementNS(
                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
                    + XML_SCHEMA_LOCAL_NAME);

            // loop through the namespace declarations first
            String[] nameSpaceDeclarationArray = (String[]) namespacePrefixMap
                    .keySet().toArray(new String[namespacePrefixMap.size()]);
            for (int i = 0; i < nameSpaceDeclarationArray.length; i++) {
                String s = nameSpaceDeclarationArray[i];
                schemaElement.setAttributeNS(XML_NAMESPACE_URI,
                        NAMESPACE_DECLARATION_PREFIX
                                + namespacePrefixMap.get(s).toString(), s);
            }

            if (schemaElement.getAttributeNS(XML_NAMESPACE_URI, xsdPrefix)
                    .length() == 0) {
                schemaElement.setAttributeNS(XML_NAMESPACE_URI,
                        NAMESPACE_DECLARATION_PREFIX + xsdPrefix,
                        XMLSCHEMA_NAMESPACE_URI);
            }

            // add the targetNamespace
            schemaElement.setAttributeNS(XML_NAMESPACE_URI, XMLNS_AXIS2WRAPPED,
                    namespaceURI);
            schemaElement.setAttribute(XSD_TARGETNAMESPACE, namespaceURI);
            schemaElement.setAttribute(XSD_ELEMENT_FORM_DEFAULT,
                    XSD_UNQUALIFIED);

            // add imports
            Element[] namespaceImports = (Element[]) namespaceImportsMap
                    .values().toArray(new Element[namespaceImportsMap.size()]);
            for (int i = 0; i < namespaceImports.length; i++) {
                schemaElement.appendChild(namespaceImports[i]);

            }

            // add element declarations
            Element[] elementDeclarations = (Element[]) elementElementsList
                    .toArray(new Element[elementElementsList.size()]);
            for (int i = 0; i < elementDeclarations.length; i++) {
                schemaElement.appendChild(elementDeclarations[i]);

            }

            return schemaElement;
        }

    }

    /**
     * @param prefixMap
     */
    private void checkAndAddNamespaceDeclarations(String namespace,
                                                  Map prefixMap, Element schemaElement) {
        // get the attribute for the current namespace
        String prefix = (String) prefixMap.get(namespace);
        // A prefix must be found at this point!
        String existingURL = schemaElement.getAttributeNS(XML_NAMESPACE_URI,
                NAMESPACE_DECLARATION_PREFIX + prefix);
        if (existingURL == null) {
            // there is no existing URL by that prefix - declare a new namespace
            schemaElement.setAttributeNS(XML_NAMESPACE_URI,
                    NAMESPACE_DECLARATION_PREFIX + prefix, namespace);
        } else if (existingURL.equals(namespace)) {
            // this namespace declaration is already there with the same prefix
            // ignore it
        } else {
            // there is a different namespace declared in the given prefix
            // change the prefix in the prefix map to a new one and declare it

            // create a prefix
            String generatedPrefix = "ns" + prefixCounter++;
            while (prefixMap.containsKey(generatedPrefix)) {
                generatedPrefix = "ns" + prefixCounter++;
            }
            schemaElement.setAttributeNS(XML_NAMESPACE_URI,
                    NAMESPACE_DECLARATION_PREFIX + generatedPrefix, namespace);
            // add to the map
            prefixMap.put(generatedPrefix, namespace);
        }

    }

    /**
     * The intention of this procedure is to process the imports. When
     * processing the imports the imported documents will be populating the
     * items in the main document recursivley
     *
     * @param wsdl4JDefinition
     */
    private void processImports(Definition wsdl4JDefinition,
                                List processedDocuments) {
        Map wsdlImports = wsdl4JDefinition.getImports();

        if (null != wsdlImports && !wsdlImports.isEmpty()) {
            Collection importsCollection = wsdlImports.values();
            for (Iterator iterator = importsCollection.iterator(); iterator
                    .hasNext();) {
                Vector values = (Vector) iterator.next();
                for (int i = 0; i < values.size(); i++) {
                    Import wsdlImport = (Import) values.elementAt(i);

                    if (wsdlImport.getDefinition() != null) {
                        Definition importedDef = wsdlImport.getDefinition();

                        if (importedDef != null) {
                            String key = importedDef.getDocumentBaseURI();
                            if (key == null) {
                                key = importedDef.getTargetNamespace();
                            }
                            // stop recursive imports!
                            if (processedDocuments.contains(key)) {
                                return;
                            }
                            processedDocuments.add(key);

                            processImports(importedDef,
                                    processedDocuments);

                            // copy ns
                            Map namespaces = importedDef.getNamespaces();
                            Iterator keys = namespaces.keySet().iterator();
                            while (keys.hasNext()) {
                                Object key2 = keys.next();
                                if (!wsdl4jDefinition.getNamespaces()
                                        .containsValue(namespaces.get(key2))) {
                                    wsdl4jDefinition.getNamespaces().put(key2,
                                            namespaces.get(key2));
                                }
                            }

                            wsdl4jDefinition.getNamespaces().putAll(namespaces);
                            // copy types
                            Types t = importedDef.getTypes();
                            if (t != null) {
                                List typesList = t.getExtensibilityElements();
                                for (int j = 0; j < typesList.size(); j++) {
                                    Types types = wsdl4JDefinition.getTypes();
                                    if (types == null) {
                                        types = wsdl4JDefinition.createTypes();
                                        wsdl4JDefinition.setTypes(types);
                                    }
                                    types
                                            .addExtensibilityElement((ExtensibilityElement) typesList
                                                    .get(j));

                                }
                            }

                            // add messages
                            Map messagesMap = importedDef.getMessages();
                            wsdl4JDefinition.getMessages().putAll(messagesMap);

                            // add portypes
                            Map porttypeMap = importedDef.getPortTypes();
                            wsdl4JDefinition.getPortTypes().putAll(porttypeMap);

                            // add bindings
                            Map bindingMap = importedDef.getBindings();
                            wsdl4JDefinition.getBindings().putAll(bindingMap);

                            // add services
                            Map serviceMap = importedDef.getServices();
                            wsdl4JDefinition.getServices().putAll(serviceMap);

                            List extElementList = importedDef
                                    .getExtensibilityElements();
                            wsdl4JDefinition.getExtensibilityElements().addAll(
                                    extElementList);

                        }

                    }
                }
            }
        }
    }

    /**
     * Read the WSDL file given the inputstream for the WSDL source
     *
     * @param in
     * @throws WSDLException
     */
    private Definition readInTheWSDLFile(InputStream in) throws WSDLException {

        WSDLReader reader = WSDLFactory.newInstance().newWSDLReader();

        // switch off the verbose mode for all usecases
        reader.setFeature(JAVAX_WSDL_VERBOSE_MODE_KEY, false);

        // if the custem resolver is present then use it
        if (customWSLD4JResolver != null) {
            return reader.readWSDL(customWSLD4JResolver);
        } else {
            Document doc;
            try {
                doc = XMLUtils.newDocument(in);
            } catch (ParserConfigurationException e) {
                throw new WSDLException(WSDLException.PARSER_ERROR,
                        "Parser Configuration Error", e);
            } catch (SAXException e) {
                throw new WSDLException(WSDLException.PARSER_ERROR,
                        "Parser SAX Error", e);

            } catch (IOException e) {
                throw new WSDLException(WSDLException.INVALID_WSDL, "IO Error",
                        e);
            }
            return reader.readWSDL(getBaseUri(), doc);
        }
    }

    /**
     * Get the Extensible elements form wsdl4jExtensibleElements
     * <code>Vector</code> if any and copy them to <code>Component</code>
     * <p/> Note - SOAP body extensible element will be processed differently
     *
     * @param wsdl4jExtensibleElements
     * @param description                   where is the ext element (port , portype , biding)
     * @param wsdl4jDefinition
     * @param originOfExtensibilityElements -
     *                                      this will indicate the place this extensibility element came
     *                                      from.
     */
    private void copyExtensibleElements(List wsdl4jExtensibleElements,
                                        Definition wsdl4jDefinition, AxisDescription description,
                                        String originOfExtensibilityElements) throws AxisFault {
        Iterator iterator = wsdl4jExtensibleElements.iterator();
        while (iterator.hasNext()) {
            ExtensibilityElement wsdl4jElement = (ExtensibilityElement) iterator
                    .next();

            if (wsdl4jElement instanceof UnknownExtensibilityElement) {
                UnknownExtensibilityElement unknown = (UnknownExtensibilityElement) (wsdl4jElement);

                if (WSDLConstants.WSDL11Constants.POLICY.equals(unknown
                        .getElementType())) {

                    Policy policy = (Policy) PolicyUtil
                            .getPolicyComponent(unknown.getElement());
                    addPolicy(description, originOfExtensibilityElements,
                            policy);

                } else if (WSDLConstants.WSDL11Constants.POLICY_REFERENCE
                        .equals(unknown.getElementType())) {

                    PolicyReference policyReference = (PolicyReference) PolicyUtil
                            .getPolicyComponent(unknown.getElement());
                    addPolicyRef(description, originOfExtensibilityElements,
                            policyReference);

                } else if (AddressingConstants.Final.WSAW_USING_ADDRESSING
                        .equals(unknown.getElementType())
                        || AddressingConstants.Submission.WSAW_USING_ADDRESSING
                        .equals(unknown.getElementType())) {
                    // Read the wsaw:UsingAddressing flag from the WSDL. It is
                    // only valid on the Port or Binding
                    // so only recognise it as en extensibility elemtn of one of
                    // those.
                    if (originOfExtensibilityElements.equals(PORT)
                            || originOfExtensibilityElements.equals(BINDING)) {
                        if (Boolean.TRUE.equals(unknown.getRequired())) {
                            axisService
                                    .setWSAddressingFlag(AddressingConstants.ADDRESSING_REQUIRED);
                        } else {
                            axisService
                                    .setWSAddressingFlag(AddressingConstants.ADDRESSING_OPTIONAL);
                        }
                    }
                } else if (AddressingConstants.Final.WSAW_ANONYMOUS
                        .equals(unknown.getElementType())) {
                    if (originOfExtensibilityElements.equals(BINDING_OPERATION)) {
                        AxisOperation axisOperation = (AxisOperation) description;
                        if (unknown.getElement().getFirstChild() != null
                                && unknown.getElement().getFirstChild()
                                .getNodeType() == Node.TEXT_NODE) {
                            String anonymousValue = unknown.getElement()
                                    .getFirstChild().getNodeValue();
                            AddressingHelper.setAnonymousParameterValue(
                                    axisOperation, anonymousValue);
                        }
                    }
                } else {
                    // Ignore this element - it is a totally unknown element
                    // and we don't care!
                }

                // WSDL4J has all the SOAP 1.1 and SOAP 1.2 Items built in. So we can check
                // the items directly
            } else if (wsdl4jElement instanceof SOAP12Address) {
                SOAP12Address soapAddress = (SOAP12Address) wsdl4jElement;
                axisService.setEndpoint(soapAddress.getLocationURI());
            } else if (wsdl4jElement instanceof SOAPAddress) {
                SOAPAddress soapAddress = (SOAPAddress) wsdl4jElement;
                axisService.setEndpoint(soapAddress.getLocationURI());
            } else if (wsdl4jElement instanceof Schema) {
                Schema schema = (Schema) wsdl4jElement;
                // just add this schema - no need to worry about the imported
                // ones
                axisService.addSchema(getXMLSchema(schema.getElement(), schema
                        .getDocumentBaseURI()));
            } else if (wsdl4jElement instanceof SOAP12Operation) {
                SOAP12Operation soapOperation = (SOAP12Operation) wsdl4jElement;
                if (description instanceof AxisOperation) {
                    AxisOperation axisOperation = (AxisOperation) description;
                    if (soapOperation.getStyle() != null) {
                        axisOperation.setStyle(soapOperation.getStyle());
                    }
                    axisOperation.setSoapAction(soapOperation
                            .getSoapActionURI());
                }
            } else if (wsdl4jElement instanceof SOAPOperation) {
                SOAPOperation soapOperation = (SOAPOperation) wsdl4jElement;
                if (description instanceof AxisOperation) {
                    AxisOperation axisOperation = (AxisOperation) description;
                    if (soapOperation.getStyle() != null) {
                        axisOperation.setStyle(soapOperation.getStyle());
                    }
                    axisOperation.setSoapAction(soapOperation
                            .getSoapActionURI());
                }
            } else if (wsdl4jElement instanceof SOAP12Header) {
                SOAP12Header soapHeader = (SOAP12Header) wsdl4jElement;
                SOAPHeaderMessage headerMessage = new SOAPHeaderMessage();
                headerMessage.setNamespaceURI(soapHeader.getNamespaceURI());
                headerMessage.setUse(soapHeader.getUse());
                Boolean required = soapHeader.getRequired();
                if (null != required) {
                    headerMessage.setRequired(required.booleanValue());
                }
                if (null != wsdl4jDefinition) {
                    // find the relevant schema part from the messages
                    Message msg = wsdl4jDefinition.getMessage(soapHeader
                            .getMessage());
                    if (msg == null) {
                        // todo i18n this
                        throw new AxisFault("message "
                                + soapHeader.getMessage()
                                + " not found in the WSDL ");
                    }
                    Part msgPart = msg.getPart(soapHeader.getPart());
                    if (msgPart == null) {
                        // todo i18n this
                        throw new AxisFault("message part "
                                + soapHeader.getPart()
                                + " not found in the WSDL ");
                    }
                    headerMessage.setElement(msgPart.getElementName());
                }
                headerMessage.setMessage(soapHeader.getMessage());

                headerMessage.setPart(soapHeader.getPart());
                if (description instanceof AxisMessage) {
                    ((AxisMessage) description).addSoapHeader(headerMessage);
                }
            } else if (wsdl4jElement instanceof SOAPHeader) {
                SOAPHeader soapHeader = (SOAPHeader) wsdl4jElement;
                SOAPHeaderMessage headerMessage = new SOAPHeaderMessage();
                headerMessage.setNamespaceURI(soapHeader.getNamespaceURI());
                headerMessage.setUse(soapHeader.getUse());
                Boolean required = soapHeader.getRequired();
                if (null != required) {
                    headerMessage.setRequired(required.booleanValue());
                }
                if (null != wsdl4jDefinition) {
                    // find the relevant schema part from the messages
                    Message msg = wsdl4jDefinition.getMessage(soapHeader
                            .getMessage());
                    if (msg == null) {
                        // todo i18n this
                        throw new AxisFault("message "
                                + soapHeader.getMessage()
                                + " not found in the WSDL ");
                    }
                    Part msgPart = msg.getPart(soapHeader.getPart());
                    if (msgPart == null) {
                        // todo i18n this
                        throw new AxisFault("message part "
                                + soapHeader.getPart()
                                + " not found in the WSDL ");
                    }
                    headerMessage.setElement(msgPart.getElementName());
                }
                headerMessage.setMessage(soapHeader.getMessage());

                headerMessage.setPart(soapHeader.getPart());
                if (description instanceof AxisMessage) {
                    ((AxisMessage) description).addSoapHeader(headerMessage);
                }
            } else if (wsdl4jElement instanceof SOAPBinding) {
                SOAPBinding soapBinding = (SOAPBinding) wsdl4jElement;
                style = soapBinding.getStyle();
                axisService.setSoapNsUri(soapBinding.getElementType()
                        .getNamespaceURI());
            } else if (wsdl4jElement instanceof SOAP12Binding) {
                SOAP12Binding soapBinding = (SOAP12Binding) wsdl4jElement;
                style = soapBinding.getStyle();
                axisService.setSoapNsUri(soapBinding.getElementType()
                        .getNamespaceURI());
            }
        }
    }

    /**
     * Add a policy
     *
     * @param description
     * @param originOfExtensibilityElements
     * @param policy
     */
    private void addPolicy(AxisDescription description,
                           String originOfExtensibilityElements, Policy policy) {

        if (description instanceof AxisService) {
            // wsdl:service
            if (SERVICE.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.SERVICE_POLICY, policy);

                // wsdl:service -> wsdl:port
            } else if (PORT.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.PORT_POLICY, policy);

                // wsdl:binding
            } else if (BINDING.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.BINDING_POLICY, policy);

            }

            // TODO wsdl:portType ?

        } else if (description instanceof AxisOperation) {

            // wsdl:portType -> wsdl:operation
            if (PORT_TYPE_OPERATION.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.OPERATION_POLICY, policy);

                // wsdl:binding -> wsdl:operation
            } else {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.BINDING_OPERATION_POLICY, policy);
            }

        } else {

            // wsdl:portType -> wsdl:operation -> wsdl:input
            if (PORT_TYPE_OPERATION_INPUT.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.INPUT_POLICY, policy);

                // wsdl:binding -> wsdl:operation -> wsdl:input
            } else if (BINDING_OPERATION_INPUT
                    .equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.BINDING_INPUT_POLICY, policy);

                // wsdl:portType -> wsdl:operation -> wsdl:put
            } else if (PORT_TYPE_OPERATION_OUTPUT
                    .equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.OUTPUT_POLICY, policy);

                // wsdl:binding -> wsdl:operation -> wsdl:output
            } else if (BINDING_OPERATION_OUTPUT
                    .equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyElement(
                        PolicyInclude.BINDING_OUTPUT_POLICY, policy);
            }
        }
    }

    /**
     * Add a policy reference
     *
     * @param description
     * @param originOfExtensibilityElements
     * @param policyRefElement
     */
    private void addPolicyRef(AxisDescription description,
                              String originOfExtensibilityElements,
                              PolicyReference policyRefElement) {

        if (description instanceof AxisService) {
            // wsdl:service
            if (SERVICE.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.SERVICE_POLICY, policyRefElement);

                // wsdl:service -> wsdl:port
            } else if (PORT.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.PORT_POLICY, policyRefElement);

                // wsdl:binding
            } else if (BINDING.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.BINDING_POLICY, policyRefElement);
            }

            // TODO policy for wsdl:portType ?

        } else if (description instanceof AxisOperation) {

            // wsdl:portType -> wsdl:operation
            if (PORT_TYPE_OPERATION.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.OPERATION_POLICY, policyRefElement);

                // wsdl:binding -> wsdl:operation
            } else {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.BINDING_POLICY, policyRefElement);
            }

        } else {

            // wsdl:portType -> wsdl:operation -> wsdl:input
            if (PORT_TYPE_OPERATION_INPUT.equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.INPUT_POLICY, policyRefElement);

                // wsdl:binding -> wsdl:operation -> wsdl:input
            } else if (BINDING_OPERATION_INPUT
                    .equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.BINDING_INPUT_POLICY, policyRefElement);

                // wsdl:portType -> wsdl:operation -> wsdl:put
            } else if (PORT_TYPE_OPERATION_OUTPUT
                    .equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.OUTPUT_POLICY, policyRefElement);

                // wsdl:binding -> wsdl:operation -> wsdl:output
            } else if (BINDING_OPERATION_OUTPUT
                    .equals(originOfExtensibilityElements)) {
                description.getPolicyInclude().addPolicyRefElement(
                        PolicyInclude.BINDING_OUTPUT_POLICY, policyRefElement);
            }

            // TODO Faults ..
        }
    }

    /**
     * Look for the wrappable operations depending on the style
     *
     * @param binding
     */
    private List findWrappableOperations(Binding binding) {
        // first find the global style declaration.
        // for a SOAP binding this can be only rpc or document
        // as per the WSDL spec (section 3.4) the default style is document

        boolean isRPC = false;
        boolean isSOAPBinding = false;

        List extElements = binding.getExtensibilityElements();
        for (int i = 0; i < extElements.size(); i++) {
            if (extElements.get(i) instanceof SOAPBinding) {
                // we have a global SOAP binding!
                isSOAPBinding = true;
                SOAPBinding soapBinding = (SOAPBinding) extElements.get(i);
                if (RPC_STYLE.equals(soapBinding.getStyle())) {
                    // set the global style to rpc
                    isRPC = true;
                }

                break;
            }
        }

        // if SOAPBinding is not present just return an empty list
        if (!isSOAPBinding) {
            return new ArrayList();
        }

        // go through every operation and get their styles.
        // each one can have a style override from the global
        // styles. Depending on the style add the relevant operations
        // to the return list
        List returnList = new ArrayList();

        BindingOperation bindingOp;
        for (Iterator bindingOperationsIterator = binding
                .getBindingOperations().iterator(); bindingOperationsIterator
                .hasNext();) {
            bindingOp = (BindingOperation) bindingOperationsIterator.next();
            String style = getSOAPStyle(bindingOp);

            if (style == null) {
                // no style specified
                // use the global style to determine whether to put this one or
                // not
                if (isRPC) {
                    returnList.add(bindingOp.getOperation());
                }
            } else if (RPC_STYLE.equals(style)) {
                // add to the list
                returnList.add(bindingOp.getOperation());
            }
            // if not RPC we just leave it - default is doc

        }

        // set this to the global list
        wrappableOperations = returnList;
        return returnList;
    }

    /**
     * Guess the MEP based on the order of messages
     *
     * @param operation
     * @throws Exception
     */
    private String getMEP(Operation operation) throws Exception {
        OperationType operationType = operation.getStyle();
        if (isServerSide) {
            if (null != operationType) {
                if (operationType.equals(OperationType.REQUEST_RESPONSE))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_OUT;

                if (operationType.equals(OperationType.ONE_WAY)) {
                    if (operation.getFaults().size() > 0) {
                        return WSDLConstants.WSDL20_2004Constants.MEP_URI_ROBUST_IN_ONLY;
                    }
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_ONLY;
                }

                if (operationType.equals(OperationType.NOTIFICATION))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_ONLY;

                if (operationType.equals(OperationType.SOLICIT_RESPONSE))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_IN;
                throw new Exception("Cannot Determine the MEP");
            }
        } else {
            if (null != operationType) {
                if (operationType.equals(OperationType.REQUEST_RESPONSE))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_IN;

                if (operationType.equals(OperationType.ONE_WAY))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_ONLY;

                if (operationType.equals(OperationType.NOTIFICATION))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_ONLY;

                if (operationType.equals(OperationType.SOLICIT_RESPONSE))
                    return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_OUT;
                throw new Exception("Cannot Determine the MEP");
            }
        }
        throw new Exception("Cannot Determine the MEP");
    }

    /**
     * Copies the extension attributes
     *
     * @param extAttributes
     * @param description
     * @param origin
     */
    private void copyExtensionAttributes(Map extAttributes,
                                         AxisDescription description, String origin) {

        QName key;
        QName value;

        for (Iterator iterator = extAttributes.keySet().iterator(); iterator
                .hasNext();) {
            key = (QName) iterator.next();

            if (Constants.URI_POLICY_NS.equals(key.getNamespaceURI())
                    && "PolicyURIs".equals(key.getLocalPart())) {

                value = (QName) extAttributes.get(key);
                String policyURIs = value.getLocalPart();

                if (policyURIs.length() != 0) {
                    String[] uris = policyURIs.split(" ");

                    PolicyReference ref;
                    for (int i = 0; i < uris.length; i++) {
                        ref = new PolicyReference();
                        ref.setURI(uris[i]);

                        if (PORT_TYPE.equals(origin)) {
                            PolicyInclude include = description
                                    .getPolicyInclude();
                            include.addPolicyRefElement(
                                    PolicyInclude.PORT_TYPE_POLICY, ref);
                        }
                    }
                }
            }
        }
    }

    /**
     * Process the policy definitions
     *
     * @param definition
     */
    private void processPoliciesInDefintion(Definition definition) {
        List extElements = definition.getExtensibilityElements();

        ExtensibilityElement extElement;
        for (Iterator iterator = extElements.iterator(); iterator.hasNext();) {
            extElement = (ExtensibilityElement) iterator.next();

            if (extElement instanceof UnknownExtensibilityElement) {
                UnknownExtensibilityElement unknown = (UnknownExtensibilityElement) extElement;
                if (WSDLConstants.WSDL11Constants.POLICY.equals(unknown
                        .getElementType())) {

                    Policy policy = (Policy) PolicyUtil
                            .getPolicyComponent(unknown.getElement());

                    String key;
                    if ((key = policy.getName()) != null
                            || (key = policy.getId()) != null) {
                        registry.register(key, policy);
                    }

                }
            }
        }
    }

    /**
     * Inner class declaration for the processing exceptions
     */
    public static class WSDLProcessingException extends RuntimeException {
        public WSDLProcessingException() {
        }

        public WSDLProcessingException(String message) {
            super(message);
        }

        public WSDLProcessingException(Throwable cause) {
            super(cause);
        }

        public WSDLProcessingException(String message, Throwable cause) {
            super(message, cause);
        }

    }
}