/*

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

import java.lang.annotation.Annotation;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import java.util.AbstractList;

import javax.xml.bind.annotation.XmlAccessOrder;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorOrder;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlAnyAttribute;

import javax.xml.bind.annotation.XmlAnyElement;

import javax.xml.bind.annotation.XmlAttachmentRef;

import javax.xml.bind.annotation.XmlAttribute;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementRef;

import javax.xml.bind.annotation.XmlElementRefs;

import javax.xml.bind.annotation.XmlElementWrapper;

import javax.xml.bind.annotation.XmlElements;

import javax.xml.bind.annotation.XmlID;

import javax.xml.bind.annotation.XmlIDREF;

import javax.xml.bind.annotation.XmlInlineBinaryData;

import javax.xml.bind.annotation.XmlList;

import javax.xml.bind.annotation.XmlMimeType;

import javax.xml.bind.annotation.XmlMixed;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlSchemaType;

import javax.xml.bind.annotation.XmlTransient;

import javax.xml.bind.annotation.XmlType;

import javax.xml.bind.annotation.XmlValue;

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

import javax.xml.namespace.QName;

import com.sun.istack.internal.FinalArrayList;

import com.sun.xml.internal.bind.annotation.OverrideAnnotationOf;

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

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

import com.sun.xml.internal.bind.v2.model.core.ClassInfo;

import com.sun.xml.internal.bind.v2.model.core.Element;

import com.sun.xml.internal.bind.v2.model.core.ID;

import com.sun.xml.internal.bind.v2.model.core.NonElement;

import com.sun.xml.internal.bind.v2.model.core.PropertyInfo;

import com.sun.xml.internal.bind.v2.model.core.PropertyKind;

import com.sun.xml.internal.bind.v2.model.core.ValuePropertyInfo;

import com.sun.xml.internal.bind.v2.runtime.IllegalAnnotationException;

import com.sun.xml.internal.bind.v2.runtime.Location;

import com.sun.xml.internal.bind.v2.util.EditDistance;

/**

 * A part of the {@link ClassInfo} that doesn't depend on a particular

 * reflection library.

 *

 * @author Kohsuke Kawaguchi (kk@kohsuke.org)

 */

public class ClassInfoImpl<T,C,F,M> extends TypeInfoImpl<T,C,F,M>

    implements ClassInfo<T,C>, Element<T,C> {

    protected final C clazz;

    /**

     * @see #getElementName()

     */

    private final QName elementName;

    /**

     * @see #getTypeName()

     */

    private final QName typeName;

    /**

     * Lazily created.

     *

     * @see #getProperties()

     */

    private FinalArrayList<PropertyInfoImpl<T,C,F,M>> properties;

    /**

     * The property order.

     *

     * null if unordered. {@link #DEFAULT_ORDER} if ordered but the order is defaulted

     *

     * @see #isOrdered()

     */

    private /*final*/ String[] propOrder;

    /**

     * Lazily computed.

     *

     * To avoid the cyclic references of the form C1 --base--> C2 --property--> C1.

     */

    private ClassInfoImpl<T,C,F,M> baseClass;

    private boolean baseClassComputed = false;

    private boolean hasSubClasses = false;

    /**

     * If this class has a declared (not inherited) attribute wildcard,  keep the reference

     * to it.

     *

     * This parameter is initialized at the construction time and never change.

     */

    protected /*final*/ PropertySeed<T,C,F,M> attributeWildcard;

    /**

     * @see #getFactoryMethod()

     */

    private M factoryMethod = null;

    ClassInfoImpl(ModelBuilder<T,C,F,M> builder, Locatable upstream, C clazz) {

        super(builder,upstream);

        this.clazz = clazz;

        assert clazz!=null;

        // compute the element name

        elementName = parseElementName(clazz);

        // compute the type name

        XmlType t = reader().getClassAnnotation(XmlType.class,clazz,this);

        typeName = parseTypeName(clazz,t);

        if(t!=null) {

            String[] propOrder = t.propOrder();

            if(propOrder.length==0)

                this.propOrder = null;   // unordered

            else {

                if(propOrder[0].length()==0)

                    this.propOrder = DEFAULT_ORDER;

                else

                    this.propOrder = propOrder;

            }

        } else {

            propOrder = DEFAULT_ORDER;

        }

        // obtain XmlAccessorOrder and  set proporder (XmlAccessorOrder can be defined for whole package)

        // (<xs:all> vs <xs:sequence>)

        XmlAccessorOrder xao = reader().getPackageAnnotation(XmlAccessorOrder.class, clazz, this);

        if((xao != null) && (xao.value() == XmlAccessOrder.UNDEFINED)) {

            propOrder = null;

        }

        // obtain XmlAccessorOrder and  set proporder (<xs:all> vs <xs:sequence>)

        xao = reader().getClassAnnotation(XmlAccessorOrder.class, clazz, this);

        if((xao != null) && (xao.value() == XmlAccessOrder.UNDEFINED)) {

            propOrder = null;

        }

        if(nav().isInterface(clazz)) {

            builder.reportError(new IllegalAnnotationException(

                Messages.CANT_HANDLE_INTERFACE.format(nav().getClassName(clazz)), this ));

        }

        // the class must have the default constructor

        if (!hasFactoryConstructor(t)){

            if(!nav().hasDefaultConstructor(clazz)){

                if(nav().isInnerClass(clazz)) {

                    builder.reportError(new IllegalAnnotationException(

                        Messages.CANT_HANDLE_INNER_CLASS.format(nav().getClassName(clazz)), this ));

                } else if (elementName != null) {

                    builder.reportError(new IllegalAnnotationException(

                        Messages.NO_DEFAULT_CONSTRUCTOR.format(nav().getClassName(clazz)), this ));

                }

            }

        }

    }

    public ClassInfoImpl<T,C,F,M> getBaseClass() {

        if (!baseClassComputed) {

            // compute the base class

            C s = nav().getSuperClass(clazz);

            if(s==null || s==nav().asDecl(Object.class)) {

                baseClass = null;

            } else {

                NonElement<T,C> b = builder.getClassInfo(s, true, this);

                if(b instanceof ClassInfoImpl) {

                    baseClass = (ClassInfoImpl<T,C,F,M>) b;

                    baseClass.hasSubClasses = true;

                } else {

                    baseClass = null;

                }

            }

            baseClassComputed = true;

        }

        return baseClass;

    }

    /**

     * {@inheritDoc}

     *

     * The substitution hierarchy is the same as the inheritance hierarchy.

     */

    public final Element<T,C> getSubstitutionHead() {

        ClassInfoImpl<T,C,F,M> c = getBaseClass();

        while(c!=null && !c.isElement())

            c = c.getBaseClass();

        return c;

    }

    public final C getClazz() {

        return clazz;

    }

    /**

     * When a bean binds to an element, it's always through {@link XmlRootElement},

     * so this method always return null.

     *

     * @deprecated

     *      you shouldn't be invoking this method on {@link ClassInfoImpl}.

     */

    public ClassInfoImpl<T,C,F,M> getScope() {

        return null;

    }

    public final T getType() {

        return nav().use(clazz);

    }

    /**

     * A {@link ClassInfo} can be referenced by {@link XmlIDREF} if

     * it has an ID property.

     */

    public boolean canBeReferencedByIDREF() {

        for (PropertyInfo<T,C> p : getProperties()) {

            if(p.id()== ID.ID)

                return true;

        }

        ClassInfoImpl<T,C,F,M> base = getBaseClass();

        if(base!=null)

            return base.canBeReferencedByIDREF();

        else

            return false;

    }

    public final String getName() {

        return nav().getClassName(clazz);

    }

    public <A extends Annotation> A readAnnotation(Class<A> a) {

        return reader().getClassAnnotation(a,clazz,this);

    }

    public Element<T,C> asElement() {

        if(isElement())

            return this;

        else

            return null;

    }

    public List<? extends PropertyInfo<T,C>> getProperties() {

        if(properties!=null)    return properties;

        // check the access type first

        XmlAccessType at = getAccessType();

        properties = new FinalArrayList<PropertyInfoImpl<T,C,F,M>>();

        findFieldProperties(clazz,at);

        findGetterSetterProperties(at);

        if(propOrder==DEFAULT_ORDER || propOrder==null) {

            XmlAccessOrder ao = getAccessorOrder();

            if(ao==XmlAccessOrder.ALPHABETICAL)

                Collections.sort(properties);

        } else {

            //sort them as specified

            PropertySorter sorter = new PropertySorter();

            for (PropertyInfoImpl p : properties) {

                sorter.checkedGet(p);   // have it check for errors

            }

            Collections.sort(properties,sorter);

            sorter.checkUnusedProperties();

        }

        {// additional error checks

            PropertyInfoImpl vp=null; // existing value property

            PropertyInfoImpl ep=null; // existing element property

            for (PropertyInfoImpl p : properties) {

                switch(p.kind()) {

                case ELEMENT:

                case REFERENCE:

                case MAP:

                    ep = p;

                    break;

                case VALUE:

                    if(vp!=null) {

                        // can't have multiple value properties.

                        builder.reportError(new IllegalAnnotationException(

                            Messages.MULTIPLE_VALUE_PROPERTY.format(),

                            vp, p ));

                    }

                    if(getBaseClass()!=null) {

                        builder.reportError(new IllegalAnnotationException(

                            Messages.XMLVALUE_IN_DERIVED_TYPE.format(), p ));

                    }

                    vp = p;

                    break;

                case ATTRIBUTE:

                    break;  // noop

                default:

                    assert false;

                }

            }

            if(ep!=null && vp!=null) {

                // can't have element and value property at the same time

                builder.reportError(new IllegalAnnotationException(

                    Messages.ELEMENT_AND_VALUE_PROPERTY.format(),

                    vp, ep

                ));

            }

        }

        return properties;

    }

    private void findFieldProperties(C c, XmlAccessType at) {

        // always find properties from the super class first

        C sc = nav().getSuperClass(c);

        if (shouldRecurseSuperClass(sc)) {

            findFieldProperties(sc,at);

        }

        for( F f : nav().getDeclaredFields(c) ) {

            Annotation[] annotations = reader().getAllFieldAnnotations(f,this);

            boolean isDummy = reader().hasFieldAnnotation(OverrideAnnotationOf.class, f);

            if( nav().isTransient(f) ) {

                // it's an error for transient field to have any binding annotation

                if(hasJAXBAnnotation(annotations))

                    builder.reportError(new IllegalAnnotationException(

                        Messages.TRANSIENT_FIELD_NOT_BINDABLE.format(nav().getFieldName(f)),

                            getSomeJAXBAnnotation(annotations)));

            } else

            if( nav().isStaticField(f) ) {

                // static fields are bound only when there's explicit annotation.

                if(hasJAXBAnnotation(annotations))

                    addProperty(createFieldSeed(f),annotations, false);

            } else {

                if(at==XmlAccessType.FIELD

                ||(at==XmlAccessType.PUBLIC_MEMBER && nav().isPublicField(f))

                || hasJAXBAnnotation(annotations)) {

                    if (isDummy) {

                        ClassInfo<T, C> top = getBaseClass();

                        while ((top != null) && (top.getProperty("content") == null)) {

                            top = top.getBaseClass();

                        }

                        DummyPropertyInfo prop = (DummyPropertyInfo) top.getProperty("content");

                        PropertySeed seed = createFieldSeed(f);

                        ((DummyPropertyInfo)prop).addType(createReferenceProperty(seed));

                    } else {

                        addProperty(createFieldSeed(f), annotations, false);

                    }

                }

                checkFieldXmlLocation(f);

            }

        }

    }

    public final boolean hasValueProperty() {

        ClassInfoImpl<T, C, F, M> bc = getBaseClass();

        if(bc!=null && bc.hasValueProperty())

            return true;

        for (PropertyInfo p : getProperties()) {

            if (p instanceof ValuePropertyInfo) return true;

        }

        return false;

        }

    public PropertyInfo<T,C> getProperty(String name) {

        for( PropertyInfo<T,C> p: getProperties() ) {

            if(p.getName().equals(name))

                return p;

        }

        return null;

    }

    /**

     */

    protected void checkFieldXmlLocation(F f) {

    }

    /**

     * Gets an annotation that are allowed on both class and type.

     */

    private <T extends Annotation> T getClassOrPackageAnnotation(Class<T> type) {

        T t = reader().getClassAnnotation(type,clazz,this);

        if(t!=null)

            return t;

        // defaults to the package level

        return reader().getPackageAnnotation(type,clazz,this);

    }

    /**

     * Computes the {@link XmlAccessType} on this class by looking at {@link XmlAccessorType}

     * annotations.

     */

    private XmlAccessType getAccessType() {

        XmlAccessorType xat = getClassOrPackageAnnotation(XmlAccessorType.class);

        if(xat!=null)

            return xat.value();

        else

            return XmlAccessType.PUBLIC_MEMBER;

    }

    /**

     * Gets the accessor order for this class by consulting {@link XmlAccessorOrder}.

     */

    private XmlAccessOrder getAccessorOrder() {

        XmlAccessorOrder xao = getClassOrPackageAnnotation(XmlAccessorOrder.class);

        if(xao!=null)

            return xao.value();

        else

            return XmlAccessOrder.UNDEFINED;

    }

    /**

     * Compares orders among {@link PropertyInfoImpl} according to {@link ClassInfoImpl#propOrder}.

     *

     * <p>

     * extends {@link HashMap} to save memory.

     */

    private final class PropertySorter extends HashMap<String,Integer> implements Comparator<PropertyInfoImpl> {

        /**

         * Mark property names that are used, so that we can report unused property names in the propOrder array.

         */

        PropertyInfoImpl[] used = new PropertyInfoImpl[propOrder.length];

        /**

         * If any name collides, it will be added to this set.

         * This is used to avoid repeating the same error message.

         */

        private Set<String> collidedNames;

        PropertySorter() {

            super(propOrder.length);

            for( String name : propOrder )

                if(put(name,size())!=null) {

                    // two properties with the same name

                    builder.reportError(new IllegalAnnotationException(

                        Messages.DUPLICATE_ENTRY_IN_PROP_ORDER.format(name),ClassInfoImpl.this));

                }

        }

        public int compare(PropertyInfoImpl o1, PropertyInfoImpl o2) {

            int lhs = checkedGet(o1);

            int rhs = checkedGet(o2);

            return lhs-rhs;

        }

        private int checkedGet(PropertyInfoImpl p) {

            Integer i = get(p.getName());

            if(i==null) {

                // missing

                if (p.kind().isOrdered)

                    builder.reportError(new IllegalAnnotationException(

                        Messages.PROPERTY_MISSING_FROM_ORDER.format(p.getName()),p));

                // give it an order to recover from an error

                i = size();

                put(p.getName(),i);

            }

            // mark the used field

            int ii = i;

            if(ii<used.length) {

                if(used[ii]!=null && used[ii]!=p) {

                    if(collidedNames==null) collidedNames = new HashSet<String>();

                    if(collidedNames.add(p.getName()))

                        // report the error only on the first time

                        builder.reportError(new IllegalAnnotationException(

                            Messages.DUPLICATE_PROPERTIES.format(p.getName()),p,used[ii]));

                }

                used[ii] = p;

            }

            return i;

        }

        /**

         * Report errors for unused propOrder entries.

         */