package com.box.sdk;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
import java.net.URL;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * Represents a retention policy. A retention policy blocks permanent deletion of content for a
 * specified amount of time. Admins can create retention policies and then later assign them to
 * specific folders or their entire enterprise.
 *
 * @see <a href="https://developer.box.com/reference/resources/retention-policy/">Box retention
 *     policy</a>
 *     <p>Unless otherwise noted, the methods in this class can throw an unchecked {@link
 *     BoxAPIException} (unchecked meaning that the compiler won't force you to handle it) if an
 *     error occurs. If you wish to implement custom error handling for errors related to the Box
 *     REST API, you should capture this exception explicitly.
 */
@BoxResourceType("retention_policy")
public class BoxRetentionPolicy extends BoxResource {
  /** The URL template used for operation with retention policies. */
  public static final URLTemplate RETENTION_POLICIES_URL_TEMPLATE =
      new URLTemplate("retention_policies");

  /** The URL template used for operation with retention policy with given ID. */
  public static final URLTemplate POLICY_URL_TEMPLATE = new URLTemplate("retention_policies/%s");

  /** The URL template used for operation with retention policy assignments. */
  public static final URLTemplate ASSIGNMENTS_URL_TEMPLATE =
      new URLTemplate("retention_policies/%s/assignments");

  /** Will cause the content retained by the policy to be permanently deleted. */
  public static final String ACTION_PERMANENTLY_DELETE = "permanently_delete";

  /** Will lift the retention policy from the content, allowing it to be deleted by users. */
  public static final String ACTION_REMOVE_RETENTION = "remove_retention";

  /** Status corresponding to active retention policy. */
  public static final String STATUS_ACTIVE = "active";

  /** Status corresponding to retired retention policy. */
  public static final String STATUS_RETIRED = "retired";

  /** The default limit of entries per response. */
  private static final int DEFAULT_LIMIT = 100;

  /**
   * Constructs a retention policy for a resource with a given ID.
   *
   * @param api the API connection to be used by the resource.
   * @param id the ID of the resource.
   */
  public BoxRetentionPolicy(BoxAPIConnection api, String id) {
    super(api, id);
  }

  /**
   * Used to create a new indefinite retention policy.
   *
   * @param api the API connection to be used by the created user.
   * @param name the name of the retention policy.
   * @return the created retention policy's info.
   */
  public static BoxRetentionPolicy.Info createIndefinitePolicy(BoxAPIConnection api, String name) {
    return createRetentionPolicy(
        api, name, BoxRetentionPolicyType.Indefinite, 0, BoxRetentionPolicyAction.RemoveRetention);
  }

  /**
   * Used to create a new indefinite retention policy with optional parameters.
   *
   * @param api the API connection to be used by the created user.
   * @param name the name of the retention policy.
   * @param optionalParams the optional parameters.
   * @return the created retention policy's info.
   */
  public static BoxRetentionPolicy.Info createIndefinitePolicy(
      BoxAPIConnection api, String name, RetentionPolicyParams optionalParams) {
    return createRetentionPolicy(
        api,
        name,
        BoxRetentionPolicyType.Indefinite,
        0,
        BoxRetentionPolicyAction.RemoveRetention,
        optionalParams);
  }

  /**
   * Used to create a new finite retention policy.
   *
   * @param api the API connection to be used by the created user.
   * @param name the name of the retention policy.
   * @param length the duration in days that the retention policy will be active for after being
   *     assigned to content.
   * @param action the disposition action can be "permanently_delete" or "remove_retention".
   * @return the created retention policy's info.
   */
  public static BoxRetentionPolicy.Info createFinitePolicy(
      BoxAPIConnection api, String name, int length, BoxRetentionPolicyAction action) {
    return createRetentionPolicy(api, name, BoxRetentionPolicyType.Finite, length, action);
  }

  /**
   * Used to create a new finite retention policy with optional parameters.
   *
   * @param api the API connection to be used by the created user.
   * @param name the name of the retention policy.
   * @param length the duration in days that the retention policy will be active for after being
   *     assigned to content.
   * @param action the disposition action can be "permanently_delete" or "remove_retention".
   * @param optionalParams the optional parameters.
   * @return the created retention policy's info.
   */
  public static BoxRetentionPolicy.Info createFinitePolicy(
      BoxAPIConnection api,
      String name,
      int length,
      BoxRetentionPolicyAction action,
      RetentionPolicyParams optionalParams) {
    return createRetentionPolicy(
        api, name, BoxRetentionPolicyType.Finite, length, action, optionalParams);
  }

  /**
   * Used to create a new retention policy.
   *
   * @param api the API connection to be used by the created user.
   * @param name the name of the retention policy.
   * @param type the type of the retention policy. Can be "finite" or "indefinite".
   * @param length the duration in days that the retention policy will be active for after being
   *     assigned to content.
   * @param action the disposition action can be "permanently_delete" or "remove_retention".
   * @return the created retention policy's info.
   */
  private static BoxRetentionPolicy.Info createRetentionPolicy(
      BoxAPIConnection api,
      String name,
      BoxRetentionPolicyType type,
      int length,
      BoxRetentionPolicyAction action) {
    return createRetentionPolicy(api, name, type, length, action, null);
  }

  /**
   * Used to create a new retention policy with optional parameters.
   *
   * @param api the API connection to be used by the created user.
   * @param name the name of the retention policy.
   * @param type the type of the retention policy. Can be "finite" or "indefinite".
   * @param length the duration in days that the retention policy will be active for after being
   *     assigned to content.
   * @param action the disposition action can be "permanently_delete" or "remove_retention".
   * @param optionalParams the optional parameters.
   * @return the created retention policy's info.
   */
  private static BoxRetentionPolicy.Info createRetentionPolicy(
      BoxAPIConnection api,
      String name,
      BoxRetentionPolicyType type,
      int length,
      BoxRetentionPolicyAction action,
      RetentionPolicyParams optionalParams) {
    URL url = RETENTION_POLICIES_URL_TEMPLATE.build(api.getBaseURL());
    BoxJSONRequest request = new BoxJSONRequest(api, url, "POST");
    JsonObject requestJSON =
        new JsonObject()
            .add("policy_name", name)
            .add("policy_type", type.value)
            .add("disposition_action", action.value);
    if (type != BoxRetentionPolicyType.Indefinite) {
      requestJSON.add("retention_length", length);
    }
    if (optionalParams != null) {
      requestJSON.add("can_owner_extend_retention", optionalParams.getCanOwnerExtendRetention());
      requestJSON.add("are_owners_notified", optionalParams.getAreOwnersNotified());
      requestJSON.add("description", optionalParams.getDescription());
      requestJSON.add("retention_type", optionalParams.getRetentionType().toJSONString());

      List<BoxUser.Info> customNotificationRecipients =
          optionalParams.getCustomNotificationRecipients();
      if (customNotificationRecipients.size() > 0) {
        JsonArray users = new JsonArray();
        for (BoxUser.Info user : customNotificationRecipients) {
          JsonObject userJSON = new JsonObject().add("type", "user").add("id", user.getID());
          users.add(userJSON);
        }
        requestJSON.add("custom_notification_recipients", users);
      }
    }
    request.setBody(requestJSON.toString());
    try (BoxJSONResponse response = request.send()) {
      JsonObject responseJSON = Json.parse(response.getJSON()).asObject();
      BoxRetentionPolicy createdPolicy =
          new BoxRetentionPolicy(api, responseJSON.get("id").asString());
      return createdPolicy.new Info(responseJSON);
    }
  }

  /**
   * Returns all the retention policies.
   *
   * @param api the API connection to be used by the resource.
   * @param fields the fields to retrieve.
   * @return an iterable with all the retention policies.
   */
  public static Iterable<BoxRetentionPolicy.Info> getAll(
      final BoxAPIConnection api, String... fields) {
    return getAll(null, null, null, DEFAULT_LIMIT, api, fields);
  }

  /**
   * Returns all the retention policies with specified filters.
   *
   * @param name a name to filter the retention policies by. A trailing partial match search is
   *     performed. Set to null if no name filtering is required.
   * @param type a policy type to filter the retention policies by. Set to null if no type filtering
   *     is required.
   * @param userID a user id to filter the retention policies by. Set to null if no type filtering
   *     is required.
   * @param limit the limit of items per single response. The default value is 100.
   * @param api the API connection to be used by the resource.
   * @param fields the fields to retrieve.
   * @return an iterable with all the retention policies met search conditions.
   */
  public static Iterable<BoxRetentionPolicy.Info> getAll(
      String name,
      String type,
      String userID,
      int limit,
      final BoxAPIConnection api,
      String... fields) {
    QueryStringBuilder queryString = new QueryStringBuilder();
    if (name != null) {
      queryString.appendParam("policy_name", name);
    }
    if (type != null) {
      queryString.appendParam("policy_type", type);
    }
    if (userID != null) {
      queryString.appendParam("created_by_user_id", userID);
    }
    if (fields.length > 0) {
      queryString.appendParam("fields", fields);
    }
    URL url =
        RETENTION_POLICIES_URL_TEMPLATE.buildWithQuery(api.getBaseURL(), queryString.toString());
    return new BoxResourceIterable<BoxRetentionPolicy.Info>(api, url, limit) {

      @Override
      protected BoxRetentionPolicy.Info factory(JsonObject jsonObject) {
        BoxRetentionPolicy policy = new BoxRetentionPolicy(api, jsonObject.get("id").asString());
        return policy.new Info(jsonObject);
      }
    };
  }

  /**
   * Returns iterable with all folder assignments of this retention policy.
   *
   * @param fields the fields to retrieve.
   * @return an iterable containing all folder assignments.
   */
  public Iterable<BoxRetentionPolicyAssignment.Info> getFolderAssignments(String... fields) {
    return this.getFolderAssignments(DEFAULT_LIMIT, fields);
  }

  /**
   * Returns iterable with all folder assignments of this retention policy.
   *
   * @param limit the limit of entries per response. The default value is 100.
   * @param fields the fields to retrieve.
   * @return an iterable containing all folder assignments.
   */
  public Iterable<BoxRetentionPolicyAssignment.Info> getFolderAssignments(
      int limit, String... fields) {
    return this.getAssignments(BoxRetentionPolicyAssignment.TYPE_FOLDER, limit, fields);
  }

  /**
   * Returns iterable with all enterprise assignments of this retention policy.
   *
   * @param fields the fields to retrieve.
   * @return an iterable containing all enterprise assignments.
   */
  public Iterable<BoxRetentionPolicyAssignment.Info> getEnterpriseAssignments(String... fields) {
    return this.getEnterpriseAssignments(DEFAULT_LIMIT, fields);
  }

  /**
   * Returns iterable with all enterprise assignments of this retention policy.
   *
   * @param limit the limit of entries per response. The default value is 100.
   * @param fields the fields to retrieve.
   * @return an iterable containing all enterprise assignments.
   */
  public Iterable<BoxRetentionPolicyAssignment.Info> getEnterpriseAssignments(
      int limit, String... fields) {
    return this.getAssignments(BoxRetentionPolicyAssignment.TYPE_ENTERPRISE, limit, fields);
  }

  /**
   * Returns iterable with all assignments of this retention policy.
   *
   * @param fields the fields to retrieve.
   * @return an iterable containing all assignments.
   */
  public Iterable<BoxRetentionPolicyAssignment.Info> getAllAssignments(String... fields) {
    return this.getAllAssignments(DEFAULT_LIMIT, fields);
  }

  /**
   * Returns iterable with all assignments of this retention policy.
   *
   * @param limit the limit of entries per response. The default value is 100.
   * @param fields the fields to retrieve.
   * @return an iterable containing all assignments.
   */
  public Iterable<BoxRetentionPolicyAssignment.Info> getAllAssignments(
      int limit, String... fields) {
    return this.getAssignments(null, limit, fields);
  }

  /**
   * Returns iterable with all assignments of given type of this retention policy.
   *
   * @param type the type of the retention policy assignment to retrieve. Can either be "folder" or
   *     "enterprise".
   * @param limit the limit of entries per response. The default value is 100.
   * @param fields the fields to retrieve.
   * @return an iterable containing all assignments of given type.
   */
  private Iterable<BoxRetentionPolicyAssignment.Info> getAssignments(
      String type, int limit, String... fields) {
    QueryStringBuilder queryString = new QueryStringBuilder();
    if (type != null) {
      queryString.appendParam("type", type);
    }
    if (fields.length > 0) {
      queryString.appendParam("fields", fields);
    }
    URL url =
        ASSIGNMENTS_URL_TEMPLATE.buildWithQuery(
            getAPI().getBaseURL(), queryString.toString(), getID());
    return new BoxResourceIterable<BoxRetentionPolicyAssignment.Info>(getAPI(), url, limit) {

      @Override
      protected BoxRetentionPolicyAssignment.Info factory(JsonObject jsonObject) {
        BoxRetentionPolicyAssignment assignment =
            new BoxRetentionPolicyAssignment(getAPI(), jsonObject.get("id").asString());
        return assignment.new Info(jsonObject);
      }
    };
  }

  /**
   * Assigns this retention policy to folder.
   *
   * @param folder the folder to assign policy to.
   * @return info about created assignment.
   */
  public BoxRetentionPolicyAssignment.Info assignTo(BoxFolder folder) {
    return BoxRetentionPolicyAssignment.createAssignmentToFolder(
        this.getAPI(), this.getID(), folder.getID());
  }

  /**
   * Assigns this retention policy to the current enterprise.
   *
   * @return info about created assignment.
   */
  public BoxRetentionPolicyAssignment.Info assignToEnterprise() {
    return BoxRetentionPolicyAssignment.createAssignmentToEnterprise(this.getAPI(), this.getID());
  }

  /**
   * Assigns this retention policy to a metadata template, optionally with certain field values.
   *
   * @param templateID the ID of the metadata template to apply to.
   * @param fieldFilters optional field value filters.
   * @return info about the created assignment.
   */
  public BoxRetentionPolicyAssignment.Info assignToMetadataTemplate(
      String templateID, MetadataFieldFilter... fieldFilters) {
    return assignToMetadataTemplate(templateID, null, fieldFilters);
  }

  /**
   * Assigns this retention policy to a metadata template, optionally with certain field values.
   *
   * @param templateID the ID of the metadata template to apply to.
   * @param startDateField the date the retention policy assignment begins. This field can be a date
   *     field's metadata attribute key id.
   * @param fieldFilters optional field value filters.
   * @return info about the created assignment.
   */
  public BoxRetentionPolicyAssignment.Info assignToMetadataTemplate(
      String templateID, String startDateField, MetadataFieldFilter... fieldFilters) {
    return BoxRetentionPolicyAssignment.createAssignmentToMetadata(
        this.getAPI(), this.getID(), templateID, startDateField, fieldFilters);
  }

  /**
   * Updates the information about this retention policy with any info fields that have been
   * modified locally.
   *
   * @param info the updated info.
   */
  public void updateInfo(BoxRetentionPolicy.Info info) {
    URL url = POLICY_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID());
    BoxJSONRequest request = new BoxJSONRequest(this.getAPI(), url, "PUT");
    request.setBody(info.getPendingChanges());
    try (BoxJSONResponse response = request.send()) {
      JsonObject responseJSON = Json.parse(response.getJSON()).asObject();
      info.update(responseJSON);
    }
  }

  /**
   * Returns information about this retention policy.
   *
   * @param fields the fields to retrieve.
   * @return information about this retention policy.
   */
  public BoxRetentionPolicy.Info getInfo(String... fields) {
    QueryStringBuilder builder = new QueryStringBuilder();
    if (fields.length > 0) {
      builder.appendParam("fields", fields);
    }
    URL url =
        POLICY_URL_TEMPLATE.buildWithQuery(
            this.getAPI().getBaseURL(), builder.toString(), this.getID());
    BoxJSONRequest request = new BoxJSONRequest(this.getAPI(), url, "GET");
    try (BoxJSONResponse response = request.send()) {
      JsonObject responseJSON = Json.parse(response.getJSON()).asObject();
      return new Info(responseJSON);
    }
  }

  /** Contains information about the retention policy. */
  public class Info extends BoxResource.Info {

    /** @see #getPolicyName() */
    private String policyName;

    /** @see #getPolicyType() */
    private String policyType;

    /** @see #getRetentionLength() */
    private int retentionLength;

    /** @see #getDispositionAction() */
    private String dispositionAction;

    /** @see #getStatus() */
    private String status;

    /** @see #getCreatedBy() */
    private BoxUser.Info createdBy;

    /** @see #getCreatedAt() */
    private Date createdAt;

    /** @see #getModifiedAt() */
    private Date modifiedAt;

    /** @see #getCanOwnerExtendRetention() */
    private boolean canOwnerExtendRetention;

    /** @see #getAreOwnersNotified() */
    private boolean areOwnersNotified;

    /** @see #getDescription() */
    private String description;

    /** @see #getRetentionType() */
    private RetentionPolicyParams.RetentionType retentionType;

    private List<BoxUser.Info> customNotificationRecipients;

    /** Constructs an empty Info object. */
    public Info() {
      super();
    }

    /**
     * Constructs an Info object by parsing information from a JSON string.
     *
     * @param json the JSON string to parse.
     */
    public Info(String json) {
      super(json);
    }

    /**
     * Constructs an Info object using an already parsed JSON object.
     *
     * @param jsonObject the parsed JSON object.
     */
    Info(JsonObject jsonObject) {
      super(jsonObject);
    }

    /** {@inheritDoc} */
    @Override
    public BoxResource getResource() {
      return BoxRetentionPolicy.this;
    }

    /**
     * Gets the name given to the retention policy.
     *
     * @return name given to the retention policy.
     */
    public String getPolicyName() {
      return this.policyName;
    }

    /**
     * Update the policy name to a new value.
     *
     * @param policyName the new policy name.
     */
    public void setPolicyName(String policyName) {
      this.policyName = policyName;
      this.addPendingChange("policy_name", policyName);
    }

    /**
     * Gets the type of the retention policy. A retention policy type can either be "finite", where
     * a specific amount of time to retain the content is known upfront, or "indefinite", where the
     * amount of time to retain the content is still unknown.
     *
     * @return the type of the retention policy.
     */
    public String getPolicyType() {
      return this.policyType;
    }

    /**
     * Gets the length of the retention policy. This length specifies the duration in days that the
     * retention policy will be active for after being assigned to content.
     *
     * @return the length of the retention policy.
     */
    public int getRetentionLength() {
      return this.retentionLength;
    }

    /** @param retentionLength The length of the retention policy. */
    public void setRetentionLength(int retentionLength) {
      this.retentionLength = retentionLength;
      this.addPendingChange("retention_length", retentionLength);
    }

    /**
     * Gets the disposition action of the retention policy. This action can be "permanently_delete",
     * or "remove_retention".
     *
     * @return the disposition action of the retention policy.
     */
    public String getDispositionAction() {
      return this.dispositionAction;
    }

    /**
     * Set the action to take when retention period ends.
     *
     * @param dispositionAction the new action.
     */
    public void setDispositionAction(String dispositionAction) {
      this.dispositionAction = dispositionAction;
      this.addPendingChange("disposition_action", dispositionAction);
    }

    /**
     * Gets the status of the retention policy. The status can be "active" or "retired".
     *
     * @return the status of the retention policy.
     */
    public String getStatus() {
      return this.status;
    }

    /**
     * Set the policy status.
     *
     * @param status the new status value.
     */
    public void setStatus(String status) {
      this.status = status;
      this.addPendingChange("status", status);
    }

    /**
     * Gets info about the user created the retention policy.
     *
     * @return info about the user created the retention policy.
     */
    public BoxUser.Info getCreatedBy() {
      return this.createdBy;
    }

    /**
     * Gets the time that the retention policy was created.
     *
     * @return the time that the retention policy was created.
     */
    public Date getCreatedAt() {
      return this.createdAt;
    }

    /**
     * Gets the time that the retention policy was last modified.
     *
     * @return the time that the retention policy was last modified.
     */
    public Date getModifiedAt() {
      return this.modifiedAt;
    }

    /**
     * Gets the flag to denote that the owner of a retained file can extend the retention when near
     * expiration.
     *
     * @return the boolean flag.
     */
    public boolean getCanOwnerExtendRetention() {
      return this.canOwnerExtendRetention;
    }

    /**
     * Gets the flag to denote that owners and co-owners of a retained file will get notified when
     * near expiration.
     *
     * @return the boolean flag.
     */
    public boolean getAreOwnersNotified() {
      return this.areOwnersNotified;
    }

    /**
     * Gets the additional text desription of the retention policy.
     *
     * @return the additional text desription of the retention policy
     */
    public String getDescription() {
      return this.description;
    }

    /**
     * Set the additional text desription of the retention policy.
     *
     * @param description the new text desription of the retention policy
     */
    public void setDescription(String description) {
      this.description = description;
      this.addPendingChange("description", description);
    }

    /**
     * @return retention type. It can be one of values: `modifiable` or `non-modifiable`.
     *     `modifiable` means that you can modify the retention policy. For example, you can add or
     *     remove folders, shorten or lengthen the policy duration, or delete the assignment.
     *     `non-modifiable` means that can modify the retention policy only in a limited way: add a
     *     folder, lengthen the duration, retire the policy, change the disposition action or
     *     notification settings. You cannot perform other actions, such as deleting the assignment
     *     or shortening the policy duration.
     */
    public RetentionPolicyParams.RetentionType getRetentionType() {
      return retentionType;
    }

    /**
     * It is not possible to set retention type to `modifiable` once it was set to `non-modifiable`.
     */
    public void setRetentionTypeToNonModifiable() {
      this.retentionType = RetentionPolicyParams.RetentionType.NON_MODIFIABLE;
      this.addPendingChange("retention_type", retentionType.toJSONString());
    }

    /**
     * Gets the list of users to be notified of a retained file when near expiration.
     *
     * @return the list of users to be notified.
     */
    public List<BoxUser.Info> getCustomNotificationRecipients() {
      return this.customNotificationRecipients;
    }

    /** {@inheritDoc} */
    @Override
    void parseJSONMember(JsonObject.Member member) {
      super.parseJSONMember(member);
      String memberName = member.getName();
      JsonValue value = member.getValue();
      try {
        switch (memberName) {
          case "policy_name":
            this.policyName = value.asString();
            break;
          case "policy_type":
            this.policyType = value.asString();
            break;
          case "retention_length":
            int intVal;
            if (value.asString().equals(BoxRetentionPolicyType.Indefinite.value)) {
              intVal = -1;
            } else {
              intVal = Integer.parseInt(value.asString());
            }
            this.retentionLength = intVal;
            break;
          case "disposition_action":
            this.dispositionAction = value.asString();
            break;
          case "status":
            this.status = value.asString();
            break;
          case "created_by":
            JsonObject userJSON = value.asObject();
            if (this.createdBy == null) {
              String userID = userJSON.get("id").asString();
              BoxUser user = new BoxUser(getAPI(), userID);
              this.createdBy = user.new Info(userJSON);
            } else {
              this.createdBy.update(userJSON);
            }
            break;
          case "created_at":
            this.createdAt = BoxDateFormat.parse(value.asString());
            break;
          case "modified_at":
            this.modifiedAt = BoxDateFormat.parse(value.asString());
            break;
          case "can_owner_extend_retention":
            this.canOwnerExtendRetention = value.asBoolean();
            break;
          case "are_owners_notified":
            this.areOwnersNotified = value.asBoolean();
            break;
          case "description":
            this.description = value.asString();
            break;
          case "retention_type":
            this.retentionType =
                RetentionPolicyParams.RetentionType.fromJSONString(value.asString());
            break;
          case "custom_notification_recipients":
            List<BoxUser.Info> recipients = new ArrayList<>();
            for (JsonValue recipientJSON : value.asArray()) {
              String userID = recipientJSON.asObject().get("id").asString();
              BoxUser user = new BoxUser(getAPI(), userID);
              recipients.add(user.new Info(recipientJSON.asObject()));
            }
            this.customNotificationRecipients = recipients;
            break;
          default:
            break;
        }
      } catch (Exception e) {
        throw new BoxDeserializationException(memberName, value.toString(), e);
      }
    }
  }

  private enum BoxRetentionPolicyType {
    /** Type for finite retention policies. Finite retention policies has the duration. */
    Finite("finite"),
    /**
     * Type for indefinite retention policies. Indefinite retention policies can have only {@link
     * BoxRetentionPolicyAction#RemoveRetention} assigned action.
     */
    Indefinite("indefinite");

    private final String value;

    BoxRetentionPolicyType(String value) {
      this.value = value;
    }
  }

  /** The disposition action of the retention policy. */
  public enum BoxRetentionPolicyAction {
    /** Will cause the content retained by the policy to be permanently deleted. */
    PermanentlyDelete("permanently_delete"),

    /** Will lift the retention policy from the content, allowing it to be deleted by users. */
    RemoveRetention("remove_retention");

    private final String value;

    BoxRetentionPolicyAction(String value) {
      this.value = value;
    }
  }
}