// Copyright 2016 The Domain Registry Authors. All Rights Reserved.
//
// 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 google.registry.ui.forms;

import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import javax.annotation.CheckReturnValue;
import javax.annotation.Detainted;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;

/**
 * Exception thrown when a form field contains a bad value.
 *
 * <p>You can safely throw {@code FormFieldException} from within your validator functions, and
 * the field name will automatically be propagated into the exception object for you.
 *
 * <p>The way that field names work is a bit complicated, because we need to support complex nested
 * field names like {@code foo[3].bar}. So what happens is the original exception will be thrown by
 * a {@link FormField} validator without the field set. Then as the exception bubbles up the stack,
 * it'll be caught by the {@link FormField#convert(Object) convert} method, which then prepends the
 * name of that component. Then when the exception reaches the user, the {@link #getFieldName()}
 * method will produce the fully-qualified field name.
 *
 * <p>This propagation mechanism is also very important when writing
 * {@link FormField.Builder#transform(com.google.common.base.Function) transform} functions, which
 * oftentimes will not know the name of the field they're validating.
 */
@NotThreadSafe
public final class FormFieldException extends FormException {

  private final List<Object> names = new ArrayList<>();

  @Nullable
  private String lazyFieldName;

  /**
   * Creates a new {@link FormFieldException}
   *
   * <p>This exception should only be thrown from within a {@link FormField} converter function.
   * The field name will automatically be propagated into the exception object for you.
   *
   * @param userMessage should be a friendly message that's safe to show to the user.
   */
  public FormFieldException(@Detainted String userMessage) {
    super(checkNotNull(userMessage, "userMessage"), null);
  }

  /**
   * Creates a new {@link FormFieldException}
   *
   * <p>This exception should only be thrown from within a {@link FormField} converter function.
   * The field name will automatically be propagated into the exception object for you.
   *
   * @param userMessage should be a friendly message that's safe to show to the user.
   * @param cause the original cause of this exception (non-null).
   */
  public FormFieldException(@Detainted String userMessage, Throwable cause) {
    super(checkNotNull(userMessage, "userMessage"), checkNotNull(cause, "cause"));
  }

  /**
   * Creates a new {@link FormFieldException} for a particular form field.
   *
   * <p>This exception should only be thrown from within a {@link FormField} MAP converter function
   * in situations where you're performing additional manual validation.
   *
   * @param userMessage should be a friendly message that's safe to show to the user.
   */
  public FormFieldException(FormField<?, ?> field, @Detainted String userMessage) {
    this(field.name(), userMessage);
  }

  /**
   * Creates a new {@link FormFieldException} for a particular field name.
   *
   * @param field name corresponding to a {@link FormField#name()}
   * @param userMessage friendly message that's safe to show to the user
   */
  public FormFieldException(String field, @Detainted String userMessage) {
    super(checkNotNull(userMessage, "userMessage"), null);
    propagateImpl(field);
  }

  /** Returns the fully-qualified name (JavaScript syntax) of the form field causing this error. */
  public String getFieldName() {
    String fieldName = lazyFieldName;
    if (fieldName == null) {
      lazyFieldName = fieldName = getFieldNameImpl();
    }
    return fieldName;
  }

  private String getFieldNameImpl() {
    checkState(!names.isEmpty(),
        "FormFieldException was thrown outside FormField infrastructure!");
    Iterator<Object> namesIterator = Lists.reverse(names).iterator();
    StringBuilder result = new StringBuilder((String) namesIterator.next());
    while (namesIterator.hasNext()) {
      Object name = namesIterator.next();
      if (name instanceof String) {
        result.append('.').append(name);
      } else if (name instanceof Integer) {
        result.append('[').append(name).append(']');
      } else {
        throw new AssertionError();
      }
    }
    return result.toString();
  }

  /** Returns self with {@code name} prepended, for propagating exceptions up the stack. */
  @CheckReturnValue
  @VisibleForTesting
  public FormFieldException propagate(String name) {
    return propagateImpl(name);
  }

  /** Returns self with {@code index} prepended, for propagating exceptions up the stack. */
  @CheckReturnValue
  FormFieldException propagate(int index) {
    return propagateImpl(index);
  }

  /** Returns self with {@code name} prepended, for propagating exceptions up the stack. */
  private FormFieldException propagateImpl(Object name) {
    lazyFieldName = null;
    names.add(checkNotNull(name));
    return this;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return this == obj
        || obj instanceof FormFieldException
        && Objects.equals(getCause(), ((FormFieldException) obj).getCause())
        && Objects.equals(getMessage(), ((FormFieldException) obj).getMessage())
        && Objects.equals(names, ((FormFieldException) obj).names);
  }

  @Override
  public int hashCode() {
    return Objects.hash(getCause(), getMessage(), getFieldName());
  }

  @Override
  public String toString() {
    return toStringHelper(getClass())
        .add("fieldName", getFieldName())
        .add("message", getMessage())
        .add("cause", getCause())
        .toString();
  }
}