package com.<organisation>.entities;

import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.base.MoreObjects;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.Var;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;
import javax.annotation.concurrent.Immutable;
import javax.annotation.concurrent.NotThreadSafe;
import org.immutables.value.Generated;

/**
 * Immutable implementation of {@link Contact}.
 * <p>
 * Use the builder to create immutable instances:
 * {@code ImmutableContact.builder()}.
 */
@Generated(from = "Contact", generator = "Immutables")
@SuppressWarnings({"all"})
@ParametersAreNonnullByDefault
@javax.annotation.processing.Generated("org.immutables.processor.ProxyProcessor")
@Immutable
@CheckReturnValue
public final class ImmutableContact implements Contact {
  private final @Nullable String name;
  private final @Nullable String phoneNumber;
  private final @Nullable String address;
  private final @Nullable String email;

  private ImmutableContact(
      @Nullable String name,
      @Nullable String phoneNumber,
      @Nullable String address,
      @Nullable String email) {
    this.name = name;
    this.phoneNumber = phoneNumber;
    this.address = address;
    this.email = email;
  }

  /**
   * @return The value of the {@code name} attribute
   */
  @JsonProperty("name")
  @Override
  public Optional<String> name() {
    return Optional.ofNullable(name);
  }

  /**
   * @return The value of the {@code phoneNumber} attribute
   */
  @JsonProperty("phoneNumber")
  @Override
  public Optional<String> phoneNumber() {
    return Optional.ofNullable(phoneNumber);
  }

  /**
   * @return The value of the {@code address} attribute
   */
  @JsonProperty("address")
  @Override
  public Optional<String> address() {
    return Optional.ofNullable(address);
  }

  /**
   * @return The value of the {@code email} attribute
   */
  @JsonProperty("email")
  @Override
  public Optional<String> email() {
    return Optional.ofNullable(email);
  }

  /**
   * Copy the current immutable object by setting a <i>present</i> value for the optional {@link Contact#name() name} attribute.
   * @param value The value for name
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withName(String value) {
    @Nullable String newValue = Objects.requireNonNull(value, "name");
    if (Objects.equals(this.name, newValue)) return this;
    return new ImmutableContact(newValue, this.phoneNumber, this.address, this.email);
  }

  /**
   * Copy the current immutable object by setting an optional value for the {@link Contact#name() name} attribute.
   * An equality check is used on inner nullable value to prevent copying of the same value by returning {@code this}.
   * @param optional A value for name
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withName(Optional<String> optional) {
    @Nullable String value = optional.orElse(null);
    if (Objects.equals(this.name, value)) return this;
    return new ImmutableContact(value, this.phoneNumber, this.address, this.email);
  }

  /**
   * Copy the current immutable object by setting a <i>present</i> value for the optional {@link Contact#phoneNumber() phoneNumber} attribute.
   * @param value The value for phoneNumber
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withPhoneNumber(String value) {
    @Nullable String newValue = Objects.requireNonNull(value, "phoneNumber");
    if (Objects.equals(this.phoneNumber, newValue)) return this;
    return new ImmutableContact(this.name, newValue, this.address, this.email);
  }

  /**
   * Copy the current immutable object by setting an optional value for the {@link Contact#phoneNumber() phoneNumber} attribute.
   * An equality check is used on inner nullable value to prevent copying of the same value by returning {@code this}.
   * @param optional A value for phoneNumber
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withPhoneNumber(Optional<String> optional) {
    @Nullable String value = optional.orElse(null);
    if (Objects.equals(this.phoneNumber, value)) return this;
    return new ImmutableContact(this.name, value, this.address, this.email);
  }

  /**
   * Copy the current immutable object by setting a <i>present</i> value for the optional {@link Contact#address() address} attribute.
   * @param value The value for address
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withAddress(String value) {
    @Nullable String newValue = Objects.requireNonNull(value, "address");
    if (Objects.equals(this.address, newValue)) return this;
    return new ImmutableContact(this.name, this.phoneNumber, newValue, this.email);
  }

  /**
   * Copy the current immutable object by setting an optional value for the {@link Contact#address() address} attribute.
   * An equality check is used on inner nullable value to prevent copying of the same value by returning {@code this}.
   * @param optional A value for address
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withAddress(Optional<String> optional) {
    @Nullable String value = optional.orElse(null);
    if (Objects.equals(this.address, value)) return this;
    return new ImmutableContact(this.name, this.phoneNumber, value, this.email);
  }

  /**
   * Copy the current immutable object by setting a <i>present</i> value for the optional {@link Contact#email() email} attribute.
   * @param value The value for email
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withEmail(String value) {
    @Nullable String newValue = Objects.requireNonNull(value, "email");
    if (Objects.equals(this.email, newValue)) return this;
    return new ImmutableContact(this.name, this.phoneNumber, this.address, newValue);
  }

  /**
   * Copy the current immutable object by setting an optional value for the {@link Contact#email() email} attribute.
   * An equality check is used on inner nullable value to prevent copying of the same value by returning {@code this}.
   * @param optional A value for email
   * @return A modified copy of {@code this} object
   */
  public final ImmutableContact withEmail(Optional<String> optional) {
    @Nullable String value = optional.orElse(null);
    if (Objects.equals(this.email, value)) return this;
    return new ImmutableContact(this.name, this.phoneNumber, this.address, value);
  }

  /**
   * This instance is equal to all instances of {@code ImmutableContact} that have equal attribute values.
   * @return {@code true} if {@code this} is equal to {@code another} instance
   */
  @Override
  public boolean equals(@Nullable Object another) {
    if (this == another) return true;
    return another instanceof ImmutableContact
        && equalTo((ImmutableContact) another);
  }

  private boolean equalTo(ImmutableContact another) {
    return Objects.equals(name, another.name)
        && Objects.equals(phoneNumber, another.phoneNumber)
        && Objects.equals(address, another.address)
        && Objects.equals(email, another.email);
  }

  /**
   * Computes a hash code from attributes: {@code name}, {@code phoneNumber}, {@code address}, {@code email}.
   * @return hashCode value
   */
  @Override
  public int hashCode() {
    @Var int h = 5381;
    h += (h << 5) + Objects.hashCode(name);
    h += (h << 5) + Objects.hashCode(phoneNumber);
    h += (h << 5) + Objects.hashCode(address);
    h += (h << 5) + Objects.hashCode(email);
    return h;
  }

  /**
   * Prints the immutable value {@code Contact} with attribute values.
   * @return A string representation of the value
   */
  @Override
  public String toString() {
    return MoreObjects.toStringHelper("Contact")
        .omitNullValues()
        .add("name", name)
        .add("phoneNumber", phoneNumber)
        .add("address", address)
        .add("email", email)
        .toString();
  }

  /**
   * Creates an immutable copy of a {@link Contact} value.
   * Uses accessors to get values to initialize the new immutable instance.
   * If an instance is already immutable, it is returned as is.
   * @param instance The instance to copy
   * @return A copied immutable Contact instance
   */
  public static ImmutableContact copyOf(Contact instance) {
    if (instance instanceof ImmutableContact) {
      return (ImmutableContact) instance;
    }
    return ImmutableContact.builder()
        .from(instance)
        .build();
  }

  /**
   * Creates a builder for {@link ImmutableContact ImmutableContact}.
   * @return A new ImmutableContact builder
   */
  public static ImmutableContact.Builder builder() {
    return new ImmutableContact.Builder();
  }

  /**
   * Builds instances of type {@link ImmutableContact ImmutableContact}.
   * Initialize attributes and then invoke the {@link #build()} method to create an
   * immutable instance.
   * <p><em>{@code Builder} is not thread-safe and generally should not be stored in a field or collection,
   * but instead used immediately to create instances.</em>
   */
  @Generated(from = "Contact", generator = "Immutables")
  @NotThreadSafe
  public static final class Builder {
    private @Nullable String name;
    private @Nullable String phoneNumber;
    private @Nullable String address;
    private @Nullable String email;

    private Builder() {
    }

    /**
     * Fill a builder with attribute values from the provided {@code Contact} instance.
     * Regular attribute values will be replaced with those from the given instance.
     * Absent optional values will not replace present values.
     * @param instance The instance from which to copy values
     * @return {@code this} builder for use in a chained invocation
     */
    @CanIgnoreReturnValue 
    public final Builder from(Contact instance) {
      Objects.requireNonNull(instance, "instance");
      Optional<String> nameOptional = instance.name();
      if (nameOptional.isPresent()) {
        name(nameOptional);
      }
      Optional<String> phoneNumberOptional = instance.phoneNumber();
      if (phoneNumberOptional.isPresent()) {
        phoneNumber(phoneNumberOptional);
      }
      Optional<String> addressOptional = instance.address();
      if (addressOptional.isPresent()) {
        address(addressOptional);
      }
      Optional<String> emailOptional = instance.email();
      if (emailOptional.isPresent()) {
        email(emailOptional);
      }
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#name() name} to name.
     * @param name The value for name
     * @return {@code this} builder for chained invocation
     */
    @CanIgnoreReturnValue 
    public final Builder name(String name) {
      this.name = Objects.requireNonNull(name, "name");
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#name() name} to name.
     * @param name The value for name
     * @return {@code this} builder for use in a chained invocation
     */
    @CanIgnoreReturnValue 
    @JsonProperty("name")
    public final Builder name(Optional<String> name) {
      this.name = name.orElse(null);
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#phoneNumber() phoneNumber} to phoneNumber.
     * @param phoneNumber The value for phoneNumber
     * @return {@code this} builder for chained invocation
     */
    @CanIgnoreReturnValue 
    public final Builder phoneNumber(String phoneNumber) {
      this.phoneNumber = Objects.requireNonNull(phoneNumber, "phoneNumber");
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#phoneNumber() phoneNumber} to phoneNumber.
     * @param phoneNumber The value for phoneNumber
     * @return {@code this} builder for use in a chained invocation
     */
    @CanIgnoreReturnValue 
    @JsonProperty("phoneNumber")
    public final Builder phoneNumber(Optional<String> phoneNumber) {
      this.phoneNumber = phoneNumber.orElse(null);
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#address() address} to address.
     * @param address The value for address
     * @return {@code this} builder for chained invocation
     */
    @CanIgnoreReturnValue 
    public final Builder address(String address) {
      this.address = Objects.requireNonNull(address, "address");
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#address() address} to address.
     * @param address The value for address
     * @return {@code this} builder for use in a chained invocation
     */
    @CanIgnoreReturnValue 
    @JsonProperty("address")
    public final Builder address(Optional<String> address) {
      this.address = address.orElse(null);
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#email() email} to email.
     * @param email The value for email
     * @return {@code this} builder for chained invocation
     */
    @CanIgnoreReturnValue 
    public final Builder email(String email) {
      this.email = Objects.requireNonNull(email, "email");
      return this;
    }

    /**
     * Initializes the optional value {@link Contact#email() email} to email.
     * @param email The value for email
     * @return {@code this} builder for use in a chained invocation
     */
    @CanIgnoreReturnValue 
    @JsonProperty("email")
    public final Builder email(Optional<String> email) {
      this.email = email.orElse(null);
      return this;
    }

    /**
     * Builds a new {@link ImmutableContact ImmutableContact}.
     * @return An immutable instance of Contact
     * @throws java.lang.IllegalStateException if any required attributes are missing
     */
    public ImmutableContact build() {
      return new ImmutableContact(name, phoneNumber, address, email);
    }
  }
}