/**
 * Represents an error condition occurred during validation.
 */
@Beta
public class ValidationFailure {
  // types of the failures
  private static final String STAGE_ERROR = "StageError";
  private static final String INVALID_PROPERTY = "InvalidProperty";
  private static final String PLUGIN_NOT_FOUND = "PluginNotFound";
  private static final String INVALID_INPUT_SCHEMA = "InvalidInputSchema";
  private static final String INVALID_OUTPUT_SCHEMA = "InvalidOutputSchema";

  // represents stage name in the failure. It is a generic property used in all the failures for a given stage
  private static final String STAGE = "stage";

  // represents configuration property in InvalidProperty failure
  private static final String CONFIG_PROPERTY = "configProperty";

  // represents plugin id in PluginNotFound failure
  private static final String PLUGIN_ID = "pluginId";
  // represents plugin type in PluginNotFound failure
  private static final String PLUGIN_TYPE = "pluginType";
  // represents plugin name in PluginNotFound failure
  private static final String PLUGIN_NAME = "pluginName";

  // represents a field in InvalidInputSchema or InvalidOutputSchema failure
  private static final String FIELD = "field";
  // represents input stage in InvalidInputSchema failure
  private static final String INPUT_STAGE = "inputStage";
  // represents output port in InvalidOutputSchema failure
  private static final String OUTPUT_PORT = "outputPort";

  private final String message;
  private final String type;
  private final String correctiveAction;
  private final Map<String, Object> properties;

  private ValidationFailure(String message, String type, @Nullable String correctiveAction,
                            Map<String, Object> properties) {
    this.message = message;
    this.type = type;
    this.correctiveAction = correctiveAction;
    this.properties = properties;
  }

  /**
   * Creates a stage validation failure.
   *
   * @param message validation failure message
   * @param stage stage name
   * @param correctiveAction corrective action
   */
  public static ValidationFailure createStageFailure(String message, String stage, @Nullable String correctiveAction) {
    Builder builder = builder(message, STAGE_ERROR);
    builder.setCorrectiveAction(correctiveAction).addProperty(STAGE, stage);
    return builder.build();
  }

  /**
   * Creates a config property validation failure.
   *
   * @param message validation failure message
   * @param stage stage name
   * @param correctiveAction corrective action
   */
  public static ValidationFailure createConfigPropertyFailure(String message, String stage,
                                                              String property, @Nullable String correctiveAction) {
    Builder builder = builder(message, INVALID_PROPERTY);
    builder.setCorrectiveAction(correctiveAction)
      .addProperty(STAGE, stage).addProperty(CONFIG_PROPERTY, property);
    return builder.build();
  }

  /**
   * Creates a plugin not found validation failure.
   *
   * @param message validation failure message
   * @param stage stage name
   * @param correctiveAction corrective action
   */
  public static ValidationFailure createPluginNotFoundFailure(String message, String stage,
                                                              String pluginId, String pluginName, String pluginType,
                                                              @Nullable String correctiveAction) {
    Builder builder = builder(message, PLUGIN_NOT_FOUND);
    builder.setCorrectiveAction(correctiveAction)
      .addProperty(STAGE, stage).addProperty(PLUGIN_ID, pluginId)
      .addProperty(PLUGIN_TYPE, pluginType)
      .addProperty(PLUGIN_NAME, pluginName);
    return builder.build();
  }

  /**
   * Creates a invalid input schema failure.
   *
   * @param message validation failure message
   * @param stage stage name
   * @param field input schema field
   * @param inputStage optional input stagename. This is applicable to plugins of type {@link Joiner}.
   * @param correctiveAction optional corrective action
   * @return invalid input schema validation failure
   */
  public static ValidationFailure createInputSchemaFailure(String message, String stage, String field,
                                                           @Nullable String inputStage,
                                                           @Nullable String correctiveAction) {
    ...
  }

  /**
   * Creates a invalid output schema failure.
   *
   * @param message validation failure message
   * @param stage stage name
   * @param field output schema field
   * @param outputPort optional output port. This is applicable to plugins of type {@link SplitterTransform}.
   * @param correctiveAction optional corrective action
   * @return invalid output schema validation failure
   */
  public static ValidationFailure createOutputSchemaFailure(String message, String stage, String field,
                                                            @Nullable String outputPort,
                                                            @Nullable String correctiveAction) {
   ....
  }

  /**
   * Returns a builder for creating a {@link ValidationFailure}.
   */
  public static Builder builder(String message, String type) {
    return new Builder(message, type);
  }

  /**
   * A builder to create {@link ValidationFailure} instance.
   */
  public static class Builder {
    private final String message;
    private final String type;
    private final String correctiveAction;
    private final Map<String, Object> properties;

  ValidationFailure(String message, String type, String correctiveAction, Map<String, Object> mapprivate Builder(String message, String type) {
      this.message = message;
      this.type = type;
      this.correctiveActionproperties = new correctiveActionHashMap<>();
    }

this.properties = map;    /**
    } * Sets corrective publicaction staticto ValidationFailure.Builder builder(String message, String type, String correctiveAction) {
rectify the failure.
     *
   return new ValidationFailure.Builder(message, type, correctiveAction);
  } * @param correctiveAction corrective action
     public* static@return classthis Builderbuilder
{     private*/
final String message;  public Builder setCorrectiveAction(String privatecorrectiveAction) final{
String type;     this.correctiveAction = correctiveAction;
    private final Map<String, Object> propertiesreturn this;
    }
private
Builder(String message, String type, String/**
correctiveAction) {    * Adds a this.messageproperty =to message;the failure.
     this.type*
= type;    * @param property this.correctiveActionthe =name correctiveAction;of the property
    this.properties =* new HashMap<>();
    }

@param value the value of the property
   // methods to* get@return variousthis typesbuilder
of properties such as string, schema.. */
    public ValidationFailure.Builder addProperty(String property, String value) {
      this.properties.put(property, value);
      return this;
    }

    ..../**
    public ValidationFailure* build()Creates {a new instance of {@link ValidationFailure}.
 return new ValidationFailure(message, type, correctiveAction,*
properties);     }* @return instance }
}

/**
 * Represents Validation Exception.of {@link ValidationFailure}
     */
 @Beta public class ValidationExceptionpublic extendsValidationFailure RuntimeExceptionbuild() {
  private List<ValidationFailure> failures;  return new private ValidationException(List<ValidationFailure> failures) {ValidationFailure(message, type, correctiveAction,
    super();     this.failures = failures;   }      @Override   public String getMessage() {     ...   } Collections.unmodifiableMap(new HashMap<>(properties)));
 /**   }
* Returns list of}
failures.
   */
  public List<ValidationFailure> getFailures() {
    return failures;
  }
/**
   * Returns message of this failure.
   */
  public static ValidationException.Builder builderString getMessage() {
    return new ValidationException.Builder()message;
  }

  /**
   * BuilderReturns totype buildof validationthis exceptionfailure.
   */
  public static class BuilderString getType() {
    private final List<ValidationFailure> failuresreturn type;
  }

 private Builder() { /**
       this.failures = new ArrayList<>();
    }

    public ValidationException.Builder addFailure(ValidationFailure failure) {
      failures.add(failure);
 * Returns corrective action for this failure.
   */
  @Nullable
  public String getCorrectiveAction() {
    return thiscorrectiveAction;
 
  }

    /**
     * UtilReturns methodproperties toof createthis andfailure.
add stage validation failure*/
to this exception.public Map<String, Object> getProperties() {
 *   return properties;
 * @param}
message
validation failure message@Override
  public boolean equals(Object *o) @param{
stage stage name   if (this == *o) @param{
correctiveAction suggested action    return true;
*/    }
public ValidationException.Builder addStageValidationFailure(String message, Stringif stage,(o == null || getClass() != o.getClass()) {
      return false;
    }
    ValidationFailure that = (ValidationFailure) o;
    return message.equals(that.message) && type.equals(that.type) &&
      Objects.equals(correctiveAction, that.correctiveAction) &&
      properties.equals(that.properties);
  }

  @Override
  public  @Nullable String correctiveActionint hashCode() {
    return  ValidationFailure.Builder builder = ValidationFailure.builderObjects.hash(message, "INVALID_STAGE"type, correctiveAction, properties);
  }

  builder.addProperty("stage", stage);@Override
  public     failures.add(builder.build());
 String toString() {
    return this;
    }
  
 "ValidationFailure{" +
  // util methods for other validation failures
    ..."message='" + message + '\'' +
       /**
     * Build and throw validation exception. This method can be used by plugins to throw an exception at any point
     * during validation. The method will build and throw ValidationException if there are any failures added while
     * building the exception
     *
     * @return Validation exception
     */
    public void throwIfAbsent() {
      if (failures.isEmpty()) {
        return;
      }
      throw new ValidationException(failures);
    }", type='" + type + '\'' +
      ", correctiveAction='" + correctiveAction + '\'' +
      ", properties=" + properties +
      '}';
  }
}

/**
 * Validation exception that carries multiple validation failures.
 */
@Beta
public class ValidationException extends RuntimeException {
  private List<ValidationFailure> failures;

  public ValidationException(List<ValidationFailure> failures) {
    super(failures.isEmpty() ? "Validation Exception occurred." : failures.iterator().next().getMessage());
    this.failures = failures;
  }

  /**
   * Returns list of failures.
   */
  public List<ValidationFailure> getFailures() {
    return failures;
  }
}