/*******************************************************************************
 * Copyright (c) 2009 Shane Clarke.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Shane Clarke - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.annotations.core;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMemberValuePair;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;

/**
 * An <code>AnnotationDefinition</code> is a representation of the information contributed through the
 * <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>,
 * <code>org.eclipse.jst.ws.annotations.core.annotationCategory</code> and
 * <code>org.eclipse.jst.ws.annotations.core.annotationInitializer</code> extension points.
 * <p>
 * It supplies the annotation class name, its annotation category, the applicable targets for the annotation
 * and an <code>IAnnotationAttributeInitializer</code> to initialize the annotations element-value pairs.
 * </p>
 * <strong>Provisional API:</strong> This class/interface is part of an interim API that is still under
 * development and expected to change significantly before reaching stability. It is being made available at
 * this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses
 * this API will almost certainly be broken (repeatedly) as the API evolves.
 * </p>
 */
public final class AnnotationDefinition {
    private static final String ATT_CLASS = "class"; //$NON-NLS-1$
    private static final String ATT_NAME = "name"; //$NON-NLS-1$
    private static final String ATT_RESTRICTED_TO = "restrictedTo"; //$NON-NLS-1$

    private static final String RESTRICTED_TO_CLASS_ONLY = "CLASS_ONLY";
    private static final String RESTRICTED_TO_INTERFACE_ONLY = "INTERFACE_ONLY";
    private static final String RESTRICTED_TO_ENUM_ONLY = "ENUM_ONLY";

    private static final String ELEM_TARGET_FILTER = "targetFilter"; //$NON-NLS-1$
    private static final String ATT_TARGET = "target"; //$NON-NLS-1$

    private IConfigurationElement configurationElement;
    private String category;
    private String annotationClassName;
    private Class<? extends java.lang.annotation.Annotation> annotationClass;
    private List<ElementType> targets;
    private String name;
    private IAnnotationAttributeInitializer annotationInitializer;
    private String restictedTo;
    private boolean interfaceOnly;
    private boolean classOnly;
    private boolean enumOnly;

    private IType annotationType;
    private List<ElementType> annotationTypeTargets;
    private IJavaProject javaProject;
    private Boolean deprecated;

    /**
     * Constructs an <code>AnnotationDefinition</code> using information from the
     * <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code> extension point and category name.
     * @param configurationElement the <code>annotation</code> element from the <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code> extension point
     * @param category the category name
     */
    public AnnotationDefinition(IConfigurationElement configurationElement, String category) {
        this.configurationElement = configurationElement;
        this.category = category;

        this.annotationClassName = AnnotationsManager.getAttributeValue(configurationElement, ATT_CLASS);
        this.name = AnnotationsManager.getAttributeValue(configurationElement, ATT_NAME);
        this.restictedTo = AnnotationsManager.getAttributeValue(configurationElement, ATT_RESTRICTED_TO);
        this.classOnly = restictedTo.equals(RESTRICTED_TO_CLASS_ONLY);
        this.interfaceOnly = restictedTo.equals(RESTRICTED_TO_INTERFACE_ONLY);
        this.enumOnly = restictedTo.equals(RESTRICTED_TO_ENUM_ONLY);
    }

    /**
     * Returns the annotation name.
     * @return the annotation name.
     */
    public String getName() {
        return name;
    }

    /**
     * Returns the category the annotation belongs to.
     * @return the annotation category.
     */
    public String getCategory() {
        return category;
    }

    /**
     * Returns the fully qualified class name of the annotation.
     * @return the fully qualified class name of the annotation.
     */
    public String getAnnotationClassName() {
        return annotationClassName;
    }

    /**
     * Returns whether the annotation is restricted to class types.
     * @return <code>true</code> if the annotation is restricted to classes only.
     */
    public boolean isClassOnly() {
        return classOnly;
    }

    /**
     * Returns whether the annotation is restricted to interface types.
     * @return <code>true</code> if the annotation is restricted to interfaces only.
     */
    public boolean isInterfaceOnly() {
        return interfaceOnly;
    }

    /**
     * Returns whether the annotation is restricted to enum types.
     * @return <code>true</code> if the annotation is restricted to enums only.
     */
    public boolean isEnumOnly() {
        return enumOnly;
    }

    /**
     * Returns the annotation class as specified by the <code>class</code> attribute of the
     * <code>annotation<annotation> element in the <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>
     * extension point.
     *
     * @return the annotation class or null if not found.
     * @deprecated As of 1.1 replaced by {@link #getAnnotationType()}
     */
    @SuppressWarnings("unchecked")
    @Deprecated
    public Class<? extends java.lang.annotation.Annotation> getAnnotationClass() {
        if (annotationClass == null) {
            try {
                Class<?> aClass = Class.forName(annotationClassName);
                if (aClass.isAnnotation()) {
                    annotationClass = (Class<java.lang.annotation.Annotation>) Class.forName(annotationClassName);
                }
            } catch(ClassNotFoundException cnfe) {
                AnnotationsCorePlugin.log(cnfe);
            }
        }
        return annotationClass;
    }

    /**
     * Returns the annotation type as specified by the <code>class</code> attribute of the
     * <code>annotation<annotation> element in the <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>
     * extension point.
     * 
     * @return the <code>org.eclipse.jdt.core.IType</code> which represents an annotation type or null if the java project
     * has not been set, if the type cannot be found or if the type does not represent an annotation type.
     * 
     * @see #setJavaProject(IJavaProject)
     * @since 1.1
     */
    public IType getAnnotationType() {
        if (annotationType == null) {
            try {
                if (javaProject != null) {
                    IType type = javaProject.findType(annotationClassName);
                    if (type != null && type.isAnnotation()) {
                        annotationType = type;
                    }
                }
            } catch (JavaModelException jme) {
                AnnotationsCorePlugin.log(jme.getStatus());
            }
        }
        return annotationType;
    }

    /**
     * Returns a list of {@link ElementType} that specify the Java elements to which the annotation
     * can be applied.
     * <p>
     * The element types are retrieved from the annotations
     * {@link java.lang.annotation.Target} meta-annotation type. This list can be filtered using
     * the <code>targetFilter</code> element on the
     * <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code> extension point when defining
     * the annotation.
     * </p>
     * @return a list of element types.
     * @deprecated as of 1.1 replaced by {@link #getAnnotationTypeTargets()}
     */
    @Deprecated
    public List<ElementType> getTargets() {
        if (targets == null) {
            targets = new LinkedList<ElementType>();

            Class<? extends java.lang.annotation.Annotation> annotation = getAnnotationClass();
            if (annotation != null) {
                Target target = annotation.getAnnotation(Target.class);
                if (target != null) {
                    targets.addAll(Arrays.asList(target.value()));

                    List<ElementType> filteredTargets = getFilteredTargets(configurationElement);
                    if (targets.containsAll(filteredTargets) && filteredTargets.size() < targets.size()) {
                        targets.removeAll(filteredTargets);
                    }
                }
            }
        }
        return targets;
    }

    /**
     * Returns a list of {@link java.lang.annotation.ElementType} that specify the Java elements to which the annotation can be applied.
     * <p>
     * The element types are retrieved from the annotations
     * {@link java.lang.annotation.Target} meta-annotation type. This list can
     * be filtered using the <code>targetFilter</code> element on the
     * <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>
     * extension point when defining the annotation.
     * </p>
     * @return a list of element types or null if the java project has not been set or if the annotation type cannot be
     * found.
     * @see #setJavaProject(IJavaProject)
     * @since 1.1
     */
    public List<ElementType> getAnnotationTypeTargets() {
        if (annotationTypeTargets == null) {
            annotationTypeTargets = new LinkedList<ElementType>();
            try {
                IType type = getAnnotationType();
                if (type != null) {
                    IAnnotation target = type.getAnnotation(Target.class.getCanonicalName());
                    if (!target.exists()) {
                        target = type.getAnnotation(Target.class.getSimpleName());
                    }
                    if (target.exists()) {
                        IMemberValuePair[] memberValuePairs = target.getMemberValuePairs();
                        for (IMemberValuePair memberValuePair : memberValuePairs) {
                            Object value = memberValuePair.getValue();
                            if (value.getClass().isArray() && value.getClass().getComponentType().equals(String.class)) {
                                String[] objs = (String[]) value;
                                for (String obj : objs) {
                                    annotationTypeTargets.add(ElementType.valueOf(obj.substring(obj.lastIndexOf('.') + 1)));
                                }
                            } else {
                                annotationTypeTargets.add(ElementType.valueOf(value.toString().substring(value.toString().lastIndexOf('.') + 1)));
                            }
                        }
                    } else {
                        //Target meta-annotation is not present on an annotation type declaration, the declared type may be used on any program element.
                    	annotationTypeTargets.addAll(Arrays.asList(ElementType.values()));
                    }
                    List<ElementType> filteredTargets = getFilteredTargets(configurationElement);
                    if (annotationTypeTargets.containsAll(filteredTargets) && filteredTargets.size() < annotationTypeTargets.size()) {
                        annotationTypeTargets.removeAll(filteredTargets);
                    }
                }
            } catch (JavaModelException jme) {
                AnnotationsCorePlugin.log(jme.getStatus());
            }
        }
        return annotationTypeTargets;
    }

    /**
     * Returns the annotations attribute initializer as specified in the
     * <code>org.eclipse.jst.ws.annotations.core.annotationInitializer</code> extension point or null if no
     * initializer can be found.
     *
     * @return the <code>IAnnotationAttributeInitializer</code>
     */
    public IAnnotationAttributeInitializer getAnnotationAttributeInitializer() {
        if (annotationInitializer == null) {
            try {
                IConfigurationElement configurationElement =
                    AnnotationsManager.getAnnotationInitializerCache().get(getAnnotationClassName());
                if (configurationElement != null) {
                    annotationInitializer = (IAnnotationAttributeInitializer) configurationElement.createExecutableExtension(ATT_CLASS);
                }
            } catch (CoreException ce) {
                AnnotationsCorePlugin.log(ce.getStatus());
            }
        }
        return annotationInitializer;
    }

    private List<ElementType> getFilteredTargets(IConfigurationElement configurationElement) {
        List<ElementType> targets = new ArrayList<ElementType>(7);
        try {
            IConfigurationElement[] deprecatedTargets = configurationElement.getChildren(ELEM_TARGET_FILTER);
            for (IConfigurationElement deprecatedTargetElement : deprecatedTargets) {
                String target = AnnotationsManager.getAttributeValue(deprecatedTargetElement, ATT_TARGET);
                targets.add(ElementType.valueOf(target));
            }
        } catch (IllegalArgumentException iae) {
            AnnotationsCorePlugin.log(iae);
        }
        return targets;
    }

    boolean isDeprecated() {
        if (deprecated == null) {
            IType type = getAnnotationType();
            if (type != null) {
                IAnnotation annotation = type.getAnnotation(Deprecated.class.getCanonicalName());
                if (!annotation.exists()) {
                    annotation = type.getAnnotation(Deprecated.class.getSimpleName());
                }
                deprecated = annotation.exists();
            } else {
                deprecated = false;
            }
        }
        return deprecated;
    }

    /**
     * Sets the <code>org.eclipse.jdt.core.IJavaProject</code> which is used to find the annotation type.
     * 
     * @see #getAnnotationType()
     * @see #getAnnotationTypeTargets()
     * @since 1.1
     */
    public void setJavaProject(IJavaProject javaProject) {
        if (this.javaProject == null || !this.javaProject.equals(javaProject)) {
            this.javaProject = javaProject;
            this.annotationType = null;
            this.annotationTypeTargets = null;
            this.deprecated = null;
        }
    }
}