/*
    * The contents of this file are subject to the terms of the Common Development and
    * Distribution License (the License). You may not use this file except in compliance with the
    * License.
    *
    * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
    * specific language governing permission and limitations under the License.
    *
    * When distributing Covered Software, include this CDDL Header Notice in each file and include
   * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
   * Header, with the fields enclosed by brackets [] replaced by your own identifying
   * information: "Portions copyright [year] [name of copyright owner]".
   *
   * Copyright 2016-2017 ForgeRock AS.
   */
  
  package org.forgerock.api.models;
  
  import static org.forgerock.api.models.ApiError.apiError;
  import static org.forgerock.api.models.Reference.reference;
  import static org.forgerock.api.util.ValidationUtil.isEmpty;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Objects;
  
  import com.fasterxml.jackson.annotation.JsonInclude;
  import com.fasterxml.jackson.annotation.JsonProperty;
  import org.forgerock.api.enums.Stability;
  import org.forgerock.util.i18n.LocalizableString;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Class that represents the Operation type in API descriptor.
   */
  @JsonInclude(JsonInclude.Include.NON_NULL)
  public abstract class Operation {
  
      private static final Logger logger = LoggerFactory.getLogger(Operation.class);
  
      private final LocalizableString description;
      private final String[] supportedLocales;
      @JsonProperty("errors")
      private final ApiError[] apiErrors;
      private final Parameter[] parameters;
      private final Stability stability;
  
      /**
       * Protected constructor of the Operation.
       *
       * @param builder Operation Builder
       */
      protected Operation(Builder builder) {
          this.description = builder.description;
          this.supportedLocales = builder.supportedLocales;
          this.stability = builder.stability;
  
          final List<ApiError> apiErrors = builder.apiErrors;
          this.apiErrors = apiErrors.toArray(new ApiError[apiErrors.size()]);
  
          final List<Parameter> parameters = builder.parameters;
          this.parameters = parameters.toArray(new Parameter[parameters.size()]);
      }
  
      /**
       * Getter of the description.
       *
       * @return Description
       */
      public LocalizableString getDescription() {
          return description;
      }
  
      /**
       * Getter of the supported locales array.
       *
       * @return Supported locales
       */
      public String[] getSupportedLocales() {
          return supportedLocales;
      }
  
      /**
       * Getter of the error array.
       *
       * @return ApiError array
       */
      public ApiError[] getApiErrors() {
          return apiErrors.length == 0 ? null : apiErrors;
      }
  
      /**
       * Getter of the parameters array.
       *
       * @return Parameters
       */
      public Parameter[] getParameters() {
         return parameters.length == 0 ? null : parameters;
     }
 
     /**
      * Getter of Operation stability.
      *
      * @return Stability or {@code null} which suggests {@link Stability#STABLE} (default).
      */
     public Stability getStability() {
         return stability;
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) {
             return true;
         }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
         Operation operation = (Operation) o;
         return Objects.equals(description, operation.description)
                 && Arrays.equals(supportedLocales, operation.supportedLocales)
                 && Arrays.equals(apiErrors, operation.apiErrors)
                 && Arrays.equals(parameters, operation.parameters)
                 && stability == operation.stability;
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(description, supportedLocales, apiErrors, parameters, stability);
     }
 
     /**
      * Allocates the operation by operation type to the given Resource Builder
      * by calling the corresonding method by type.
      *
      * @param resourceBuilder - Resource Builder to add the operation
      */
     protected abstract void allocateToResource(Resource.Builder resourceBuilder);
 
     /**
      * Builder to help construct the Operation.
      */
     public abstract static class Builder<T extends Builder<T>> {
 
         private LocalizableString description;
         private String[] supportedLocales;
         private final List<ApiError> apiErrors;
         private final List<Parameter> parameters;
         private Stability stability;
 
         /**
          * Creates a new Builder.
          */
         protected Builder() {
             apiErrors = new ArrayList<>();
             parameters = new ArrayList<>();
         }
 
         /**
          * Abstract method that returns the instantiated Builder itself.
          *
          * @return Builder
          */
         protected abstract T self();
 
         /**
          * Set the description.
          *
          * @param description A description of the endpoint
          * @return Builder
          */
         public T description(LocalizableString description) {
             this.description = description;
             return self();
         }
 
         /**
          * Set the description.
          *
          * @param description A description of the endpoint
          * @return Builder
          */
         @JsonProperty("description")
         public T description(String description) {
             this.description = new LocalizableString(description);
             return self();
         }
 
         /**
          * Set the supported locale.
          *
          * @param supportedlocales Locales codes supported by the operation
          * @return Builder
          */
         @JsonProperty("supportedLocales")
         public T supportedLocales(String... supportedlocales) {
             this.supportedLocales = supportedlocales;
             return self();
         }
 
         /**
          * Set multiple supported errors.
          *
          * @param apiErrors What errors may be returned by this operation
          * @return Builder
          */
         @JsonProperty("errors")
         public T errors(List<ApiError> apiErrors) {
             this.apiErrors.addAll(apiErrors);
             return self();
         }
 
         /**
          * Sets a single supported error.
          *
          * @param apiError An error that may be returned by this operation
          * @return Builder
          */
         public T error(ApiError apiError) {
             this.apiErrors.add(apiError);
             return self();
         }
 
         /**
          * Set multiple supported parameters.
          *
          * @param parameters Extra parameters supported by the operation
          * @return Builder
          */
         @JsonProperty("parameters")
         public T parameters(List<Parameter> parameters) {
             this.parameters.addAll(parameters);
             return self();
         }
 
         /**
          * Sets a single supported parameters.
          *
          * @param parameter Extra parameter supported by the operation
          * @return Builder
          */
         public T parameter(Parameter parameter) {
             this.parameters.add(parameter);
             return self();
         }
 
         /**
          * Sets stability of Operation.
          *
          * @param stability Stability
          * @return Builder
          */
         @JsonProperty("stability")
         public T stability(Stability stability) {
             this.stability = stability;
             return self();
         }
 
         /**
          * Set all properties in the Builder using the data in the annotation.
          * @param operation The annotation that holds the data
          * @param descriptor The root descriptor
          * @param relativeType The type relative to which schema resources should be resolved.
          * @return Builder
          */
         public T detailsFromAnnotation(org.forgerock.api.annotations.Operation operation,
                 ApiDescription descriptor, Class<?> relativeType) {
             for (String ref : operation.errorRefs()) {
                 if (isEmpty(ref)) {
                     logger.debug("Empty errorRefs array-element ignored on: " + relativeType.getCanonicalName());
                 } else {
                     error(apiError().reference(reference().value(ref).build()).build());
                 }
             }
             for (org.forgerock.api.annotations.ApiError apiApiError : operation.errors()) {
                 error(ApiError.fromAnnotation(apiApiError, descriptor, relativeType));
             }
             for (org.forgerock.api.annotations.Parameter parameter : operation.parameters()) {
                 parameter(Parameter.fromAnnotation(relativeType, parameter));
             }
             return description(new LocalizableString(operation.description(), relativeType))
                     .supportedLocales(operation.locales())
                     .stability(operation.stability());
         }
     }
 
 }