/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.dart.engine.internal.element.handle;

import com.google.dart.engine.ast.AstNode;
import com.google.dart.engine.ast.CompilationUnit;
import com.google.dart.engine.context.AnalysisContext;
import com.google.dart.engine.context.AnalysisException;
import com.google.dart.engine.element.ClassElement;
import com.google.dart.engine.element.CompilationUnitElement;
import com.google.dart.engine.element.ConstructorElement;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.ElementAnnotation;
import com.google.dart.engine.element.ElementLocation;
import com.google.dart.engine.element.ElementVisitor;
import com.google.dart.engine.element.ExportElement;
import com.google.dart.engine.element.FieldElement;
import com.google.dart.engine.element.FunctionElement;
import com.google.dart.engine.element.FunctionTypeAliasElement;
import com.google.dart.engine.element.ImportElement;
import com.google.dart.engine.element.LabelElement;
import com.google.dart.engine.element.LibraryElement;
import com.google.dart.engine.element.LocalVariableElement;
import com.google.dart.engine.element.MethodElement;
import com.google.dart.engine.element.ParameterElement;
import com.google.dart.engine.element.PrefixElement;
import com.google.dart.engine.element.PropertyAccessorElement;
import com.google.dart.engine.element.TopLevelVariableElement;
import com.google.dart.engine.element.TypeParameterElement;
import com.google.dart.engine.source.Source;

import java.lang.ref.WeakReference;

/**
 * The abstract class {@code ElementHandle} implements the behavior common to objects that implement
 * a handle to an {@link Element}.
 * 
 * @coverage dart.engine.element
 */
public abstract class ElementHandle implements Element {
  /**
   * Return a handle on the given element. If the element is already a handle, then it will be
   * returned directly, otherwise a handle of the appropriate class will be constructed.
   * 
   * @param element the element for which a handle is to be constructed
   * @return a handle on the given element
   */
  @SuppressWarnings("unchecked")
  public static <E extends Element> E forElement(E element) {
    if (element instanceof ElementHandle) {
      return element;
    }
    switch (element.getKind()) {
      case CLASS:
        return (E) new ClassElementHandle((ClassElement) element);
      case COMPILATION_UNIT:
        return (E) new CompilationUnitElementHandle((CompilationUnitElement) element);
      case CONSTRUCTOR:
        return (E) new ConstructorElementHandle((ConstructorElement) element);
      case EXPORT:
        return (E) new ExportElementHandle((ExportElement) element);
      case FIELD:
        return (E) new FieldElementHandle((FieldElement) element);
      case FUNCTION:
        return (E) new FunctionElementHandle((FunctionElement) element);
      case GETTER:
        return (E) new PropertyAccessorElementHandle((PropertyAccessorElement) element);
        //case HTML:
      case IMPORT:
        return (E) new ImportElementHandle((ImportElement) element);
      case LABEL:
        return (E) new LabelElementHandle((LabelElement) element);
      case LIBRARY:
        return (E) new LibraryElementHandle((LibraryElement) element);
      case LOCAL_VARIABLE:
        return (E) new LocalVariableElementHandle((LocalVariableElement) element);
      case METHOD:
        return (E) new MethodElementHandle((MethodElement) element);
      case PARAMETER:
        return (E) new ParameterElementHandle((ParameterElement) element);
      case PREFIX:
        return (E) new PrefixElementHandle((PrefixElement) element);
      case SETTER:
        return (E) new PropertyAccessorElementHandle((PropertyAccessorElement) element);
      case TOP_LEVEL_VARIABLE:
        return (E) new TopLevelVariableElementHandle((TopLevelVariableElement) element);
      case FUNCTION_TYPE_ALIAS:
        return (E) new FunctionTypeAliasElementHandle((FunctionTypeAliasElement) element);
      case TYPE_PARAMETER:
        return (E) new TypeParameterElementHandle((TypeParameterElement) element);
      default:
        throw new UnsupportedOperationException();
    }
  }

  /**
   * Return an array of the same size as the given array where each element of the returned array is
   * a handle for the corresponding element of the given array.
   * 
   * @param elements the elements for which handles are to be created
   * @return an array of handles to the given elements
   */
  public static <E extends Element> E[] forElements(E[] elements) {
    int length = elements.length;
    E[] handles = elements.clone();
    for (int i = 0; i < length; i++) {
      handles[i] = forElement(elements[i]);
    }
    return handles;
  }

  /**
   * The context in which the element is defined.
   */
  private AnalysisContext context;

  /**
   * The location of this element, used to reconstitute the element if it has been garbage
   * collected.
   */
  private ElementLocation location;

  /**
   * A reference to the element being referenced by this handle, or {@code null} if the element has
   * been garbage collected.
   */
  private WeakReference<Element> elementReference;

  /**
   * Initialize a newly created element handle to represent the given element.
   * 
   * @param element the element being represented
   */
  public ElementHandle(Element element) {
    context = element.getContext();
    location = element.getLocation();
    elementReference = new WeakReference<Element>(element);
  }

  @Override
  public <R> R accept(ElementVisitor<R> visitor) {
    return getActualElement().accept(visitor);
  }

  @Override
  public String computeDocumentationComment() throws AnalysisException {
    return getActualElement().computeDocumentationComment();
  }

  @Override
  public boolean equals(Object object) {
    return object instanceof Element && ((Element) object).getLocation().equals(location);
  }

  @Override
  public <E extends Element> E getAncestor(Class<E> elementClass) {
    return getActualElement().getAncestor(elementClass);
  }

  @Override
  public AnalysisContext getContext() {
    return context;
  }

  @Override
  public String getDisplayName() {
    return getActualElement().getDisplayName();
  }

  @Override
  public Element getEnclosingElement() {
    return getActualElement().getEnclosingElement();
  }

  @Override
  public String getExtendedDisplayName(String shortName) {
    return getActualElement().getExtendedDisplayName(shortName);
  }

  @Override
  public LibraryElement getLibrary() {
    return getAncestor(LibraryElement.class);
  }

  @Override
  public ElementLocation getLocation() {
    return location;
  }

  @Override
  public ElementAnnotation[] getMetadata() {
    return getActualElement().getMetadata();
  }

  @Override
  public String getName() {
    return getActualElement().getName();
  }

  @Override
  public int getNameOffset() {
    return getActualElement().getNameOffset();
  }

  @Override
  public AstNode getNode() throws AnalysisException {
    return getActualElement().getNode();
  }

  @Override
  public Source getSource() {
    return getActualElement().getSource();
  }

  @Override
  public CompilationUnit getUnit() throws AnalysisException {
    return getActualElement().getUnit();
  }

  @Override
  public int hashCode() {
    return location.hashCode();
  }

  @Override
  public boolean isAccessibleIn(LibraryElement library) {
    return getActualElement().isAccessibleIn(library);
  }

  @Override
  public boolean isDeprecated() {
    return getActualElement().isDeprecated();
  }

  @Override
  public boolean isOverride() {
    return getActualElement().isOverride();
  }

  @Override
  public boolean isPrivate() {
    return getActualElement().isPrivate();
  }

  @Override
  public boolean isPublic() {
    return getActualElement().isPublic();
  }

  @Override
  public boolean isSynthetic() {
    return getActualElement().isSynthetic();
  }

  @Override
  public void visitChildren(ElementVisitor<?> visitor) {
    getActualElement().visitChildren(visitor);
  }

  /**
   * Return the element being represented by this handle, reconstituting the element if the
   * reference has been set to {@code null}.
   * 
   * @return the element being represented by this handle
   */
  protected Element getActualElement() {
    Element element = elementReference.get();
    if (element == null) {
      element = context.getElement(location);
      elementReference = new WeakReference<Element>(element);
    }
    return element;
  }
}