/*******************************************************************************
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.apt.model;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.AnnotationValueVisitor;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeMirror;

import org.eclipse.jdt.internal.compiler.apt.dispatch.BaseProcessingEnvImpl;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.impl.DoubleConstant;
import org.eclipse.jdt.internal.compiler.impl.FloatConstant;
import org.eclipse.jdt.internal.compiler.impl.LongConstant;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.problem.ShouldNotImplement;

public class AnnotationValueImpl implements AnnotationValue, TypeIds {
	
	/*
	 * Additions to T_* constants in TypeIds. 
	 */
	private static final int T_AnnotationMirror = -1;
	private static final int T_EnumConstant = -2;
	private static final int T_ClassObject = -3;
	private static final int T_ArrayType = -4;
	
	private final BaseProcessingEnvImpl _env;
	
	/**
	 * The annotation value, as it would be returned by
	 * {@link #getValue()}.  For instance, an Integer (for an int
	 * constant), a VariableElement (for an enum constant), or
	 * a List<AnnotationValueImpl> containing multiple such (for an array type).  
	 */
	private final Object _value;
	
	/**
	 * The type stored in _value, represented as a T_* value from {@link TypeIds}
	 * or one of the additional T_* values defined in this class.
	 */
	private final int _kind;

	/**
	 * @param value
	 *            The JDT representation of a compile-time constant. See
	 *            {@link ElementValuePair#getValue()} for possible object types:
	 *            <ul>
	 *            <li>{@link org.eclipse.jdt.internal.compiler.impl.Constant} for member
	 *            of primitive type or String</li>
	 *            <li>{@link TypeBinding} for a member value of type
	 *            {@link java.lang.Class}</li>
	 *            <li>{@link FieldBinding} for an enum constant</li>
	 *            <li>{@link AnnotationBinding} for an annotation instance</li>
	 *            <li><code>Object[]</code> for a member value of array type, where the
	 *            array entries are one of the above</li>
	 *            </ul>
	 * @param type
	 *            The JDT representation of the type of the constant, as determined
	 *            by the return type of the element.  This is needed because the type
	 *            of the value may have been widened (e.g., byte to int) by the compiler
	 *            and we need to call the proper visitor.  This is used only for base types.
	 *            If it is null or not a BaseTypeBinding, it is ignored and the type is
	 *            determined from the type of the value.
	 */
	public AnnotationValueImpl(BaseProcessingEnvImpl env, Object value, TypeBinding type) {
		_env = env;
		int kind[] = new int[1];
		if (type == null) {
			_value = convertToMirrorType(value, type, kind);
			_kind = kind[0];
		} else if (type.isArrayType()) {
			List<AnnotationValue> convertedValues = null;
			TypeBinding valueType = ((ArrayBinding)type).elementsType();
			if (value instanceof Object[]) {
				Object[] values = (Object[])value;
				convertedValues = new ArrayList<AnnotationValue>(values.length);
				for (Object oneValue : values) {
					convertedValues.add(new AnnotationValueImpl(_env, oneValue, valueType));
				}
			} else {
				convertedValues = new ArrayList<AnnotationValue>(1);
				convertedValues.add(new AnnotationValueImpl(_env, value, valueType));
			}
			_value = Collections.unmodifiableList(convertedValues);
			_kind = T_ArrayType;
		} else {
			_value = convertToMirrorType(value, type, kind);
			_kind = kind[0];
		}
	}
	
	/**
	 * Convert the JDT representation of a single constant into its javax.lang.model
	 * representation.  For instance, convert a StringConstant into a String, or
	 * a FieldBinding into a VariableElement.  This does not handle the case where
	 * value is an Object[].
	 * @param value the JDT object
	 * @param type the return type of the annotation member.  If null or not a
	 * BaseTypeBinding, this is ignored and the value is inspected to determine type.
	 * @param kind an int array whose first element will be set to the type of the
	 * converted object, represented with T_* values from TypeIds or from this class.
	 * @return
	 */
	private Object convertToMirrorType(Object value, TypeBinding type, int kind[]) {
		if (type == null) {
			kind[0] = TypeIds.T_JavaLangString;
			return "<error>"; //$NON-NLS-1$
		} else if (type instanceof BaseTypeBinding || type.id == TypeIds.T_JavaLangString) {
			if (value == null) {
				if (type instanceof BaseTypeBinding
						|| type.id == TypeIds.T_JavaLangString) {
					// return a string with error in it to reflect a value that could not be resolved
					kind[0] = TypeIds.T_JavaLangString;
					return "<error>"; //$NON-NLS-1$
				} else if (type.isAnnotationType()) {
					kind[0] = T_AnnotationMirror;
					return _env.getFactory().newAnnotationMirror(null);
				}
			} else if (value instanceof Constant) {
				if (type instanceof BaseTypeBinding) {
					kind[0] = ((BaseTypeBinding)type).id;
				}
				else if (type.id == TypeIds.T_JavaLangString) {
					kind[0] = ((Constant)value).typeID();
				} else {
					// error case
					kind[0] = TypeIds.T_JavaLangString;
					return "<error>"; //$NON-NLS-1$
				}
				switch (kind[0]) {
				case T_boolean:
					return ((Constant)value).booleanValue();
				case T_byte:
					return ((Constant)value).byteValue();
				case T_char:
					return ((Constant)value).charValue();
				case T_double:
					return ((Constant)value).doubleValue();
				case T_float:
					return ((Constant)value).floatValue();
				case T_int:
					try {
						if (value instanceof LongConstant
								|| value instanceof DoubleConstant
								|| value instanceof FloatConstant) {
							// error case
							kind[0] = TypeIds.T_JavaLangString;
							return "<error>"; //$NON-NLS-1$
						}
						return ((Constant)value).intValue();
					} catch (ShouldNotImplement e) {
						kind[0] = TypeIds.T_JavaLangString;
						return "<error>"; //$NON-NLS-1$
					}
				case T_JavaLangString:
					return ((Constant)value).stringValue();
				case T_long:
					return ((Constant)value).longValue();
				case T_short:
					return ((Constant)value).shortValue();
				}
			}
		} else if (type.isEnum()) {
			if (value instanceof FieldBinding) {
				kind[0] = T_EnumConstant;
				return (VariableElement) _env.getFactory().newElement((FieldBinding) value);
			} else {
				kind[0] = TypeIds.T_JavaLangString;
				return "<error>"; //$NON-NLS-1$
			}
		} else if (type.isAnnotationType()) {
			if (value instanceof AnnotationBinding) {
				kind[0] = T_AnnotationMirror;
				return _env.getFactory().newAnnotationMirror((AnnotationBinding) value);
			}
		} else if (value instanceof TypeBinding) {
			kind[0] = T_ClassObject;
			return _env.getFactory().newTypeMirror((TypeBinding) value);
		}
		// error case
		kind[0] = TypeIds.T_JavaLangString;
		return "<error>"; //$NON-NLS-1$
	}

	@SuppressWarnings("unchecked") // Need to cast Object _value to a List<AnnotationValue>
	@Override
	public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
		switch (_kind) {
		case TypeIds.T_boolean:
			return v.visitBoolean((Boolean)_value, p);
		case TypeIds.T_byte:
			return v.visitByte((Byte)_value, p);
		case TypeIds.T_char:
			return v.visitChar((Character)_value, p);
		case TypeIds.T_double:
			return v.visitDouble((Double)_value, p);
		case TypeIds.T_float:
			return v.visitFloat((Float)_value, p);
		case TypeIds.T_int:
			return v.visitInt((Integer)_value, p);
		case TypeIds.T_JavaLangString:
			return v.visitString((String)_value, p);
		case TypeIds.T_long:
			return v.visitLong((Long)_value, p);
		case TypeIds.T_short:
			return v.visitShort((Short)_value, p);
		case T_EnumConstant:
			return v.visitEnumConstant((VariableElement)_value, p);
		case T_ClassObject:
			return v.visitType((TypeMirror)_value, p);
		case T_AnnotationMirror:
			return v.visitAnnotation((AnnotationMirror)_value, p);
		case T_ArrayType:
			return v.visitArray((List<AnnotationValue>)_value, p);
		default:
			return null;
		}
	}

	@Override
	public Object getValue() {
		return _value;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof AnnotationValueImpl) {
			return this._value.equals(((AnnotationValueImpl) obj)._value);
		}
		return false;
	}

	@Override
	public int hashCode() {
		return this._value.hashCode() + this._kind;
	}

	@Override
	public String toString() {
		if (null == _value) {
			return "null"; //$NON-NLS-1$
		}
		return _value.toString();
	}
}