/*
 * Copyright 2016-present Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * 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.facebook.buck.jvm.java.abi.source;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.NullType;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
import javax.lang.model.type.TypeVisitor;
import javax.lang.model.type.UnionType;
import javax.lang.model.type.WildcardType;

/**
 * An implementation of {@link TypeMirror} that is not dependent on any particular compiler
 * implementation. Subclasses may require {@link javax.lang.model.element.Element}s and/or {@link
 * javax.lang.model.type.TypeMirror}s, but do not depend on any particular implementation of them
 * (beyond the spec).
 */
abstract class StandaloneTypeMirror implements TypeMirror {
  private final TypeKind kind;
  private final List<? extends AnnotationMirror> annotations;

  protected StandaloneTypeMirror(TypeKind kind) {
    this(kind, Collections.emptyList());
  }

  protected StandaloneTypeMirror(TypeKind kind, List<? extends AnnotationMirror> annotations) {
    this.kind = kind;
    this.annotations = Collections.unmodifiableList(new ArrayList<>(annotations));
  }

  @Override
  public TypeKind getKind() {
    return kind;
  }

  @Override
  public <R, P> R accept(TypeVisitor<R, P> v, P p) {
    switch (kind) {
      case BOOLEAN:
      case BYTE:
      case SHORT:
      case INT:
      case LONG:
      case CHAR:
      case FLOAT:
      case DOUBLE:
        return v.visitPrimitive((PrimitiveType) this, p);
      case PACKAGE:
      case VOID:
      case NONE:
        return v.visitNoType((NoType) this, p);
      case NULL:
        return v.visitNull((NullType) this, p);
      case ARRAY:
        return v.visitArray((ArrayType) this, p);
      case DECLARED:
        return v.visitDeclared((DeclaredType) this, p);
      case ERROR:
        return v.visitError((ErrorType) this, p);
      case TYPEVAR:
        return v.visitTypeVariable((TypeVariable) this, p);
      case WILDCARD:
        return v.visitWildcard((WildcardType) this, p);
      case EXECUTABLE:
        return v.visitExecutable((ExecutableType) this, p);
      case OTHER:
        return v.visit(this, p);
      case UNION:
        return v.visitUnion((UnionType) this, p);
      case INTERSECTION:
        return v.visitIntersection((IntersectionType) this, p);
      default:
        throw new AssertionError(String.format("Unknown TypeKind: %s", kind));
    }
  }

  @Override
  public List<? extends AnnotationMirror> getAnnotationMirrors() {
    return this.annotations;
  }

  @Override
  public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
    // This one is really difficult to implement, and also generally a bad thing to use anyway
    throw new UnsupportedOperationException();
  }

  @Override
  public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
    // This one is really difficult to implement, and also generally a bad thing to use anyway
    throw new UnsupportedOperationException();
  }
}