/*

 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.ws.wsdl.writer;

import static com.sun.xml.internal.bind.v2.schemagen.Util.*;

import com.oracle.webservices.internal.api.databinding.WSDLResolver;

import com.sun.xml.internal.txw2.TXW;

import com.sun.xml.internal.txw2.TypedXmlWriter;

import com.sun.xml.internal.txw2.output.ResultFactory;

import com.sun.xml.internal.txw2.output.XmlSerializer;

import com.sun.xml.internal.txw2.output.TXWResult;

import com.sun.xml.internal.ws.api.SOAPVersion;

import com.sun.xml.internal.ws.api.WSBinding;

import com.sun.xml.internal.ws.api.model.JavaMethod;

import com.sun.xml.internal.ws.api.model.MEP;

import com.sun.xml.internal.ws.api.model.ParameterBinding;

import com.sun.xml.internal.ws.api.model.SEIModel;

import com.sun.xml.internal.ws.api.model.soap.SOAPBinding;

import com.sun.xml.internal.ws.api.server.Container;

import com.sun.xml.internal.ws.api.wsdl.writer.WSDLGeneratorExtension;

import com.sun.xml.internal.ws.api.wsdl.writer.WSDLGenExtnContext;

import com.sun.xml.internal.ws.model.AbstractSEIModelImpl;

import com.sun.xml.internal.ws.model.CheckedExceptionImpl;

import com.sun.xml.internal.ws.model.JavaMethodImpl;

import com.sun.xml.internal.ws.model.ParameterImpl;

import com.sun.xml.internal.ws.model.WrapperParameter;

import com.sun.xml.internal.ws.util.xml.XmlUtil;

import com.sun.xml.internal.ws.wsdl.parser.SOAPConstants;

import com.sun.xml.internal.ws.wsdl.parser.WSDLConstants;

import com.sun.xml.internal.ws.wsdl.writer.document.Binding;

import com.sun.xml.internal.ws.wsdl.writer.document.BindingOperationType;

import com.sun.xml.internal.ws.wsdl.writer.document.Definitions;

import com.sun.xml.internal.ws.wsdl.writer.document.Fault;

import com.sun.xml.internal.ws.wsdl.writer.document.FaultType;

import com.sun.xml.internal.ws.wsdl.writer.document.Import;

import com.sun.xml.internal.ws.wsdl.writer.document.Message;

import com.sun.xml.internal.ws.wsdl.writer.document.Operation;

import com.sun.xml.internal.ws.wsdl.writer.document.ParamType;

import com.sun.xml.internal.ws.wsdl.writer.document.Port;

import com.sun.xml.internal.ws.wsdl.writer.document.PortType;

import com.sun.xml.internal.ws.wsdl.writer.document.Service;

import com.sun.xml.internal.ws.wsdl.writer.document.Types;

import com.sun.xml.internal.ws.wsdl.writer.document.soap.Body;

import com.sun.xml.internal.ws.wsdl.writer.document.soap.BodyType;

import com.sun.xml.internal.ws.wsdl.writer.document.soap.Header;

import com.sun.xml.internal.ws.wsdl.writer.document.soap.SOAPAddress;

import com.sun.xml.internal.ws.wsdl.writer.document.soap.SOAPFault;

import com.sun.xml.internal.ws.wsdl.writer.document.xsd.Schema;

import com.sun.xml.internal.ws.spi.db.BindingContext;

import com.sun.xml.internal.ws.spi.db.BindingHelper;

import com.sun.xml.internal.ws.spi.db.TypeInfo;

import com.sun.xml.internal.ws.spi.db.WrapperComposite;

import com.sun.xml.internal.ws.util.RuntimeVersion;

import com.sun.xml.internal.ws.policy.jaxws.PolicyWSDLGeneratorExtension;

import com.sun.xml.internal.ws.encoding.soap.streaming.SOAPNamespaceConstants;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.Element;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.ComplexType;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.ExplicitGroup;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.LocalElement;

import javax.jws.soap.SOAPBinding.Style;

import javax.jws.soap.SOAPBinding.Use;

import javax.xml.bind.SchemaOutputResolver;

import javax.xml.namespace.QName;

import javax.xml.transform.Result;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMResult;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.sax.SAXResult;

import javax.xml.ws.Holder;

import javax.xml.ws.WebServiceException;

import org.w3c.dom.Document;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

/**

 * Class used to generate WSDLs from a {@link SEIModel}.

 *

 * @author WS Development Team

 */

public class WSDLGenerator {

    private JAXWSOutputSchemaResolver resolver;

    private WSDLResolver wsdlResolver = null;

    private AbstractSEIModelImpl model;

    private Definitions serviceDefinitions;

    private Definitions portDefinitions;

    private Types types;

    /**

     * Constant String for ".wsdl"

     */

    private static final String DOT_WSDL = ".wsdl";

    /**

     * Constant String appended to response message names

     */

    private static final String RESPONSE = "Response";

    /**

     * constant String used for part name for wrapped request messages

     */

    private static final String PARAMETERS = "parameters";

    /**

     * the part name for unwrappable response messages

     */

    private static final String RESULT = "parameters";

    /**

     * the part name for response messages that are not unwrappable

     */

    private static final String UNWRAPPABLE_RESULT = "result";

    /**

     * The WSDL namespace

     */

    private static final String WSDL_NAMESPACE = WSDLConstants.NS_WSDL;

    /**

     * the XSD namespace

     */

    private static final String XSD_NAMESPACE = SOAPNamespaceConstants.XSD;

    /**

     * the namespace prefix to use for the XSD namespace

     */

    private static final String XSD_PREFIX = "xsd";

    /**

     * The SOAP 1.1 namespace

     */

    private static final String SOAP11_NAMESPACE = SOAPConstants.NS_WSDL_SOAP;

    /**

     * The SOAP 1.2 namespace

     */

    private static final String SOAP12_NAMESPACE = SOAPConstants.NS_WSDL_SOAP12;

    /**

     * The namespace prefix to use for the SOAP 1.1 namespace

     */

    private static final String SOAP_PREFIX = "soap";

    /**

     * The namespace prefix to use for the SOAP 1.2 namespace

     */

    private static final String SOAP12_PREFIX = "soap12";

    /**

     * The namespace prefix to use for the targetNamespace

     */

    private static final String TNS_PREFIX = "tns";

    /**

     * Constant String "document" used to specify <code>document</code> style

     * soapBindings

     */

    private static final String DOCUMENT = "document";

    /**

     * Constant String "rpc" used to specify <code>rpc</code> style

     * soapBindings

     */

    private static final String RPC = "rpc";

    /**

     * Constant String "literal" used to create <code>literal</code> use binddings

     */

    private static final String LITERAL = "literal";

    /**

     * Constant String to flag the URL to replace at runtime for the endpoint

     */

    private static final String REPLACE_WITH_ACTUAL_URL = "REPLACE_WITH_ACTUAL_URL";

    private Set<QName> processedExceptions = new HashSet<QName>();

    private WSBinding binding;

    private String wsdlLocation;

    private String portWSDLID;

    private String schemaPrefix;

    private WSDLGeneratorExtension extension;

    List<WSDLGeneratorExtension> extensionHandlers;

    private String endpointAddress = REPLACE_WITH_ACTUAL_URL;

    private Container container;

    private final Class implType;

    private boolean inlineSchemas;      // TODO

    private final boolean disableSecureXmlProcessing;

    /**

     * Creates the WSDLGenerator

     * @param model The {@link AbstractSEIModelImpl} used to generate the WSDL

     * @param wsdlResolver The {@link WSDLResolver} to use resovle names while generating the WSDL

     * @param binding specifies which {@link javax.xml.ws.BindingType} to generate

     * @param extensions an array {@link WSDLGeneratorExtension} that will

     * be invoked to generate WSDL extensions

     */

    public WSDLGenerator(AbstractSEIModelImpl model, WSDLResolver wsdlResolver, WSBinding binding, Container container,

                         Class implType, boolean inlineSchemas, WSDLGeneratorExtension... extensions) {

        this(model, wsdlResolver, binding, container, implType, inlineSchemas, false, extensions);

    }

    /**

     * Creates the WSDLGenerator

     * @param model The {@link AbstractSEIModelImpl} used to generate the WSDL

     * @param wsdlResolver The {@link WSDLResolver} to use resovle names while generating the WSDL

     * @param binding specifies which {@link javax.xml.ws.BindingType} to generate

     * @param disableSecureXmlProcessing specifies whether to disable the secure xml processing feature

     * @param extensions an array {@link WSDLGeneratorExtension} that will

     * be invoked to generate WSDL extensions

     */

    public WSDLGenerator(AbstractSEIModelImpl model, WSDLResolver wsdlResolver, WSBinding binding, Container container,

                         Class implType, boolean inlineSchemas, boolean disableSecureXmlProcessing,

                         WSDLGeneratorExtension... extensions) {

        this.model = model;

        resolver = new JAXWSOutputSchemaResolver();

        this.wsdlResolver = wsdlResolver;

        this.binding = binding;

        this.container = container;

        this.implType = implType;

        extensionHandlers = new ArrayList<WSDLGeneratorExtension>();

        this.inlineSchemas = inlineSchemas;

        this.disableSecureXmlProcessing = disableSecureXmlProcessing;

        // register handlers for default extensions

        register(new W3CAddressingWSDLGeneratorExtension());

        register(new W3CAddressingMetadataWSDLGeneratorExtension());

        register(new PolicyWSDLGeneratorExtension());

        if (container != null) { // on server

            WSDLGeneratorExtension[] wsdlGeneratorExtensions = container.getSPI(WSDLGeneratorExtension[].class);

            if (wsdlGeneratorExtensions != null) {

                for (WSDLGeneratorExtension wsdlGeneratorExtension : wsdlGeneratorExtensions) {

                    register(wsdlGeneratorExtension);

                }

            }

        }

        for (WSDLGeneratorExtension w : extensions)

            register(w);

        this.extension = new WSDLGeneratorExtensionFacade(extensionHandlers.toArray(new WSDLGeneratorExtension[0]));

    }

    /**

     * Sets the endpoint address string to be written.

     * Defaults to {@link #REPLACE_WITH_ACTUAL_URL}.

     *

     * @param address wsdl:port/soap:address/[@location] value

     */

    public void setEndpointAddress(String address) {

        this.endpointAddress = address;

    }

    protected String mangleName(String name) {

        return BindingHelper.mangleNameToClassName(name);

    }

    /**

     * Performes the actual WSDL generation

     */

    public void doGeneration() {

        XmlSerializer serviceWriter;

        XmlSerializer portWriter = null;

        String fileName = mangleName(model.getServiceQName().getLocalPart());

        Result result = wsdlResolver.getWSDL(fileName + DOT_WSDL);

        wsdlLocation = result.getSystemId();

        serviceWriter = new CommentFilter(ResultFactory.createSerializer(result));

        if (model.getServiceQName().getNamespaceURI().equals(model.getTargetNamespace())) {

            portWriter = serviceWriter;

            schemaPrefix = fileName + "_";

        } else {

            String wsdlName = mangleName(model.getPortTypeName().getLocalPart());

            if (wsdlName.equals(fileName))

                wsdlName += "PortType";

            Holder<String> absWSDLName = new Holder<String>();

            absWSDLName.value = wsdlName + DOT_WSDL;

            result = wsdlResolver.getAbstractWSDL(absWSDLName);

            if (result != null) {

                portWSDLID = result.getSystemId();

                if (portWSDLID.equals(wsdlLocation)) {

                    portWriter = serviceWriter;

                } else {

                    portWriter = new CommentFilter(ResultFactory.createSerializer(result));

                }

            } else {

                portWSDLID = absWSDLName.value;

            }

            schemaPrefix = new java.io.File(portWSDLID).getName();

            int idx = schemaPrefix.lastIndexOf('.');

            if (idx > 0)

                schemaPrefix = schemaPrefix.substring(0, idx);

            schemaPrefix = mangleName(schemaPrefix) + "_";

        }

        generateDocument(serviceWriter, portWriter);

    }

    /**

     * Writing directly to XmlSerializer is a problem, since it doesn't suppress

     * xml declaration. Creating filter so that comment is written before TXW writes

     * anything in the WSDL.

     */

    private static class CommentFilter implements XmlSerializer {

        final XmlSerializer serializer;

        private static final String VERSION_COMMENT =

        CommentFilter(XmlSerializer serializer) {

            this.serializer = serializer;

        }

        @Override

        public void startDocument() {

            serializer.startDocument();

            comment(new StringBuilder(VERSION_COMMENT));

            text(new StringBuilder("\n"));

        }

        @Override

        public void beginStartTag(String uri, String localName, String prefix) {

            serializer.beginStartTag(uri, localName, prefix);

        }

        @Override

        public void writeAttribute(String uri, String localName, String prefix, StringBuilder value) {

            serializer.writeAttribute(uri, localName, prefix, value);

        }

        @Override

        public void writeXmlns(String prefix, String uri) {

            serializer.writeXmlns(prefix, uri);

        }

        @Override

        public void endStartTag(String uri, String localName, String prefix) {

            serializer.endStartTag(uri, localName, prefix);

        }

        @Override

        public void endTag() {

            serializer.endTag();

        }

        @Override

        public void text(StringBuilder text) {

            serializer.text(text);

        }

        @Override

        public void cdata(StringBuilder text) {

            serializer.cdata(text);

        }

        @Override

        public void comment(StringBuilder comment) {

            serializer.comment(comment);

        }

        @Override

        public void endDocument() {

            serializer.endDocument();

        }

        @Override

        public void flush() {

            serializer.flush();

        }

    }

    private void generateDocument(XmlSerializer serviceStream, XmlSerializer portStream) {

        serviceDefinitions = TXW.create(Definitions.class, serviceStream);

        serviceDefinitions._namespace(WSDL_NAMESPACE, "");//WSDL_PREFIX);

        serviceDefinitions._namespace(XSD_NAMESPACE, XSD_PREFIX);

        serviceDefinitions.targetNamespace(model.getServiceQName().getNamespaceURI());

        serviceDefinitions._namespace(model.getServiceQName().getNamespaceURI(), TNS_PREFIX);

        if (binding.getSOAPVersion() == SOAPVersion.SOAP_12)

            serviceDefinitions._namespace(SOAP12_NAMESPACE, SOAP12_PREFIX);

        else

            serviceDefinitions._namespace(SOAP11_NAMESPACE, SOAP_PREFIX);

        serviceDefinitions.name(model.getServiceQName().getLocalPart());

        WSDLGenExtnContext serviceCtx = new WSDLGenExtnContext(serviceDefinitions, model, binding, container, implType);

        extension.start(serviceCtx);

        if (serviceStream != portStream && portStream != null) {

            // generate an abstract and concrete wsdl

            portDefinitions = TXW.create(Definitions.class, portStream);

            portDefinitions._namespace(WSDL_NAMESPACE, "");//WSDL_PREFIX);

            portDefinitions._namespace(XSD_NAMESPACE, XSD_PREFIX);

            if (model.getTargetNamespace() != null) {

                portDefinitions.targetNamespace(model.getTargetNamespace());

                portDefinitions._namespace(model.getTargetNamespace(), TNS_PREFIX);

            }

            String schemaLoc = relativize(portWSDLID, wsdlLocation);

            Import _import = serviceDefinitions._import().namespace(model.getTargetNamespace());

            _import.location(schemaLoc);

        } else if (portStream != null) {

            // abstract and concrete are the same

            portDefinitions = serviceDefinitions;

        } else {

            // import a provided abstract wsdl

            String schemaLoc = relativize(portWSDLID, wsdlLocation);

            Import _import = serviceDefinitions._import().namespace(model.getTargetNamespace());

            _import.location(schemaLoc);

        }

        extension.addDefinitionsExtension(serviceDefinitions);

        if (portDefinitions != null) {

            generateTypes();

            generateMessages();

            generatePortType();

        }

        generateBinding();

        generateService();

        //Give a chance to WSDLGeneratorExtensions to write stuff before closing </wsdl:defintions>

        extension.end(serviceCtx);

        serviceDefinitions.commit();

        if (portDefinitions != null && portDefinitions != serviceDefinitions)

            portDefinitions.commit();

    }

    /**

     * Generates the types section of the WSDL

     */

    protected void generateTypes() {

        types = portDefinitions.types();

        if (model.getBindingContext() != null) {

            if (inlineSchemas && model.getBindingContext().getClass().getName().indexOf("glassfish") == -1) {

                resolver.nonGlassfishSchemas = new ArrayList<DOMResult>();

            }

            try {

                model.getBindingContext().generateSchema(resolver);

            } catch (IOException e) {

                // TODO locallize and wrap this

                throw new WebServiceException(e.getMessage());

            }

        }

        if (resolver.nonGlassfishSchemas != null) {

            TransformerFactory tf = XmlUtil.newTransformerFactory(!disableSecureXmlProcessing);

            try {

                Transformer t = tf.newTransformer();

                for (DOMResult xsd : resolver.nonGlassfishSchemas) {

                    Document doc = (Document) xsd.getNode();

                    SAXResult sax = new SAXResult(new TXWContentHandler(types));

                    t.transform(new DOMSource(doc.getDocumentElement()), sax);

                }

            } catch (TransformerConfigurationException e) {

                throw new WebServiceException(e.getMessage(), e);

            } catch (TransformerException e) {

                throw new WebServiceException(e.getMessage(), e);

            }

        }

        generateWrappers();

    }

    void generateWrappers() {

        List<WrapperParameter> wrappers = new ArrayList<WrapperParameter>();

        for (JavaMethodImpl method : model.getJavaMethods()) {

            if(method.getBinding().isRpcLit()) continue;

            for (ParameterImpl p : method.getRequestParameters()) {

                if (p instanceof WrapperParameter) {

                    if (WrapperComposite.class.equals((((WrapperParameter)p).getTypeInfo().type))) {

                        wrappers.add((WrapperParameter)p);

                    }

                }

            }

            for (ParameterImpl p : method.getResponseParameters()) {

                if (p instanceof WrapperParameter) {

                    if (WrapperComposite.class.equals((((WrapperParameter)p).getTypeInfo().type))) {

                        wrappers.add((WrapperParameter)p);

                    }

                }

            }

        }

        if (wrappers.isEmpty()) return;

        HashMap<String, Schema> xsds = new HashMap<String, Schema>();

        for(WrapperParameter wp : wrappers) {

            String tns = wp.getName().getNamespaceURI();

            Schema xsd = xsds.get(tns);

            if (xsd == null) {

                xsd = types.schema();

                xsd.targetNamespace(tns);

                xsds.put(tns, xsd);

            }

            Element e =  xsd._element(Element.class);

            e._attribute("name", wp.getName().getLocalPart());

            e.type(wp.getName());

            ComplexType ct =  xsd._element(ComplexType.class);

            ct._attribute("name", wp.getName().getLocalPart());

            ExplicitGroup sq = ct.sequence();

            for (ParameterImpl p : wp.getWrapperChildren() ) {

                if (p.getBinding().isBody()) {

                    LocalElement le = sq.element();