/*

 * 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.tools.internal.ws.processor.modeler.annotation;

import com.sun.tools.internal.ws.processor.model.Port;

import com.sun.tools.internal.ws.resources.WebserviceapMessages;

import com.sun.tools.internal.ws.util.ClassNameInfo;

import com.sun.tools.internal.ws.wsdl.document.soap.SOAPStyle;

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

import javax.jws.Oneway;

import javax.jws.WebMethod;

import javax.jws.WebParam;

import javax.jws.WebResult;

import javax.jws.WebService;

import javax.jws.soap.SOAPBinding;

import javax.jws.soap.SOAPBinding.ParameterStyle;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.Name;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.NoType;

import javax.lang.model.type.TypeKind;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.util.ElementFilter;

import javax.lang.model.util.SimpleElementVisitor6;

import javax.lang.model.util.SimpleTypeVisitor6;

import javax.lang.model.util.Types;

import java.lang.annotation.Annotation;

import java.util.Collection;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.Stack;

/**

 * @author WS Development Team

 */

public abstract class WebServiceVisitor extends SimpleElementVisitor6<Void, Object> {

    protected ModelBuilder builder;

    protected String wsdlNamespace;

    protected String typeNamespace;

    protected Stack<SOAPBinding> soapBindingStack;

    protected SOAPBinding typeElementSoapBinding;

    protected SOAPStyle soapStyle = SOAPStyle.DOCUMENT;

    protected boolean wrapped = true;

    protected Port port;

    protected Name serviceImplName;

    protected Name endpointInterfaceName;

    protected AnnotationProcessorContext context;

    protected AnnotationProcessorContext.SeiContext seiContext;

    protected boolean processingSei = false;

    protected String serviceName;

    protected Name packageName;

    protected String portName;

    protected boolean endpointReferencesInterface = false;

    protected boolean hasWebMethods = false;

    protected TypeElement typeElement;

    protected Set<String> processedMethods;

    protected boolean pushedSoapBinding = false;

    private static final NoTypeVisitor NO_TYPE_VISITOR = new NoTypeVisitor();

    public WebServiceVisitor(ModelBuilder builder, AnnotationProcessorContext context) {

        this.builder = builder;

        this.context = context;

        soapBindingStack = new Stack<SOAPBinding>();

        processedMethods = new HashSet<String>();

    }

    @Override

    public Void visitType(TypeElement e, Object o) {

        WebService webService = e.getAnnotation(WebService.class);

        if (!shouldProcessWebService(webService, e))

            return null;

        if (builder.checkAndSetProcessed(e))

            return null;

        typeElement = e;

        switch (e.getKind()) {

            case INTERFACE: {

                if (endpointInterfaceName != null && !endpointInterfaceName.equals(e.getQualifiedName())) {

                    builder.processError(WebserviceapMessages.WEBSERVICEAP_ENDPOINTINTERFACES_DO_NOT_MATCH(endpointInterfaceName, e.getQualifiedName()), e);

                }

                verifySeiAnnotations(webService, e);

                endpointInterfaceName = e.getQualifiedName();

                processingSei = true;

                preProcessWebService(webService, e);

                processWebService(webService, e);

                postProcessWebService(webService, e);

                break;

            }

            case CLASS: {

                typeElementSoapBinding = e.getAnnotation(SOAPBinding.class);

                if (serviceImplName == null)

                    serviceImplName = e.getQualifiedName();

                String endpointInterfaceName = webService != null ? webService.endpointInterface() : null;

                if (endpointInterfaceName != null && endpointInterfaceName.length() > 0) {

                    checkForInvalidImplAnnotation(e, SOAPBinding.class);

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

                        builder.processError(WebserviceapMessages.WEBSERVICEAP_ENDPOINTINTEFACE_PLUS_ELEMENT("name"), e);

                    endpointReferencesInterface = true;

                    verifyImplAnnotations(e);

                    inspectEndpointInterface(endpointInterfaceName, e);

                    serviceImplName = null;

                    return null;

                }

                processingSei = false;

                preProcessWebService(webService, e);

                processWebService(webService, e);

                serviceImplName = null;

                postProcessWebService(webService, e);

                serviceImplName = null;

                break;

            }

            default:

                break;

        }

        return null;

    }

    protected void verifySeiAnnotations(WebService webService, TypeElement d) {

        if (webService.endpointInterface().length() > 0) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_ENDPOINTINTERFACE_ON_INTERFACE(

                    d.getQualifiedName(), webService.endpointInterface()), d);

        }

        if (webService.serviceName().length() > 0) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_SEI_ANNOTATION_ELEMENT(

                    "serviceName", d.getQualifiedName()), d);

        }

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

            builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_SEI_ANNOTATION_ELEMENT(

                    "portName", d.getQualifiedName()), d);

        }

    }

    protected void verifyImplAnnotations(TypeElement d) {

        for (ExecutableElement method : ElementFilter.methodsIn(d.getEnclosedElements())) {

            checkForInvalidImplAnnotation(method, WebMethod.class);

            checkForInvalidImplAnnotation(method, Oneway.class);

            checkForInvalidImplAnnotation(method, WebResult.class);

            for (VariableElement param : method.getParameters()) {

                checkForInvalidImplAnnotation(param, WebParam.class);

            }

        }

    }

    protected void checkForInvalidSeiAnnotation(TypeElement element, Class annotationClass) {

        Object annotation = element.getAnnotation(annotationClass);

        if (annotation != null) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_SEI_ANNOTATION(

                    annotationClass.getName(), element.getQualifiedName()), element);

        }

    }

    protected void checkForInvalidImplAnnotation(Element element, Class annotationClass) {

        Object annotation = element.getAnnotation(annotationClass);

        if (annotation != null) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_ENDPOINTINTEFACE_PLUS_ANNOTATION(annotationClass.getName()), element);

        }

    }

    protected void preProcessWebService(WebService webService, TypeElement element) {

        processedMethods = new HashSet<String>();

        seiContext = context.getSeiContext(element);

        String targetNamespace = null;

        if (webService != null)

            targetNamespace = webService.targetNamespace();

        PackageElement packageElement = builder.getProcessingEnvironment().getElementUtils().getPackageOf(element);

        if (targetNamespace == null || targetNamespace.length() == 0) {

            String packageName = packageElement.getQualifiedName().toString();

            if (packageName == null || packageName.length() == 0) {

                builder.processError(WebserviceapMessages.WEBSERVICEAP_NO_PACKAGE_CLASS_MUST_HAVE_TARGETNAMESPACE(

                        element.getQualifiedName()), element);

            }

            targetNamespace = RuntimeModeler.getNamespace(packageName);

        }

        seiContext.setNamespaceUri(targetNamespace);

        if (serviceImplName == null)

            serviceImplName = seiContext.getSeiImplName();

        if (serviceImplName != null) {

            seiContext.setSeiImplName(serviceImplName);

            context.addSeiContext(serviceImplName, seiContext);

        }

        portName = ClassNameInfo.getName(element.getSimpleName().toString().replace('$', '_'));

        packageName = packageElement.getQualifiedName();

        portName = webService != null && webService.name() != null && webService.name().length() > 0 ?

                webService.name() : portName;

        serviceName = ClassNameInfo.getName(element.getQualifiedName().toString()) + WebServiceConstants.SERVICE.getValue();

        serviceName = webService != null && webService.serviceName() != null && webService.serviceName().length() > 0 ?

                webService.serviceName() : serviceName;

        wsdlNamespace = seiContext.getNamespaceUri();

        typeNamespace = wsdlNamespace;

        SOAPBinding soapBinding = element.getAnnotation(SOAPBinding.class);

        if (soapBinding != null) {

            pushedSoapBinding = pushSoapBinding(soapBinding, element, element);

        } else if (element.equals(typeElement)) {

            pushedSoapBinding = pushSoapBinding(new MySoapBinding(), element, element);

        }

    }

    public static boolean sameStyle(SOAPBinding.Style style, SOAPStyle soapStyle) {

        return style.equals(SOAPBinding.Style.DOCUMENT)

                && soapStyle.equals(SOAPStyle.DOCUMENT)

                || style.equals(SOAPBinding.Style.RPC)

                && soapStyle.equals(SOAPStyle.RPC);

    }

    protected boolean pushSoapBinding(SOAPBinding soapBinding, Element bindingElement, TypeElement classElement) {

        boolean changed = false;

        if (!sameStyle(soapBinding.style(), soapStyle)) {

            changed = true;

            if (pushedSoapBinding)

                builder.processError(WebserviceapMessages.WEBSERVICEAP_MIXED_BINDING_STYLE(

                        classElement.getQualifiedName()), bindingElement);

        }

        if (soapBinding.style().equals(SOAPBinding.Style.RPC)) {

            soapStyle = SOAPStyle.RPC;

            wrapped = true;

            if (soapBinding.parameterStyle().equals(ParameterStyle.BARE)) {

                builder.processError(WebserviceapMessages.WEBSERVICEAP_RPC_LITERAL_MUST_NOT_BE_BARE(

                        classElement.getQualifiedName()), bindingElement);

            }

        } else {

            soapStyle = SOAPStyle.DOCUMENT;

            if (wrapped != soapBinding.parameterStyle().equals(ParameterStyle.WRAPPED)) {

                wrapped = soapBinding.parameterStyle().equals(ParameterStyle.WRAPPED);

                changed = true;

            }

        }

        if (soapBinding.use().equals(SOAPBinding.Use.ENCODED)) {

            String style = "rpc";

            if (soapBinding.style().equals(SOAPBinding.Style.DOCUMENT))

                style = "document";

            builder.processError(WebserviceapMessages.WEBSERVICE_ENCODED_NOT_SUPPORTED(

                    classElement.getQualifiedName(), style), bindingElement);

        }

        if (changed || soapBindingStack.empty()) {

            soapBindingStack.push(soapBinding);

            pushedSoapBinding = true;

        }

        return changed;

    }

    protected SOAPBinding popSoapBinding() {

        if (pushedSoapBinding)

            soapBindingStack.pop();

        SOAPBinding soapBinding = null;

        if (!soapBindingStack.empty()) {

            soapBinding = soapBindingStack.peek();

            if (soapBinding.style().equals(SOAPBinding.Style.RPC)) {

                soapStyle = SOAPStyle.RPC;

                wrapped = true;

            } else {

                soapStyle = SOAPStyle.DOCUMENT;

                wrapped = soapBinding.parameterStyle().equals(ParameterStyle.WRAPPED);

            }

        } else {

                pushedSoapBinding = false;

        }

        return soapBinding;

    }

    protected String getNamespace(PackageElement packageElement) {

        return RuntimeModeler.getNamespace(packageElement.getQualifiedName().toString());

    }

    protected boolean shouldProcessWebService(WebService webService, TypeElement element) {

        switch (element.getKind()) {

            case INTERFACE: {

                hasWebMethods = false;

                if (webService == null)

                    builder.processError(WebserviceapMessages.WEBSERVICEAP_ENDPOINTINTERFACE_HAS_NO_WEBSERVICE_ANNOTATION(

                            element.getQualifiedName()), element);

                SOAPBinding soapBinding = element.getAnnotation(SOAPBinding.class);

                if (soapBinding != null

                        && soapBinding.style() == SOAPBinding.Style.RPC

                        && soapBinding.parameterStyle() == SOAPBinding.ParameterStyle.BARE) {

                    builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_SOAPBINDING_PARAMETERSTYLE(

                            soapBinding, element), element);

                    return false;

                }

                return isLegalSei(element);

            }

            case CLASS: {

                if (webService == null)

                    return false;

                hasWebMethods = hasWebMethods(element);

                SOAPBinding soapBinding = element.getAnnotation(SOAPBinding.class);

                if (soapBinding != null

                        && soapBinding.style() == SOAPBinding.Style.RPC

                        && soapBinding.parameterStyle() == SOAPBinding.ParameterStyle.BARE) {

                    builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_SOAPBINDING_PARAMETERSTYLE(

                            soapBinding, element), element);

                    return false;

                }

                return isLegalImplementation(webService, element);

            }

            default: {

                throw new IllegalArgumentException("Class or Interface was expecting. But element: " + element);

            }

        }

    }

    abstract protected void processWebService(WebService webService, TypeElement element);

    protected void postProcessWebService(WebService webService, TypeElement element) {

        processMethods(element);

        popSoapBinding();

    }

    protected boolean hasWebMethods(TypeElement element) {

        if (element.getQualifiedName().toString().equals(Object.class.getName()))

            return false;

        WebMethod webMethod;

        for (ExecutableElement method : ElementFilter.methodsIn(element.getEnclosedElements())) {

            webMethod = method.getAnnotation(WebMethod.class);

            if (webMethod != null) {

                if (webMethod.exclude()) {

                    if (webMethod.operationName().length() > 0)

                        builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_WEBMETHOD_ELEMENT_WITH_EXCLUDE(

                                "operationName", element.getQualifiedName(), method.toString()), method);

                    if (webMethod.action().length() > 0)

                        builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_WEBMETHOD_ELEMENT_WITH_EXCLUDE(

                                "action", element.getQualifiedName(), method.toString()), method);

                } else {

                    return true;

                }

            }

        }

        return false;//hasWebMethods(d.getSuperclass().getDeclaration());

    }

    protected void processMethods(TypeElement element) {

        switch (element.getKind()) {

            case INTERFACE: {

                builder.log("ProcessedMethods Interface: " + element);

                hasWebMethods = false;

                for (ExecutableElement method : ElementFilter.methodsIn(element.getEnclosedElements())) {

                    method.accept(this, null);

                }

                for (TypeMirror superType : element.getInterfaces())

                    processMethods((TypeElement) ((DeclaredType) superType).asElement());

                break;

            }

            case CLASS: {

                builder.log("ProcessedMethods Class: " + element);

                hasWebMethods = hasWebMethods(element);

                if (element.getQualifiedName().toString().equals(Object.class.getName()))

                    return;

                if (element.getAnnotation(WebService.class) != null) {

                    // Super classes must have @WebService annotations to pick up their methods

                    for (ExecutableElement method : ElementFilter.methodsIn(element.getEnclosedElements())) {

                        method.accept(this, null);

                    }

                }

                TypeMirror superclass = element.getSuperclass();

                if (!superclass.getKind().equals(TypeKind.NONE)) {

                    processMethods((TypeElement) ((DeclaredType) superclass).asElement());

                }

                break;

            }

            default:

                break;

        }

    }

    private TypeElement getEndpointInterfaceElement(String endpointInterfaceName, TypeElement element) {

        TypeElement intTypeElement = null;

        for (TypeMirror interfaceType : element.getInterfaces()) {

            if (endpointInterfaceName.equals(interfaceType.toString())) {

                intTypeElement = (TypeElement) ((DeclaredType) interfaceType).asElement();

                seiContext = context.getSeiContext(intTypeElement.getQualifiedName());

                assert (seiContext != null);

                seiContext.setImplementsSei(true);

                break;

            }

        }

        if (intTypeElement == null) {

            intTypeElement = builder.getProcessingEnvironment().getElementUtils().getTypeElement(endpointInterfaceName);

        }

        if (intTypeElement == null)

            builder.processError(WebserviceapMessages.WEBSERVICEAP_ENDPOINTINTERFACE_CLASS_NOT_FOUND(endpointInterfaceName));

        return intTypeElement;

    }

    private void inspectEndpointInterface(String endpointInterfaceName, TypeElement d) {

        TypeElement intTypeElement = getEndpointInterfaceElement(endpointInterfaceName, d);

        if (intTypeElement != null)

            intTypeElement.accept(this, null);

    }

    @Override

    public Void visitExecutable(ExecutableElement method, Object o) {

        // Methods must be public

        if (!method.getModifiers().contains(Modifier.PUBLIC))

            return null;

        if (processedMethod(method))

            return null;

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

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

            return null;

        SOAPBinding soapBinding = method.getAnnotation(SOAPBinding.class);

        if (soapBinding == null && !method.getEnclosingElement().equals(typeElement)) {

            if (method.getEnclosingElement().getKind().equals(ElementKind.CLASS)) {

                soapBinding = method.getEnclosingElement().getAnnotation(SOAPBinding.class);

                if (soapBinding != null)

                    builder.log("using " + method.getEnclosingElement() + "'s SOAPBinding.");

                else {

                    soapBinding = new MySoapBinding();

                }

            }

        }

        boolean newBinding = false;

        if (soapBinding != null) {

            newBinding = pushSoapBinding(soapBinding, method, typeElement);

        }

        try {

            if (shouldProcessMethod(method, webMethod)) {

                processMethod(method, webMethod);

            }

        } finally {

            if (newBinding) {

                popSoapBinding();

            }

        }

        return null;

    }

    protected boolean processedMethod(ExecutableElement method) {

        String id = method.toString();

        if (processedMethods.contains(id))

            return true;

        processedMethods.add(id);

        return false;

    }

    protected boolean shouldProcessMethod(ExecutableElement method, WebMethod webMethod) {

        builder.log("should process method: " + method.getSimpleName() + " hasWebMethods: " + hasWebMethods + " ");

        /*

        Fix for https://jax-ws.dev.java.net/issues/show_bug.cgi?id=577

        if (hasWebMethods && webMethod == null) {

            builder.log("webMethod == null");

            return false;

        }

        */

        Collection<Modifier> modifiers = method.getModifiers();

        boolean staticFinal = modifiers.contains(Modifier.STATIC) || modifiers.contains(Modifier.FINAL);

        if (staticFinal) {

            if (webMethod != null) {

                builder.processError(WebserviceapMessages.WEBSERVICEAP_WEBSERVICE_METHOD_IS_STATIC_OR_FINAL(method.getEnclosingElement(),

                        method), method);

            }

            return false;

        }

        boolean result = (endpointReferencesInterface ||

                method.getEnclosingElement().equals(typeElement) ||

                (method.getEnclosingElement().getAnnotation(WebService.class) != null));

        builder.log("endpointReferencesInterface: " + endpointReferencesInterface);

        builder.log("declaring class has WebService: " + (method.getEnclosingElement().getAnnotation(WebService.class) != null));

        builder.log("returning: " + result);

        return result;

    }

    abstract protected void processMethod(ExecutableElement method, WebMethod webMethod);

    protected boolean isLegalImplementation(WebService webService, TypeElement classElement) {

        boolean isStateful = isStateful(classElement);

        Collection<Modifier> modifiers = classElement.getModifiers();

        if (!modifiers.contains(Modifier.PUBLIC)) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_WEBSERVICE_CLASS_NOT_PUBLIC(classElement.getQualifiedName()), classElement);

            return false;

        }

        if (modifiers.contains(Modifier.FINAL) && !isStateful) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_WEBSERVICE_CLASS_IS_FINAL(classElement.getQualifiedName()), classElement);

            return false;

        }

        if (modifiers.contains(Modifier.ABSTRACT) && !isStateful) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_WEBSERVICE_CLASS_IS_ABSTRACT(classElement.getQualifiedName()), classElement);

            return false;

        }

        boolean hasDefaultConstructor = false;

        for (ExecutableElement constructor : ElementFilter.constructorsIn(classElement.getEnclosedElements())) {

            if (constructor.getModifiers().contains(Modifier.PUBLIC) &&

                    constructor.getParameters().isEmpty()) {

                hasDefaultConstructor = true;

                break;

            }

        }

        if (!hasDefaultConstructor && !isStateful) {

            if (classElement.getEnclosingElement() != null && !modifiers.contains(Modifier.STATIC)) {

                builder.processError(WebserviceapMessages.WEBSERVICEAP_WEBSERVICE_CLASS_IS_INNERCLASS_NOT_STATIC(

                        classElement.getQualifiedName()), classElement);

                return false;

            }