/*
 * Copyright (C) 2014 The Dagger Authors.
 *
 * 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 dagger.internal.codegen.binding;

import static dagger.internal.codegen.base.ElementFormatter.elementToString;
import static dagger.internal.codegen.base.RequestKinds.requestType;

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import dagger.Provides;
import dagger.internal.codegen.base.Formatter;
import dagger.internal.codegen.langmodel.DaggerTypes;
import dagger.model.DependencyRequest;
import dagger.producers.Produces;
import java.util.Optional;
import javax.inject.Inject;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementVisitor;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.ElementKindVisitor8;

/**
 * Formats a {@link DependencyRequest} into a {@link String} suitable for an error message listing a
 * chain of dependencies.
 *
 * <dl>
 *   <dt>For component provision methods
 *   <dd>{@code @Qualifier SomeType is provided at\n ComponentType.method()}
 *   <dt>For component injection methods
 *   <dd>{@code SomeType is injected at\n ComponentType.method(foo)}
 *   <dt>For parameters to {@link Provides @Provides}, {@link Produces @Produces}, or {@link
 *       Inject @Inject} methods:
 *   <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType.method([…, ]param[, …])}
 *   <dt>For parameters to {@link Inject @Inject} constructors:
 *   <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType([…, ]param[, …])}
 *   <dt>For {@link Inject @Inject} fields:
 *   <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType.field}
 * </dl>
 */
public final class DependencyRequestFormatter extends Formatter<DependencyRequest> {

  private final DaggerTypes types;

  @Inject
  DependencyRequestFormatter(DaggerTypes types) {
    this.types = types;
  }

  @Override
  public String format(DependencyRequest request) {
    return request
        .requestElement()
        .map(element -> element.accept(formatVisitor, request))
        .orElse("");
  }

  /**
   * Appends a newline and the formatted dependency request unless {@link
   * #format(DependencyRequest)} returns the empty string.
   */
  @CanIgnoreReturnValue
  public StringBuilder appendFormatLine(
      StringBuilder builder, DependencyRequest dependencyRequest) {
    String formatted = format(dependencyRequest);
    if (!formatted.isEmpty()) {
      builder.append('\n').append(formatted);
    }
    return builder;
  }

  private final ElementVisitor<String, DependencyRequest> formatVisitor =
      new ElementKindVisitor8<String, DependencyRequest>() {

        @Override
        public String visitExecutableAsMethod(ExecutableElement method, DependencyRequest request) {
          return INDENT
              + request.key()
              + " is "
              + componentMethodRequestVerb(request)
              + " at\n"
              + DOUBLE_INDENT
              + elementToString(method);
        }

        @Override
        public String visitVariable(VariableElement variable, DependencyRequest request) {
          TypeMirror requestedType = requestType(request.kind(), request.key().type(), types);
          return INDENT
              + formatQualifier(request.key().qualifier())
              + requestedType
              + " is injected at\n"
              + DOUBLE_INDENT
              + elementToString(variable);
        }

        @Override
        public String visitType(TypeElement e, DependencyRequest request) {
          return ""; // types by themselves provide no useful information.
        }

        @Override
        protected String defaultAction(Element element, DependencyRequest request) {
          throw new IllegalStateException(
              "Invalid request " + element.getKind() + " element " + element);
        }
      };

  private String formatQualifier(Optional<AnnotationMirror> maybeQualifier) {
    return maybeQualifier.map(qualifier -> qualifier + " ").orElse("");
  }

  /**
   * Returns the verb for a component method dependency request. Returns "produced", "provided", or
   * "injected", depending on the kind of request.
   */
  private String componentMethodRequestVerb(DependencyRequest request) {
    switch (request.kind()) {
      case FUTURE:
      case PRODUCER:
      case INSTANCE:
      case LAZY:
      case PROVIDER:
      case PROVIDER_OF_LAZY:
        return "requested";

      case MEMBERS_INJECTION:
        return "injected";

      case PRODUCED:
        break;
    }
    throw new AssertionError("illegal request kind for method: " + request);
  }
}