/*

 * 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.codemodel.internal.CodeWriter;

import com.sun.codemodel.internal.JAnnotationArrayMember;

import com.sun.codemodel.internal.JAnnotationUse;

import com.sun.codemodel.internal.JBlock;

import com.sun.codemodel.internal.JCodeModel;

import com.sun.codemodel.internal.JCommentPart;

import com.sun.codemodel.internal.JDefinedClass;

import com.sun.codemodel.internal.JDocComment;

import com.sun.codemodel.internal.JExpr;

import com.sun.codemodel.internal.JFieldVar;

import com.sun.codemodel.internal.JMethod;

import com.sun.codemodel.internal.JMod;

import com.sun.codemodel.internal.JType;

import com.sun.codemodel.internal.JVar;

import com.sun.codemodel.internal.writer.ProgressCodeWriter;

import com.sun.tools.internal.jxc.ap.InlineAnnotationReaderImpl;

import com.sun.tools.internal.jxc.model.nav.ApNavigator;

import com.sun.tools.internal.ws.ToolVersion;

import com.sun.tools.internal.ws.processor.generator.GeneratorBase;

import com.sun.tools.internal.ws.processor.generator.GeneratorConstants;

import com.sun.tools.internal.ws.processor.generator.Names;

import com.sun.tools.internal.ws.processor.modeler.ModelerException;

import com.sun.tools.internal.ws.processor.util.DirectoryUtil;

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

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

import com.sun.tools.internal.ws.wscompile.FilerCodeWriter;

import com.sun.tools.internal.ws.wscompile.WsgenOptions;

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

import com.sun.xml.internal.bind.v2.model.annotation.AnnotationReader;

import com.sun.xml.internal.bind.v2.model.nav.Navigator;

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

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

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

import javax.jws.Oneway;

import javax.jws.WebMethod;

import javax.jws.WebService;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.Name;

import javax.lang.model.element.TypeElement;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.MirroredTypeException;

import javax.lang.model.type.TypeKind;

import javax.lang.model.type.TypeMirror;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlAttachmentRef;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlList;

import javax.xml.bind.annotation.XmlMimeType;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

import javax.xml.namespace.QName;

import javax.xml.ws.RequestWrapper;

import javax.xml.ws.ResponseWrapper;

import javax.xml.ws.WebFault;

import javax.xml.ws.WebServiceException;

import java.io.File;

import java.io.IOException;

import java.lang.annotation.Annotation;

import java.util.Collection;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import static com.sun.codemodel.internal.ClassType.CLASS;

import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.BEAN;

import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.FAULT_INFO;

import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.JAXWS_PACKAGE_PD;

import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.PD_JAXWS_PACKAGE_PD;

import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.RESPONSE;

/**

 * This class generates the request/response and Exception Beans

 * used by the JAX-WS runtime.

 *

 * @author  WS Development Team

 */

public class WebServiceWrapperGenerator extends WebServiceVisitor {

    private Set<String> wrapperNames;

    private Set<String> processedExceptions;

    private JCodeModel cm;

    private final MakeSafeTypeVisitor makeSafeVisitor;

    private static final FieldFactory FIELD_FACTORY = new FieldFactory();

    private final AbstractWrapperBeanGenerator ap_generator =

            new ApWrapperBeanGenerator(InlineAnnotationReaderImpl.theInstance,

                    new ApNavigator(builder.getProcessingEnvironment()), FIELD_FACTORY);

    private final class ApWrapperBeanGenerator extends AbstractWrapperBeanGenerator<TypeMirror, TypeElement, ExecutableElement, MemberInfo> {

        protected ApWrapperBeanGenerator(

                AnnotationReader<TypeMirror, TypeElement, ?, ExecutableElement> annReader,

                Navigator<TypeMirror, TypeElement, ?, ExecutableElement> nav, BeanMemberFactory<TypeMirror, MemberInfo> beanMemberFactory) {

            super(annReader, nav, beanMemberFactory);

        }

        @Override

        protected TypeMirror getSafeType(TypeMirror type) {

            return WebServiceWrapperGenerator.this.getSafeType(type);

        }

        @Override

        protected TypeMirror getHolderValueType(TypeMirror paramType) {

            return builder.getHolderValueType(paramType);

        }

        @Override

        protected boolean isVoidType(TypeMirror type) {

            return type != null && type.getKind().equals(TypeKind.VOID);

        }

    }

    private static final class FieldFactory implements AbstractWrapperBeanGenerator.BeanMemberFactory<TypeMirror, MemberInfo> {

        @Override

        public MemberInfo createWrapperBeanMember(TypeMirror paramType,

                                                  String paramName, List<Annotation> jaxb) {

            return new MemberInfo(paramType, paramName, jaxb);

        }

    }

    public WebServiceWrapperGenerator(ModelBuilder builder, AnnotationProcessorContext context) {

        super(builder, context);

        makeSafeVisitor = new MakeSafeTypeVisitor(builder.getProcessingEnvironment());

    }

    @Override

    protected void processWebService(WebService webService, TypeElement d) {

        cm = new JCodeModel();

        wrapperNames = new HashSet<String>();

        processedExceptions = new HashSet<String>();

    }

    @Override

    protected void postProcessWebService(WebService webService, TypeElement d) {

        super.postProcessWebService(webService, d);

        doPostProcessWebService(webService, d);

    }

    @SuppressWarnings("CallToThreadDumpStack")

    protected void doPostProcessWebService(WebService webService, TypeElement d) {

        if (cm != null) {

            WsgenOptions options = builder.getOptions();

            try {

                if(options.verbose)

                    cw = new ProgressCodeWriter(cw, System.out);

                cm.build(cw);

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

    @Override

    protected void processMethod(ExecutableElement method, WebMethod webMethod) {

        builder.log("WrapperGen - method: "+method);

        builder.log("method.getDeclaringType(): " + method.asType());

        if (wrapped && soapStyle.equals(SOAPStyle.DOCUMENT)) {

            generateWrappers(method, webMethod);

        }

        generateExceptionBeans(method);

    }

    private boolean generateExceptionBeans(ExecutableElement method) {

        String beanPackage = packageName + PD_JAXWS_PACKAGE_PD.getValue();

        if (packageName.length() == 0)

            beanPackage = JAXWS_PACKAGE_PD.getValue();

        boolean beanGenerated = false;

        for (TypeMirror thrownType : method.getThrownTypes()) {

            TypeElement typeDecl = (TypeElement) ((DeclaredType) thrownType).asElement();

            if (typeDecl == null) {

                builder.processError(WebserviceapMessages.WEBSERVICEAP_COULD_NOT_FIND_TYPEDECL(

                        thrownType.toString(), context.getRound()));

                return false;

            }

            boolean tmp = generateExceptionBean(typeDecl, beanPackage);

            beanGenerated = beanGenerated || tmp;

        }

        return beanGenerated;

    }

    private boolean duplicateName(String name) {

        for (String str : wrapperNames) {

            if (str.equalsIgnoreCase(name))

        return true;

        }

        wrapperNames.add(name);

    return false;

    }

    private boolean generateWrappers(ExecutableElement method, WebMethod webMethod) {

        boolean isOneway = method.getAnnotation(Oneway.class) != null;

        String beanPackage = packageName + PD_JAXWS_PACKAGE_PD.getValue();

        if (packageName.length() == 0)

            beanPackage = JAXWS_PACKAGE_PD.getValue();

        Name methodName = method.getSimpleName();

        String operationName = builder.getOperationName(methodName);

        operationName = webMethod != null && webMethod.operationName().length() > 0 ?

                webMethod.operationName() : operationName;

        String reqName = operationName;

        String resName = operationName + WebServiceConstants.RESPONSE.getValue();

        String reqNamespace = typeNamespace;

        String resNamespace = typeNamespace;

        String requestClassName = beanPackage + StringUtils.capitalize(method.getSimpleName().toString());

        RequestWrapper reqWrapper = method.getAnnotation(RequestWrapper.class);

        if (reqWrapper != null) {

            if (reqWrapper.className().length() > 0)

                requestClassName = reqWrapper.className();

            if (reqWrapper.localName().length() > 0)

                reqName = reqWrapper.localName();

            if (reqWrapper.targetNamespace().length() > 0)

                reqNamespace = reqWrapper.targetNamespace();

        }

        builder.log("requestWrapper: "+requestClassName);

///// fix for wsgen CR 6442344

//////////

        boolean canOverwriteRequest = builder.canOverWriteClass(requestClassName);

        if (!canOverwriteRequest) {

            builder.log("Class " + requestClassName + " exists. Not overwriting.");

        }

        if (duplicateName(requestClassName) && canOverwriteRequest) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_REQUEST_WRAPPER_BEAN_NAME_NOT_UNIQUE(

                    typeElement.getQualifiedName(), method.toString()));

        }

        String responseClassName = null;

        boolean canOverwriteResponse = canOverwriteRequest;

        if (!isOneway) {

            responseClassName = beanPackage+StringUtils.capitalize(method.getSimpleName().toString())+RESPONSE.getValue();

            ResponseWrapper resWrapper = method.getAnnotation(ResponseWrapper.class);

            if(resWrapper != null) {

                if (resWrapper.className().length() > 0)

                    responseClassName = resWrapper.className();

                if (resWrapper.localName().length() > 0)

                    resName = resWrapper.localName();

                if (resWrapper.targetNamespace().length() > 0)

                    resNamespace = resWrapper.targetNamespace();

            }

            canOverwriteResponse = builder.canOverWriteClass(responseClassName);

            if (!canOverwriteResponse) {

                builder.log("Class " + responseClassName + " exists. Not overwriting.");

            }

            if (duplicateName(responseClassName) && canOverwriteResponse) {

                builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_RESPONSE_WRAPPER_BEAN_NAME_NOT_UNIQUE(

                        typeElement.getQualifiedName(), method.toString()));

            }

        }

        //ArrayList<MemberInfo> reqMembers = new ArrayList<MemberInfo>();

        //ArrayList<MemberInfo> resMembers = new ArrayList<MemberInfo>();

        WrapperInfo reqWrapperInfo = new WrapperInfo(requestClassName);

        //reqWrapperInfo.setMembers(reqMembers);

        WrapperInfo resWrapperInfo = null;

        if (!isOneway) {

            resWrapperInfo = new WrapperInfo(responseClassName);

            //resWrapperInfo.setMembers(resMembers);

        }

        seiContext.setReqWrapperOperation(method, reqWrapperInfo);

        if (!isOneway)

            seiContext.setResWrapperOperation(method, resWrapperInfo);

        try {

            if (!canOverwriteRequest && !canOverwriteResponse) {

                return false;

            }

            JDefinedClass reqCls = null;

            if (canOverwriteRequest) {

                reqCls = getCMClass(requestClassName, CLASS);

            }

            JDefinedClass resCls = null;

            if (!isOneway && canOverwriteResponse) {

                resCls = getCMClass(responseClassName, CLASS);

            }

            // XMLElement Declarations

            writeXmlElementDeclaration(reqCls, reqName,reqNamespace);

            writeXmlElementDeclaration(resCls, resName, resNamespace);

            List<MemberInfo> reqMembers = ap_generator.collectRequestBeanMembers(method);

            List<MemberInfo> resMembers = ap_generator.collectResponseBeanMembers(method);

            // XmlType

            writeXmlTypeDeclaration(reqCls, reqName, reqNamespace, reqMembers);

            writeXmlTypeDeclaration(resCls, resName, resNamespace, resMembers);

            // class members

            writeMembers(reqCls, reqMembers);

            writeMembers(resCls, resMembers);

        } catch (Exception e) {

            throw new ModelerException("modeler.nestedGeneratorError",e);

        }

        return true;

    }

//    private List<Annotation> collectJAXBAnnotations(Declaration decl) {

//        List<Annotation> jaxbAnnotation = new ArrayList<Annotation>();

//        for(Class jaxbClass : jaxbAnns) {

//            Annotation ann = decl.getAnnotation(jaxbClass);

//            if (ann != null) {

//                jaxbAnnotation.add(ann);

//            }

//        }

//        return jaxbAnnotation;

//    }

    private TypeMirror getSafeType(TypeMirror type) {

        return makeSafeVisitor.visit(type, builder.getProcessingEnvironment().getTypeUtils());

    }

    private JType getType(TypeMirror typeMirror) {

        String type = typeMirror.toString();

        try {

//            System.out.println("typeName: "+typeName);

            return cm.parseType(type);

//            System.out.println("type: "+type);

        } catch (ClassNotFoundException e) {

            return cm.ref(type);

        }

    }

    private void writeMembers(JDefinedClass cls, Collection<MemberInfo> members) {

        if (cls == null)

            return;

        for (MemberInfo memInfo : members) {

            JType type = getType(memInfo.getParamType());

            JFieldVar field = cls.field(JMod.PRIVATE, type, memInfo.getParamName());

            annotateParameterWithJaxbAnnotations(memInfo, field);

        }

        for (MemberInfo memInfo : members) {

            writeMember(cls, memInfo.getParamType(),

                    memInfo.getParamName());

        }

    }

    private void annotateParameterWithJaxbAnnotations(MemberInfo memInfo, JFieldVar field) {

        List<Annotation> jaxbAnnotations = memInfo.getJaxbAnnotations();

        for(Annotation ann : jaxbAnnotations) {

            if (ann instanceof XmlMimeType) {

                JAnnotationUse jaxbAnn = field.annotate(XmlMimeType.class);

                jaxbAnn.param("value", ((XmlMimeType)ann).value());

            } else if (ann instanceof XmlJavaTypeAdapter) {

                JAnnotationUse jaxbAnn = field.annotate(XmlJavaTypeAdapter.class);

                XmlJavaTypeAdapter ja = (XmlJavaTypeAdapter) ann;

                try {

                    ja.value();

                    throw new AssertionError();

                } catch (MirroredTypeException e) {

                    jaxbAnn.param("value",getType(e.getTypeMirror()));

                }

                // XmlJavaTypeAdapter.type() is for package only. No need to copy.

            } else if (ann instanceof XmlAttachmentRef) {

                field.annotate(XmlAttachmentRef.class);

            } else if (ann instanceof XmlList){

                field.annotate(XmlList.class);

            } else if (ann instanceof XmlElement) {

                XmlElement elemAnn = (XmlElement)ann;

                JAnnotationUse jAnn = field.annotate(XmlElement.class);

                jAnn.param("name", elemAnn.name());

                jAnn.param("namespace", elemAnn.namespace());

                if (elemAnn.nillable()) {

                    jAnn.param("nillable", true);

                }

                if (elemAnn.required()) {

                     jAnn.param("required", true);

                }

            } else {

                throw new WebServiceException("SEI Parameter cannot have this JAXB annotation: " + ann);

            }

        }

    }

    protected JDefinedClass getCMClass(String className, com.sun.codemodel.internal.ClassType type) {

        JDefinedClass cls;

        try {

            cls = cm._class(className, type);

        } catch (com.sun.codemodel.internal.JClassAlreadyExistsException e){

            cls = cm._getClass(className);

        }

        return cls;

    }

    private boolean generateExceptionBean(TypeElement thrownDecl, String beanPackage) {

        if (!builder.isServiceException(thrownDecl.asType()))

            return false;

        String exceptionName = ClassNameInfo.getName(thrownDecl.getQualifiedName().toString());

        if (processedExceptions.contains(exceptionName))

            return false;

        processedExceptions.add(exceptionName);

        WebFault webFault = thrownDecl.getAnnotation(WebFault.class);

        String className = beanPackage+ exceptionName + BEAN.getValue();

        Collection<MemberInfo> members = ap_generator.collectExceptionBeanMembers(thrownDecl);

        boolean isWSDLException = isWSDLException(members, thrownDecl);

        String namespace = typeNamespace;

        String name = exceptionName;

        FaultInfo faultInfo;

        if (isWSDLException) {

            TypeMirror beanType =  getFaultInfoMember(members).getParamType();

            faultInfo = new FaultInfo(TypeMonikerFactory.getTypeMoniker(beanType), true);

            namespace = webFault.targetNamespace().length()>0 ?

                               webFault.targetNamespace() : namespace;

            name = webFault.name().length()>0 ?

                          webFault.name() : name;

            faultInfo.setElementName(new QName(namespace, name));

            seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);

            return false;

        }

        if (webFault != null) {

            namespace = webFault.targetNamespace().length()>0 ?

                        webFault.targetNamespace() : namespace;

            name = webFault.name().length()>0 ?

                   webFault.name() : name;

            className = webFault.faultBean().length()>0 ?

                        webFault.faultBean() : className;

        }

        JDefinedClass cls = getCMClass(className, CLASS);

        faultInfo = new FaultInfo(className, false);

        if (duplicateName(className)) {

            builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_EXCEPTION_BEAN_NAME_NOT_UNIQUE(

                    typeElement.getQualifiedName(), thrownDecl.getQualifiedName()));

        }

        boolean canOverWriteBean = builder.canOverWriteClass(className);

        if (!canOverWriteBean) {

            builder.log("Class " + className + " exists. Not overwriting.");

            seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);

            return false;

        }

            return false;

        //write class comment - JAXWS warning

        JDocComment comment = cls.javadoc();

        for (String doc : GeneratorBase.getJAXWSClassComment(ToolVersion.VERSION.MAJOR_VERSION)) {

            comment.add(doc);

        }

        // XmlElement Declarations

        writeXmlElementDeclaration(cls, name, namespace);

        // XmlType Declaration

        //members = sortMembers(members);

        XmlType xmlType = thrownDecl.getAnnotation(XmlType.class);

        String xmlTypeName = (xmlType != null && !xmlType.name().equals("##default")) ? xmlType.name() : exceptionName;

        String xmlTypeNamespace = (xmlType != null && !xmlType.namespace().equals("##default")) ? xmlType.namespace() : typeNamespace;

        writeXmlTypeDeclaration(cls, xmlTypeName, xmlTypeNamespace, members);

        writeMembers(cls, members);

        seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);

        return true;

    }

    protected boolean isWSDLException(Collection<MemberInfo> members, TypeElement thrownDecl) {

        WebFault webFault = thrownDecl.getAnnotation(WebFault.class);

        return webFault != null && members.size() == 2 && getFaultInfoMember(members) != null;

    }

    /*

     * Returns the corresponding MemberInfo for getFaultInfo()

     * method of an exception. Returns null, if that method is not there.

     */

    private MemberInfo getFaultInfoMember(Collection<MemberInfo> members) {

        for(MemberInfo member : members) {

            if (member.getParamName().equals(FAULT_INFO.getValue())) {

                return member;

            }

        }

        return null;

    }

    private void writeXmlElementDeclaration(JDefinedClass cls, String elementName, String namespaceUri) {

       if (cls == null)

            return;

        JAnnotationUse xmlRootElementAnn = cls.annotate(XmlRootElement.class);