/*

 * 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.model;

import com.sun.istack.internal.NotNull;

import com.sun.istack.internal.localization.Localizable;

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

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

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

import com.sun.xml.internal.ws.api.databinding.DatabindingConfig;

import com.sun.xml.internal.ws.api.databinding.MetadataReader;

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

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

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

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

import com.sun.xml.internal.ws.api.model.wsdl.WSDLBoundOperation;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLInput;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLPart;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort;

import com.sun.xml.internal.ws.binding.WebServiceFeatureList;

import com.sun.xml.internal.ws.model.soap.SOAPBindingImpl;

import com.sun.xml.internal.ws.resources.ModelerMessages;

import com.sun.xml.internal.ws.resources.ServerMessages;

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

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

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

import static com.sun.xml.internal.ws.binding.WebServiceFeatureList.getSoapVersion;

import static com.sun.xml.internal.ws.model.Utils.REFLECTION_NAVIGATOR;

import javax.jws.*;

import javax.jws.WebParam.Mode;

import javax.jws.soap.SOAPBinding;

import javax.jws.soap.SOAPBinding.Style;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlSeeAlso;

import javax.xml.namespace.QName;

import javax.xml.ws.*;

import javax.xml.ws.soap.MTOM;

import javax.xml.ws.soap.MTOMFeature;

import java.lang.annotation.Annotation;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.security.AccessController;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.TreeMap;

import java.util.concurrent.Future;

import java.util.logging.Logger;

import static javax.jws.soap.SOAPBinding.ParameterStyle.WRAPPED;

/**

 * Creates a runtime model of a SEI (portClass).

 *

 * @author WS Developement Team

 */

public class RuntimeModeler {

    private final WebServiceFeatureList features;

    private BindingID bindingId;

    private WSBinding wsBinding;

    private final Class portClass;

    private AbstractSEIModelImpl model;

    private SOAPBindingImpl defaultBinding;

    // can be empty but never null

    private String packageName;

    private String targetNamespace;

    private boolean isWrapped = true;

    private ClassLoader classLoader;

    private final WSDLPort binding;

    private QName serviceName;

    private QName portName;

    private Set<Class> classUsesWebMethod;

    private DatabindingConfig config;

    private MetadataReader metadataReader;

    /**

     *

     */

    public static final String PD_JAXWS_PACKAGE_PD  = ".jaxws.";

    /**

     *

     */

    public static final String JAXWS_PACKAGE_PD     = "jaxws.";

    public static final String RESPONSE             = "Response";

    public static final String RETURN               = "return";

    public static final String BEAN                 = "Bean";

    public static final String SERVICE              = "Service";

    public static final String PORT                 = "Port";

    public static final Class HOLDER_CLASS = Holder.class;

    public static final Class<RuntimeException> RUNTIME_EXCEPTION_CLASS = RuntimeException.class;

    public static final Class<Exception> EXCEPTION_CLASS = Exception.class;

    public static final String DecapitalizeExceptionBeanProperties = "com.sun.xml.internal.ws.api.model.DecapitalizeExceptionBeanProperties";

    public static final String SuppressDocLitWrapperGeneration = "com.sun.xml.internal.ws.api.model.SuppressDocLitWrapperGeneration";

    public static final String DocWrappeeNamespapceQualified = "com.sun.xml.internal.ws.api.model.DocWrappeeNamespapceQualified";

  /*public RuntimeModeler(@NotNull Class portClass, @NotNull QName serviceName, @NotNull BindingID bindingId, @NotNull WebServiceFeature... features) {

        this(portClass, serviceName, null, bindingId, features);

    }*/

    /**

     *

     * creates an instance of RunTimeModeler given a <code>sei</code> and <code>binding</code>

     * @param portClass The SEI class to be modeled.

     * @param serviceName The ServiceName to use instead of one calculated from the implementation class

     * @param wsdlPort {@link com.sun.xml.internal.ws.api.model.wsdl.WSDLPort}

     * @param features web service features

     */

  /*public RuntimeModeler(@NotNull Class portClass, @NotNull QName serviceName, @NotNull WSDLPortImpl wsdlPort, @NotNull WebServiceFeature... features){

        this(portClass, serviceName, wsdlPort, wsdlPort.getBinding().getBindingId(), features);

    }*/

  /*private RuntimeModeler(@NotNull Class portClass, @NotNull QName serviceName, WSDLPortImpl binding, BindingID bindingId, @NotNull WebServiceFeature... features) {

        this.portClass = portClass;

        this.serviceName = serviceName;

        this.binding = binding;

        this.bindingId = bindingId;

        this.features = features;

    }*/

    public RuntimeModeler(@NotNull DatabindingConfig config){

        this.portClass = (config.getEndpointClass() != null)? config.getEndpointClass() : config.getContractClass();

        this.serviceName = config.getMappingInfo().getServiceName();

        this.binding = config.getWsdlPort();

        this.classLoader = config.getClassLoader();

        this.portName = config.getMappingInfo().getPortName();

        this.config = config;

        this.wsBinding = config.getWSBinding();

        metadataReader = config.getMetadataReader();

        targetNamespace = config.getMappingInfo().getTargetNamespace();

        if (metadataReader == null) metadataReader = new ReflectAnnotationReader();

        if (wsBinding != null) {

            this.bindingId = wsBinding.getBindingId();

                if (config.getFeatures() != null) wsBinding.getFeatures().mergeFeatures(config.getFeatures(), false);

                if (binding != null) wsBinding.getFeatures().mergeFeatures(binding.getFeatures(), false);

                this.features = WebServiceFeatureList.toList(wsBinding.getFeatures());

        } else {

            this.bindingId = config.getMappingInfo().getBindingID();

            this.features = WebServiceFeatureList.toList(config.getFeatures());

            if (binding != null) bindingId = binding.getBinding().getBindingId();

            if (bindingId == null) bindingId = getDefaultBindingID();

            if (!features.contains(MTOMFeature.class)) {

                MTOM mtomAn = getAnnotation(portClass, MTOM.class);

                if (mtomAn != null) features.add(WebServiceFeatureList.getFeature(mtomAn));

            }

            if (!features.contains(com.oracle.webservices.internal.api.EnvelopeStyleFeature.class)) {

                com.oracle.webservices.internal.api.EnvelopeStyle es = getAnnotation(portClass, com.oracle.webservices.internal.api.EnvelopeStyle.class);

                if (es != null) features.add(WebServiceFeatureList.getFeature(es));

            }

            this.wsBinding = bindingId.createBinding(features);

        }

    }

    private BindingID getDefaultBindingID() {

        BindingType bt = getAnnotation(portClass, BindingType.class);

        if (bt != null) return BindingID.parse(bt.value());

        SOAPVersion ver = getSoapVersion(features);

        boolean mtomEnabled = features.isEnabled(MTOMFeature.class);

        if (SOAPVersion.SOAP_12.equals(ver)) {

            return (mtomEnabled) ? BindingID.SOAP12_HTTP_MTOM : BindingID.SOAP12_HTTP;

        } else {

            return (mtomEnabled) ? BindingID.SOAP11_HTTP_MTOM : BindingID.SOAP11_HTTP;

        }

        }

        /**

     * sets the classloader to be used when loading classes by the <code>RuntimeModeler</code>.

     * @param classLoader ClassLoader used to load classes

     */

    public void setClassLoader(ClassLoader classLoader) {

        this.classLoader = classLoader;

    }

    /**

     * sets the PortName to be used by the <code>RuntimeModeler</code>.

     * @param portName The PortName to be used instead of the PortName

     * retrieved via annotations

     */

    public void setPortName(QName portName) {

        this.portName = portName;

    }

    private <T extends Annotation> T getAnnotation(final Class<?> clazz, final Class<T> T) {

        return metadataReader.getAnnotation(T, clazz);

    }

    private <T extends Annotation> T getAnnotation(final Method method, final Class<T> T) {

        return metadataReader.getAnnotation(T, method);

    }

    private Annotation[] getAnnotations(final Method method) {

        return metadataReader.getAnnotations(method);

    }

    private Annotation[] getAnnotations(final Class<?> c) {

        return metadataReader.getAnnotations(c);

    }

    private Annotation[][] getParamAnnotations(final Method method) {

        return metadataReader.getParameterAnnotations(method);

    }

    private static final Logger logger =

        Logger.getLogger(

            com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".server");

    //currently has many local vars which will be eliminated after debugging issues

    //first draft

    /**

     * builds the runtime model from the <code>portClass</code> using the binding ID <code>bindingId</code>.

     * @return the runtime model for the <code>portClass</code>.

     */

    public AbstractSEIModelImpl buildRuntimeModel() {

        model = new SOAPSEIModel(features);

        model.contractClass = config.getContractClass();

        model.endpointClass = config.getEndpointClass();

        model.classLoader = this.classLoader;

        model.wsBinding = wsBinding;

        model.databindingInfo.setWsdlURL(config.getWsdlURL());

        model.databindingInfo.properties().putAll(config.properties());

        if (model.contractClass == null) model.contractClass = portClass;

        if (model.endpointClass == null && !portClass.isInterface()) model.endpointClass = portClass;

        Class<?> seiClass = portClass;

        metadataReader.getProperties(model.databindingInfo.properties(), portClass);

        WebService webService = getAnnotation(portClass, WebService.class);

        if (webService == null) {

            throw new RuntimeModelerException("runtime.modeler.no.webservice.annotation",

                portClass.getCanonicalName());

        }

        Class<?> seiFromConfig = configEndpointInterface();

        if (webService.endpointInterface().length() > 0 || seiFromConfig != null) {

                if (seiFromConfig != null) {

                        seiClass = seiFromConfig;

                } else {

                        seiClass = getClass(webService.endpointInterface(), ModelerMessages.localizableRUNTIME_MODELER_CLASS_NOT_FOUND(webService.endpointInterface()));

                }

            model.contractClass = seiClass;

                model.endpointClass = portClass;

            WebService seiService = getAnnotation(seiClass, WebService.class);

            if (seiService == null) {

                throw new RuntimeModelerException("runtime.modeler.endpoint.interface.no.webservice",

                    webService.endpointInterface());

            }

            //check if @SOAPBinding is defined on the impl class

            SOAPBinding sbPortClass = getAnnotation(portClass, SOAPBinding.class);

            SOAPBinding sbSei = getAnnotation(seiClass, SOAPBinding.class);

            if(sbPortClass != null){

                if(sbSei == null || sbSei.style() != sbPortClass.style()|| sbSei.use() != sbPortClass.use()){

                    logger.warning(ServerMessages.RUNTIMEMODELER_INVALIDANNOTATION_ON_IMPL("@SOAPBinding", portClass.getName(), seiClass.getName()));

                }

            }

        }

        if (serviceName == null)

            serviceName = getServiceName(portClass, metadataReader);

        model.setServiceQName(serviceName);

//        String portLocalName  = portClass.getSimpleName()+PORT;

//        if (webService.portName().length() >0) {

//            portLocalName = webService.portName();

//        } else if (webService.name().length() >0) {

//            portLocalName = webService.name()+PORT;

//        }

//

//        if (portName == null)

//            portName = new QName(serviceName.getNamespaceURI(), portLocalName);

//        if (!portName.getNamespaceURI().equals(serviceName.getNamespaceURI())) {

//            throw new RuntimeModelerException("runtime.modeler.portname.servicename.namespace.mismatch",

//                serviceName, portName);

//        }

        if (portName == null) portName = getPortName(portClass, metadataReader, serviceName.getNamespaceURI());

        model.setPortName(portName);

        // Check if databinding is overridden in annotation.

        com.oracle.webservices.internal.api.databinding.DatabindingMode dbm2 = getAnnotation(portClass, com.oracle.webservices.internal.api.databinding.DatabindingMode.class);

        if (dbm2 != null) model.databindingInfo.setDatabindingMode(dbm2.value());

        processClass(seiClass);

        if (model.getJavaMethods().size() == 0)

            throw new RuntimeModelerException("runtime.modeler.no.operations",

                    portClass.getName());

        model.postProcess();

        // Make the configured databinding mode available to the

        // DatabindingConfig.

        config.properties().put(BindingContext.class.getName(),

                model.bindingContext);

        // TODO: this needs to be fixed properly --

        // when we are building RuntimeModel first before building WSDLModel,

        // we still need to do this correctly

        if(binding!=null)

            model.freeze(binding);

        return model;

    }

    private Class configEndpointInterface() {

                if (config.getEndpointClass() == null ||

                    config.getEndpointClass().isInterface()     ) return null; //client proxy Interface

                return config.getContractClass();

        }

        /**

     * utility method to load classes

     * @param className the name of the class to load

     * @param errorMessage

     *      Error message to use when the resolution fails.

     * @return the class specified by <code>className</code>

     */

    private Class getClass(String className, Localizable errorMessage) {

        try {

            if (classLoader == null)

                return Thread.currentThread().getContextClassLoader().loadClass(className);

            else

                return classLoader.loadClass(className);

        } catch (ClassNotFoundException e) {

            throw new RuntimeModelerException(errorMessage);

        }

    }

    private boolean noWrapperGen() {

        Object o = config.properties().get(SuppressDocLitWrapperGeneration);

        return (o!= null && o instanceof Boolean) ? ((Boolean) o) : false;

    }

    private Class getRequestWrapperClass(String className, Method method, QName reqElemName) {

        ClassLoader loader =  (classLoader == null) ? Thread.currentThread().getContextClassLoader() : classLoader;

        try {

            return loader.loadClass(className);

        } catch (ClassNotFoundException e) {

            if (noWrapperGen()) return WrapperComposite.class;

            logger.fine("Dynamically creating request wrapper Class " + className);

            return WrapperBeanGenerator.createRequestWrapperBean(className, method, reqElemName, loader);

        }

    }

    private Class getResponseWrapperClass(String className, Method method, QName resElemName) {

        ClassLoader loader =  (classLoader == null) ? Thread.currentThread().getContextClassLoader() : classLoader;

        try {

            return loader.loadClass(className);

        } catch (ClassNotFoundException e) {

            if (noWrapperGen()) return WrapperComposite.class;

            logger.fine("Dynamically creating response wrapper bean Class " + className);

            return WrapperBeanGenerator.createResponseWrapperBean(className, method, resElemName, loader);

        }

    }

    private Class getExceptionBeanClass(String className, Class exception, String name, String namespace) {

        boolean decapitalizeExceptionBeanProperties = true;

        Object o = config.properties().get(DecapitalizeExceptionBeanProperties);

        if (o!= null && o instanceof Boolean) decapitalizeExceptionBeanProperties = (Boolean) o;

        ClassLoader loader =  (classLoader == null) ? Thread.currentThread().getContextClassLoader() : classLoader;

        try {

            return loader.loadClass(className);

        } catch (ClassNotFoundException e) {

            if (noWrapperGen()) return exception;

            logger.fine("Dynamically creating exception bean Class " + className);

            return WrapperBeanGenerator.createExceptionBean(className, exception, targetNamespace, name, namespace, loader, decapitalizeExceptionBeanProperties);

        }

    }

    protected void determineWebMethodUse(Class clazz) {

        if (clazz == null)

            return;

        if (!clazz.isInterface()) {

            if (clazz == Object.class)

                return;

            WebMethod webMethod;

            for (Method method : clazz.getMethods()) {

                if (method.getDeclaringClass()!=clazz)

                    continue;

                webMethod = getAnnotation(method, WebMethod.class);

                if (webMethod != null && !webMethod.exclude()) {

                    classUsesWebMethod.add(clazz);

                    break;

                }

            }

        }

        determineWebMethodUse(clazz.getSuperclass());

    }

    void processClass(Class clazz) {

        classUsesWebMethod = new HashSet<Class>();

        determineWebMethodUse(clazz);

        WebService webService = getAnnotation(clazz, WebService.class);

        QName portTypeName = getPortTypeName(clazz, targetNamespace, metadataReader);

//        String portTypeLocalName  = clazz.getSimpleName();

//        if (webService.name().length() >0)

//            portTypeLocalName = webService.name();

//

//        targetNamespace = webService.targetNamespace();

        packageName = "";

        if (clazz.getPackage() != null)

            packageName = clazz.getPackage().getName();

//        if (targetNamespace.length() == 0) {

//            targetNamespace = getNamespace(packageName);

//        }

//        model.setTargetNamespace(targetNamespace);

//        QName portTypeName = new QName(targetNamespace, portTypeLocalName);

        targetNamespace = portTypeName.getNamespaceURI();

        model.setPortTypeName(portTypeName);

        model.setTargetNamespace(targetNamespace);

        model.defaultSchemaNamespaceSuffix = config.getMappingInfo().getDefaultSchemaNamespaceSuffix();

        model.setWSDLLocation(webService.wsdlLocation());

        SOAPBinding soapBinding = getAnnotation(clazz, SOAPBinding.class);

        if (soapBinding != null) {

            if (soapBinding.style() == SOAPBinding.Style.RPC && soapBinding.parameterStyle() == SOAPBinding.ParameterStyle.BARE) {

                throw new RuntimeModelerException("runtime.modeler.invalid.soapbinding.parameterstyle",

                        soapBinding, clazz);

            }

            isWrapped = soapBinding.parameterStyle()== WRAPPED;

        }

        defaultBinding = createBinding(soapBinding);

        /*

         * if clazz != portClass then there is an SEI.  If there is an

         * SEI, then all methods should be processed.  However, if there is

         * no SEI, and the implementation class uses at least one

         * WebMethod annotation, then only methods with this annotation

         * will be processed.

         */

/*        if (clazz == portClass) {

            WebMethod webMethod;

            for (Method method : clazz.getMethods()) {

                webMethod = getPrivMethodAnnotation(method, WebMethod.class);

                if (webMethod != null &&

                    !webMethod.exclude()) {

                    usesWebMethod = true;

                    break;

                }

            }

        }*/

        for (Method method : clazz.getMethods()) {

            if (!clazz.isInterface()) {     // if clazz is SEI, then all methods are web methods

                if (method.getDeclaringClass() == Object.class) continue;

                if (!getBooleanSystemProperty("com.sun.xml.internal.ws.legacyWebMethod")) {  // legacy webMethod computation behaviour to be used

                    if (!isWebMethodBySpec(method, clazz))

                        continue;

                } else {

                    if (!isWebMethod(method))

                        continue;

                }

            }

            // TODO: binding can be null. We need to figure out how to post-process

            // RuntimeModel to link to WSDLModel

            processMethod(method);

        }

        //Add additional jaxb classes referenced by {@link XmlSeeAlso}

        XmlSeeAlso xmlSeeAlso = getAnnotation(clazz, XmlSeeAlso.class);

        if(xmlSeeAlso != null)

            model.addAdditionalClasses(xmlSeeAlso.value());

    }

    /*

     * Section 3.3 of spec

     * Otherwise, the class implicitly defines a service endpoint interface (SEI) which

     * comprises all of the public methods that satisfy one of the following conditions:

     *  1. They are annotated with the javax.jws.WebMethod annotation with the exclude element set to

     *     false or missing (since false is the default for this annotation element).

     *  2. They are not annotated with the javax.jws.WebMethod annotation but their declaring class has a

     *     javax.jws.WebService annotation.

     *

     * also the method should non-static or non-final

     */

    private boolean isWebMethodBySpec(Method method, Class clazz) {

        int modifiers = method.getModifiers();

        boolean staticFinal = Modifier.isStatic(modifiers) || Modifier.isFinal(modifiers);

        assert Modifier.isPublic(modifiers);

        assert !clazz.isInterface();

        WebMethod webMethod = getAnnotation(method, WebMethod.class);

        if (webMethod != null) {

            if (webMethod.exclude()) {

                return false;       // @WebMethod(exclude="true")

            }

            if (staticFinal) {

                throw new RuntimeModelerException(ModelerMessages.localizableRUNTIME_MODELER_WEBMETHOD_MUST_BE_NONSTATICFINAL(method));

            }

            return true;            // @WebMethod

        }

        if (staticFinal) {

            return false;

        }

        Class declClass = method.getDeclaringClass();

        return getAnnotation(declClass, WebService.class) != null;

    }

    private boolean isWebMethod(Method method) {

        int modifiers = method.getModifiers();