package org.apache.axis2.description;

import org.apache.axis2.AxisFault;
import org.apache.axis2.namespace.Constants;
import org.apache.axis2.util.PolicyUtil;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.woden.WSDLException;
import org.apache.woden.WSDLFactory;
import org.apache.woden.WSDLReader;
import org.apache.woden.WSDLSource;
import org.apache.woden.internal.DOMWSDLFactory;
import org.apache.woden.schema.Schema;
import org.apache.woden.wsdl20.Binding;
import org.apache.woden.wsdl20.Description;
import org.apache.woden.wsdl20.Endpoint;
import org.apache.woden.wsdl20.Interface;
import org.apache.woden.wsdl20.InterfaceFaultReference;
import org.apache.woden.wsdl20.InterfaceMessageReference;
import org.apache.woden.wsdl20.InterfaceOperation;
import org.apache.woden.wsdl20.Service;
import org.apache.woden.wsdl20.enumeration.Direction;
import org.apache.woden.wsdl20.extensions.ExtensionElement;
import org.apache.woden.wsdl20.extensions.UnknownExtensionElement;
import org.apache.woden.wsdl20.xml.BindingElement;
import org.apache.woden.wsdl20.xml.DescriptionElement;
import org.apache.woden.wsdl20.xml.InterfaceElement;
import org.apache.woden.wsdl20.xml.InterfaceFaultReferenceElement;
import org.apache.woden.wsdl20.xml.InterfaceMessageReferenceElement;
import org.apache.woden.wsdl20.xml.InterfaceOperationElement;
import org.apache.woden.wsdl20.xml.TypesElement;
import org.apache.ws.commons.schema.XmlSchema;
import org.apache.ws.commons.schema.utils.NamespaceMap;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.InputStream;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/*
 * 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 WSDL20ToAxisServiceBuilder extends WSDLToAxisServiceBuilder {

    protected Description description;

    private String wsdlURI;

    // FIXME @author Chathura THis shoud be a URI. Find whats used by
    // woden.
    private static String RPC = "rpc";

    protected String interfaceName;

    private String savedTargetNamespace;

    private Map namespacemap;
    
    private NamespaceMap stringBasedNamespaceMap;
    
    private boolean setupComplete = false;

    public WSDL20ToAxisServiceBuilder(InputStream in, QName serviceName,
                                      String interfaceName) {
        this.in = in;
        this.serviceName = serviceName;
        this.interfaceName = interfaceName;
        this.axisService = new AxisService();
        setPolicyRegistryFromService(axisService);
    }

    public WSDL20ToAxisServiceBuilder(String wsdlUri,
                                      String name, String interfaceName)  throws Exception  {
        WSDLReader wsdlReader = WSDLFactory.newInstance().newWSDLReader();
        DescriptionElement descriptionElement = wsdlReader.readWSDL(wsdlUri);
        savedTargetNamespace = descriptionElement.getTargetNamespace()
                .toString();
        namespacemap = descriptionElement.getNamespaces();
        this.description = descriptionElement.toComponent();
        this.serviceName = null;
        if(name != null) {
            serviceName = new QName(descriptionElement.getTargetNamespace().toString(), name);
        }
        this.interfaceName = interfaceName;
        this.axisService = new AxisService();
        setPolicyRegistryFromService(axisService);
    }

    public WSDL20ToAxisServiceBuilder(String wsdlUri, QName serviceName) {
        super(null, serviceName);
        this.wsdlURI = wsdlUri;
    }

    public WSDL20ToAxisServiceBuilder(String wsdlUri, AxisService service) {
        super(null, service);
        this.wsdlURI = wsdlUri;
    }

    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 wsdlDescriptionParamter = new Parameter();
            wsdlDescriptionParamter.setName(WSDLConstants.WSDL_20_DESCRIPTION);
            wsdlDescriptionParamter.setValue(description);
            axisService.addParameter(wsdlDescriptionParamter);

            if (description == null) {
                return null;
            }
            // setting target name space
            axisService.setTargetNamespace(savedTargetNamespace);

            // if there are documentation elements in the root. Lets add them as the service description
            // but since there can be multiple documentation elements, lets only add the first one
//            DocumentationElement[] documentationElements = description.toElement().getDocumentationElements();
//            if (documentationElements != null && documentationElements.length > 0) {
//                axisService.setServiceDescription(documentationElements[0].getContent().toString());
//            }

            // adding ns in the original WSDL
            // processPoliciesInDefintion(wsdl4jDefinition); TODO : Defering policy handling for now - Chinthaka
            // policy support

            // schema generation

            // Create the namespacemap

            axisService.setNameSpacesMap(stringBasedNamespaceMap);
            // TypeDefinition[] typeDefinitions =
            // description.getTypeDefinitions();
            // for(int i=0; i<typeDefinitions.length; i++){
            // if("org.apache.ws.commons.schema".equals(typeDefinitions[i].getContentModel())){
            // axisService.addSchema((XmlSchema)typeDefinitions[i].getContent());
            // }else
            // if("org.w3c.dom".equals(typeDefinitions[i].getContentModel())){
            // axisService.addSchema(getXMLSchema((Element)typeDefinitions[i].getContent(),
            // null));
            // }
            //                
            // }

            TypesElement typesElement = description.toElement()
                    .getTypesElement();
            if (typesElement != null) {
                Schema[] schemas = typesElement.getSchemas();
                for (int i = 0; i < schemas.length; i++) {
                    XmlSchema schemaDefinition = schemas[i].getSchemaDefinition();


                    // WSDL 2.0 spec requires that even the built-in schema should be returned
                    // once asked for schema definitions. But for data binding purposes we can ignore that
                    if (schemaDefinition != null && !Constants.URI_2001_SCHEMA_XSD.equals(schemaDefinition.getTargetNamespace())) {
                        axisService.addSchema(schemaDefinition);
                    }
                }
            }

            Binding binding = findBinding(description);
            // //////////////////(1.2) /////////////////////////////
            // // create new Schema extensions element for wrapping
            // Element[] schemaElements =
            // generateWrapperSchema(descriptionElement,
            // binding);
            // 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));
            // }
            // }
            // }
            processBinding(binding, description);
            return axisService;
        } catch (Exception 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 WSDL20ToAllAxisServicesBuilder will call populateService
     * for each endpoint in the WSDL. Separating the non-service specific
     * information here allows WSDL20ToAllAxisServicesBuilder to only do this
     * work 1 time per WSDL, instead of for each endpoint on each service.
     * 
     * @throws AxisFault
     */
    protected void setup() throws AxisFault {
        if (setupComplete) { // already setup, just do nothing and return
            return;
        }
        try {
            if (description == null) {

                DescriptionElement descriptionElement = null;
                if (wsdlURI != null && !"".equals(wsdlURI)) {
                    descriptionElement = readInTheWSDLFile(wsdlURI);
                } else if (in != null) {

                    DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
                            .newInstance();
                    documentBuilderFactory.setNamespaceAware(true);
                    DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
                    Document document = documentBuilder.parse(in);

                    WSDLReader reader = DOMWSDLFactory.newInstance().newWSDLReader();
                    WSDLSource wsdlSource = reader.createWSDLSource();
                    wsdlSource.setSource(document.getDocumentElement());
                    // wsdlSource.setBaseURI(new URI(getBaseUri()));
                    descriptionElement = reader.readWSDL(wsdlSource);
                } else {
                    throw new AxisFault("No resources found to read the wsdl");
                }

                savedTargetNamespace = descriptionElement.getTargetNamespace().toString();
                namespacemap = descriptionElement.getNamespaces();
                this.description = descriptionElement.toComponent();

            }
            // Create the namespacemap

            stringBasedNamespaceMap = new NamespaceMap();
            Iterator iterator = namespacemap.keySet().iterator();
            while (iterator.hasNext()) {
                String key = (String) iterator.next();
                stringBasedNamespaceMap.put(key, (namespacemap.get(key)).toString());
            }

            setupComplete = true;
        } catch (AxisFault e) {
            throw e; // just rethrow AxisFaults
        } catch (Exception e) {
            throw new AxisFault(e);
        }
    }
    
    private void processBinding(Binding binding, Description description)
            throws Exception {
        if (binding != null) {

            // TODO @author Chathura have to copy policy elements.
            // copyExtensibleElements(binding.getExtensibilityElements(), dif,
            // axisService, BINDING);

            Interface serviceInterface = binding.getInterface();

            processInterface(serviceInterface, description);

        }
    }

    private void processInterface(Interface serviceInterface, Description dif)
            throws Exception {

        // TODO @author Chathura copy the policy elements
        // copyExtensionAttributes(wsdl4jPortType.getExtensionAttributes(),
        // axisService, PORT_TYPE);

        InterfaceOperation[] interfaceOperations = serviceInterface
                .getInterfaceOperations();
        for (int i = 0; i < interfaceOperations.length; i++) {
            axisService.addOperation(populateOperations(interfaceOperations[i],
                    description));
        }

    }

    private AxisOperation populateOperations(InterfaceOperation operation,
                                             Description description) throws Exception {
        QName opName = operation.getName();
        // Copy Name Attribute
        AxisOperation axisOperation = axisService.getOperation(opName);
        if (axisOperation == null) {
            String MEP = operation.getMessageExchangePattern().toString();
            axisOperation = AxisOperationFactory.getOperationDescription(MEP);
            axisOperation.setName(opName);

            // All policy includes must share same registry
            PolicyInclude pi = axisOperation.getPolicyInclude();
            if (pi == null) {
                pi = new PolicyInclude();
                axisOperation.setPolicyInclude(pi);
            }
            pi.setPolicyRegistry(registry);
        }

        // assuming the style of the operations of WSDL 2.0 is always document.
        axisOperation.setStyle("document");

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

        InterfaceMessageReference[] interfaceMessageReferences = operation
                .getInterfaceMessageReferences();
        for (int i = 0; i < interfaceMessageReferences.length; i++) {
            InterfaceMessageReferenceElement messageReference = interfaceMessageReferences[i].toElement();
            if (messageReference.getMessageLabel().equals(
                    messageReference.getMessageLabel().IN)) {
                // Its an input message

                if (isServerSide) {
                    AxisMessage inMessage = axisOperation
                            .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);

                    inMessage.setElementQName(messageReference.getElementName());
                    inMessage.setName(messageReference.getElementName().getLocalPart());
                    // TODO copy policy elements
                } else {
                    AxisMessage inMessage = axisOperation
                            .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);

                    inMessage.setElementQName(messageReference.getElementName());
                    inMessage.setName(messageReference.getElementName().getLocalPart());
                    // TODO copy policy elements
                }
            } else if (messageReference.getMessageLabel().equals(
                    messageReference.getMessageLabel().OUT)) {
                if (isServerSide) {
                    AxisMessage outMessage = axisOperation
                            .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);

                    outMessage.setElementQName(messageReference.getElementName());
                    outMessage.setName(messageReference.getElementName().getLocalPart());
//                  TODO copy policy elements
                } else {
                    AxisMessage outMessage = axisOperation
                            .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);

                    outMessage.setElementQName(messageReference.getElementName());
                    outMessage.setName(messageReference.getElementName().getLocalPart());
//                  TODO copy policy elements
                }
            }

        }


        // add operation level faults
        InterfaceFaultReference[] faults = operation.getInterfaceFaultReferences();
        for (int i = 0; i < faults.length; i++) {
            AxisMessage faultMessage = new AxisMessage();

            InterfaceFaultReferenceElement interfaceFaultReferenceElement = faults[i].toElement();
            faultMessage.setDirection(interfaceFaultReferenceElement.getDirection().toString());

            faultMessage.setElementQName(interfaceFaultReferenceElement.getInterfaceFaultElement().getElementName());
            faultMessage.setName(interfaceFaultReferenceElement.getRef().getLocalPart());
            axisOperation.setFaultMessages(faultMessage);
        }


        return axisOperation;
    }

    private void copyExtensibleElements(ExtensionElement[] extensionElement,
                                        DescriptionElement descriptionElement, AxisDescription description,
                                        String originOfExtensibilityElements) {
        for (int i = 0; i < extensionElement.length; i++) {
            ExtensionElement element = extensionElement[i];

            if (element instanceof UnknownExtensionElement) {
                UnknownExtensionElement unknown = (UnknownExtensionElement) element;

                // look for the SOAP 1.2 stuff here. WSDL4j does not understand
                // SOAP 1.2 things
                // TODO this is wrong. Compare this with WSDL 2.0 QName
                if (WSDLConstants.WSDL11Constants.SOAP_12_OPERATION.equals(unknown
                        .getExtensionType())) {
                    Element unknownElement = unknown.getElement();
                    if (description instanceof AxisOperation) {
                        AxisOperation axisOperation = (AxisOperation) description;
                        String style = unknownElement.getAttribute("style");
                        if (style != null) {
                            axisOperation.setStyle(style);
                        }
                        axisOperation.setSoapAction(unknownElement
                                .getAttribute("soapAction"));
                    }
                } else if (WSDLConstants.WSDL11Constants.SOAP_12_HEADER.equals(unknown
                        .getExtensionType())) {
                    // TODO : implement thid
                } else if (WSDLConstants.WSDL11Constants.SOAP_12_BINDING.equals(unknown
                        .getExtensionType())) {
                    style = unknown.getElement().getAttribute("style");
                    axisService.setSoapNsUri(element.getExtensionType()
                            .getNamespaceURI());
                } else if (WSDLConstants.WSDL11Constants.SOAP_12_ADDRESS.equals(unknown
                        .getExtensionType())) {
                    axisService.setEndpoint(unknown.getElement().getAttribute(
                            "location"));
                } else if (WSDLConstants.WSDL11Constants.POLICY.equals(unknown
                        .getExtensionType())) {
                    // TODO


                } else if (WSDLConstants.WSDL11Constants.POLICY_REFERENCE.equals(unknown
                        .getExtensionType())) {
                    // TODO

                    
                } else {
                    // TODO : we are ignored that.
                }

                // } else if (element 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(),
                // wsdl4jDefinition.getDocumentBaseURI()));
                // } else if
                // (SOAPConstants.Q_ELEM_SOAP_OPERATION.equals(wsdl4jElement
                // .getElementType())) {
                // 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
                // (SOAPConstants.Q_ELEM_SOAP_HEADER.equals(wsdl4jElement
                // .getElementType())) {
                // 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());
                // Part msgPart = msg.getPart(soapHeader.getPart());
                // headerMessage.setElement(msgPart.getElementName());
                // }
                // headerMessage.setMessage(soapHeader.getMessage());
                //
                // headerMessage.setPart(soapHeader.getPart());
                // if (description instanceof AxisMessage) {
                // ((AxisMessage) description).addSoapHeader(headerMessage);
                // }
                // } else if
                // (SOAPConstants.Q_ELEM_SOAP_BINDING.equals(wsdl4jElement
                // .getElementType())) {
                // SOAPBinding soapBinding = (SOAPBinding) wsdl4jElement;
                // style = soapBinding.getStyle();
                // axisService.setSoapNsUri(soapBinding.getElementType()
                // .getNamespaceURI());
                // }
            }
        }
    }

    private Binding findBinding(Description discription) throws AxisFault {
        Service[] services = discription.getServices();
        Service service = null;
        Endpoint endpoint = null;
        Binding binding = null;

        if (services.length == 0) {
            throw new AxisFault("No service found in the WSDL");
        }

        if (serviceName != null) {
            for (int i = 0; i < services.length; i++) {
                if (serviceName.equals(services[i].getName())) {
                    service = services[i];
                    break;  // found it. Stop looking.
                }
            }
            if (service == null) {
                throw new AxisFault("Service not found the WSDL "
                        + serviceName.getLocalPart());
            }
        } else {
            // If no particular service is mentioned select the first one.
            service = services[0];
        }
        // FIXME @author Chathura get the policy stuff to be copied
        // copyExtensibleElements(service.getExtensibilityElements(), dif,
        // axisService, SERVICE);
        Endpoint[] endpoints = service.getEndpoints();
        if (this.interfaceName != null) {

            if (endpoints.length == 0) {
                throw new AxisFault("No Endpoints/Ports found in the service:"
                        + service.getName().getLocalPart());
            }

            for (int i = 0; i < endpoints.length; ++i) {
                if (this.interfaceName.equals(endpoints[i].getName().toString())) {
                    endpoint = endpoints[i];
                    break;  // found it.  Stop looking
                }
            }
            if (endpoint == null) {
                throw new AxisFault("No port found for the given name :"
                        + this.interfaceName);
            }
        } else {
            // if no particular endpoint is specified use the first one.
            endpoint = endpoints[0];

        }
        axisService.setName(service.getName().getLocalPart());
        if (endpoint != null) {
            // FIXME @author Chathura copy in the policy stuff
            // copyExtensibleElements(port.getExtensibilityElements(), dif,
            // axisService, PORT);
            axisService.setEndpoint(endpoint.getAddress().toString());
            binding = endpoint.getBinding();
        }
        return binding;
    }

    private Element[] generateWrapperSchema(
            DescriptionElement wodenDescription, BindingElement binding) {

        List schemaElementList = new ArrayList();
        String targetNamespaceUri = wodenDescription.getTargetNamespace()
                .toString();

        // ///////////////////////////////////////////////////////////////////////////////////////////
        // if there are any bindings present then we have to process them. we
        // have to generate a schema
        // per binding (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
        // //////////////////////////////////////////////////////////////////////////////////////////

        // FIXME @author Chathura Once this method is done we could run the
        // basic codgen
        schemaElementList.add(createSchemaForInterface(binding
                .getInterfaceElement(), targetNamespaceUri,
                findWrapForceable(binding)));
        return (Element[]) schemaElementList
                .toArray(new Element[schemaElementList.size()]);
    }

    private Element createSchemaForInterface(InterfaceElement interfaceElement,
                                             String targetNamespaceUri, boolean forceWrapping) {

        // loop through the messages. We'll populate things map with the
        // relevant
        // messages
        // from the operations

        // this will have name (QName) as the key and
        // InterfaceMessageReferenceElement as the value
        Map messagesMap = new HashMap();

        // this will have operation name (a QName) as the key and
        // InterfaceMessageReferenceElement as the value
        Map inputOperationsMap = new HashMap();

        // this will have operation name (a QName) as the key and
        // InterfaceMessageReferenceElement as the value
        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!
        InterfaceOperationElement[] operationElements = interfaceElement
                .getInterfaceOperationElements();
        InterfaceOperationElement opElement;
        for (int k = 0; k < operationElements.length; k++) {
            opElement = operationElements[k];
            InterfaceMessageReferenceElement[] interfaceMessageReferenceElements = opElement
                    .getInterfaceMessageReferenceElements();

            for (int i = 0; i < interfaceMessageReferenceElements.length; i++) {
                InterfaceMessageReferenceElement interfaceMessageReferenceElement = interfaceMessageReferenceElements[i];
                String direction = interfaceMessageReferenceElement
                        .getDirection().toString();
                messagesMap.put(interfaceMessageReferenceElement
                        .getElementName(), interfaceMessageReferenceElement);
                if (Direction.IN.toString().equalsIgnoreCase(direction)) {
                    inputOperationsMap.put(opElement.getName(),
                            interfaceMessageReferenceElement);
                } else if (Direction.OUT.toString().equalsIgnoreCase(direction)) {
                    outputOperationsMap.put(opElement.getName(),
                            interfaceMessageReferenceElement);
                }
            }

            InterfaceFaultReferenceElement[] interfaceFaultReferenceElements = opElement
                    .getInterfaceFaultReferenceElements();

            for (int i = 0; i < interfaceFaultReferenceElements.length; i++) {
                InterfaceFaultReferenceElement interfaceFaultReferenceElement = interfaceFaultReferenceElements[i];
                String direction = interfaceFaultReferenceElement
                        .getDirection().toString();
                messagesMap.put(interfaceFaultReferenceElement.getRef(),
                        interfaceFaultReferenceElement);
                faultyOperationsMap.put(interfaceFaultReferenceElement
                        .getInterfaceFaultElement(),
                        interfaceFaultReferenceElement);
            }

        }

        // /////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 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;
        if (forceWrapping) {
            // just take all the messages and wrap them, we've been told to
            // force wrapping!
            keys = (QName[]) messagesMap.keySet().toArray(
                    new QName[messagesMap.size()]);
        } else {
            //
            QName[] allKeys = (QName[]) messagesMap.keySet().toArray(
                    new QName[messagesMap.size()]);
            List wrappableMessageNames = new ArrayList();
            boolean noMessagesTobeProcessed = true;

            // TODO Fix this
            // for (int i = 0; i < allKeys.length; i++) {
            // if (findWrapppable((Message) messagesMap.get(allKeys[i]))) {
            // noMessagesTobeProcessed = false;
            // //add that message to the list
            // wrappableMessageNames.add(allKeys[i]);
            // }
            // }
            if (noMessagesTobeProcessed) {
                return null;
            }

            keys = (QName[]) wrappableMessageNames
                    .toArray(new QName[wrappableMessageNames.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
        // String name = wsdl4jMessage.getQName().getLocalPart();
        // Element newComplexType = document.createElementNS(
        // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
        // + XML_SCHEMA_COMPLEX_TYPE_LOCAL_NAME);
        // newComplexType.setAttribute(XSD_NAME, name);
        //
        // Element cmplxContentSequence = 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);
        // //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());
        // }
        // cmplxContentSequence.appendChild(child);
        // }
        // newComplexType.appendChild(cmplxContentSequence);
        // //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);
        //
        // String typeValue = ((Message) inputOperationsMap.get(inputOpName))
        // .getQName().getLocalPart();
        // elementDeclaration.setAttribute(XSD_TYPE, AXIS2WRAPPED + ":"
        // + typeValue);
        // elementElementsList.add(elementDeclaration);
        // resolvedRpcWrappedElementMap.put(inputOpName, new QName(
        // targetNamespaceUri, 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 + "Response";
        // elementDeclaration = document.createElementNS(
        // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
        // + XML_SCHEMA_ELEMENT_LOCAL_NAME);
        // elementDeclaration.setAttribute(XSD_NAME, outputOpName);
        // String typeValue = ((Message) outputOperationsMap
        // .get(baseoutputOpName)).getQName().getLocalPart();
        // elementDeclaration.setAttribute(XSD_TYPE, AXIS2WRAPPED + ":"
        // + typeValue);
        // elementElementsList.add(elementDeclaration);
        // resolvedRpcWrappedElementMap.put(outputOpName, new QName(
        // targetNamespaceUri, 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);
        // String typeValue = ((Message) faultyOperationsMap
        // .get(baseFaultOpName)).getQName().getLocalPart();
        // elementDeclaration.setAttribute(XSD_TYPE, AXIS2WRAPPED + ":"
        // + typeValue);
        // elementElementsList.add(elementDeclaration);
        // resolvedRpcWrappedElementMap.put(baseFaultOpName, new QName(
        // targetNamespaceUri, baseFaultOpName, AXIS2WRAPPED));
        //
        // }
        //
        // //////////////////////////////////////////////////////////////////////////////////////////////
        // // Now we are done with processing the messages and generating the
        // right
        // // schema object model
        // // time to write out the schema
        // //////////////////////////////////////////////////////////////////////////////////////////////
        //
        // 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("http://www.w3.org/2000/xmlns/",
        // "xmlns:" + namespacePrefixMap.get(s).toString(), s);
        //
        // }
        //
        // //add the targetNamespace
        //
        // schemaElement.setAttributeNS("http://www.w3.org/2000/xmlns/",
        // XMLNS_AXIS2WRAPPED, targetNamespaceUri);
        // schemaElement.setAttribute(XSD_TARGETNAMESPACE, targetNamespaceUri);
        // schemaElement.setAttribute(XSD_ELEMENT_FORM_DEFAULT,
        // XSD_UNQUALIFIED);
        //
        // Element[] namespaceImports = (Element[]) namespaceImportsMap.values()
        // .toArray(new Element[namespaceImportsMap.size()]);
        // for (int i = 0; i < namespaceImports.length; i++) {
        // schemaElement.appendChild(namespaceImports[i]);
        //
        // }
        //
        // Element[] complexTypeElements = (Element[]) complexTypeElementsMap
        // .values().toArray(new Element[complexTypeElementsMap.size()]);
        // for (int i = 0; i < complexTypeElements.length; i++) {
        // schemaElement.appendChild(complexTypeElements[i]);
        //
        // }
        //
        // Element[] elementDeclarations = (Element[]) elementElementsList
        // .toArray(new Element[elementElementsList.size()]);
        // for (int i = 0; i < elementDeclarations.length; i++) {
        // schemaElement.appendChild(elementDeclarations[i]);
        //
        // }

        // return schemaElement;

        return null;
    }

    private boolean findWrapForceable(BindingElement binding) {
        boolean retVal = false;
        if (RPC.equalsIgnoreCase(binding.getInterfaceElement()
                .getStyleDefault().toString())) {
            return true;
        }
        if (!retVal) {
            InterfaceOperationElement[] operations = binding
                    .getInterfaceElement().getInterfaceOperationElements();
            for (int i = 0; i < operations.length; i++) {
                URI[] styles = operations[i].getStyle();
                for (int j = 0; j < styles.length; j++) {
                    if (RPC.equalsIgnoreCase(styles[j].toString())) {
                        return true;
                    }

                }
            }
        }
        return false;
    }

    private DescriptionElement readInTheWSDLFile(String wsdlURI)
            throws WSDLException {

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

        // TODO : I can not find a constant for this feature in WSDLReader
        // reader.setFeature("javax.wsdl.importDocuments", false);

//        reader.setFeature(WSDLReader.FEATURE_VERBOSE, false);
        return reader.readWSDL(wsdlURI);
    }

}