/*
    * 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 ForgeRock AS.
   */
  
  package org.forgerock.api.models;
  
  import static org.forgerock.api.util.ValidationUtil.*;
  
  import java.lang.reflect.Method;
  import java.util.Arrays;
  import java.util.Objects;
  
  import com.fasterxml.jackson.annotation.JsonProperty;
  import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
  import org.wrensecurity.guava.common.base.Strings;
  
  import org.forgerock.api.ApiValidationException;
  import org.forgerock.api.enums.CountPolicy;
  import org.forgerock.api.enums.PagingMode;
  import org.forgerock.api.enums.QueryType;
  
  /**
   * Class that represents the Create Operation type in API descriptor.
   */
  @JsonDeserialize(builder = Query.Builder.class)
  public final class Query extends Operation implements Comparable<Query> {
  
      private final QueryType type;
      private final PagingMode[] pagingModes;
      private final CountPolicy[] countPolicies;
      private final String queryId;
      private final String[] queryableFields;
      private final String[] supportedSortKeys;
  
      private Query(Builder builder) {
          super(builder);
          this.type = builder.type;
          this.pagingModes = builder.pagingModes;
          this.countPolicies = builder.countPolicies;
          this.queryId = builder.queryId;
          this.queryableFields = builder.queryableFields;
          this.supportedSortKeys = builder.supportedSortKeys;
  
          if (type == null) {
              throw new ApiValidationException("type is required");
          }
          if (type == QueryType.ID && isEmpty(queryId)) {
              throw new ApiValidationException("queryId required for type = ID");
          }
      }
  
      /**
       * Getter of the query type.
       *
       * @return Query type num
       */
      public QueryType getType() {
          return type;
      }
  
      /**
       * Getter of the paging modes.
       *
       * @return Paging mode enums
       */
      public PagingMode[] getPagingModes() {
          return pagingModes;
      }
  
      /**
       * Getter of the supported paging policies.
       * If the array is empty, this means that the query does not support any form of count policy, and no value for
       * count policy should be specified.
       *
       * @return Supported paging policy enums
       */
      public CountPolicy[] getCountPolicies() {
          return countPolicies;
      }
  
      /**
       * Getter of the query id.
       *
       * @return Query id
       */
      public String getQueryId() {
          return queryId;
     }
 
     /**
      * Getter of the queryable fields.
      *
      * @return Queryable fields
      */
     public String[] getQueryableFields() {
         return queryableFields;
     }
 
     /**
      * Getter of the supported sort keys.
      *
      * @return Supported sort keys
      */
     public String[] getSupportedSortKeys() {
         return supportedSortKeys;
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) {
             return true;
         }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
         if (!super.equals(o)) {
             return false;
         }
         Query query = (Query) o;
         return type == query.type
                 && Arrays.equals(pagingModes, query.pagingModes)
                 && Arrays.equals(countPolicies, query.countPolicies)
                 && Objects.equals(queryId, query.queryId)
                 && Arrays.equals(queryableFields, query.queryableFields)
                 && Arrays.equals(supportedSortKeys, query.supportedSortKeys);
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(super.hashCode(), type, pagingModes, countPolicies, queryId, queryableFields,
                 supportedSortKeys);
     }
 
     /**
      * Creates a new builder for Query.
      *
      * @return New builder instance
      */
     public static Builder query() {
         return new Builder();
     }
 
     /**
      * Allocates the Query operation type to the given Resource Builder.
      *
      * @param resourceBuilder - Resource Builder to add the operation
      */
     @Override
     protected void allocateToResource(Resource.Builder resourceBuilder) {
         resourceBuilder.query(this);
     }
 
     /**
      * Builds a Query object from the data stored in the annotation.
      *
      * @param query The annotation that stores the data.
      * @param annotated The method that the annotation was found on.
      * @param descriptor The root descriptor to add definitions to.
      * @param relativeType The type relative to which schema resources should be resolved.
      * @return Query instance
      */
     public static Query fromAnnotation(org.forgerock.api.annotations.Query query, Method annotated,
             ApiDescription descriptor, Class<?> relativeType) {
         String queryId = query.id();
         if (query.type() == QueryType.ID && Strings.isNullOrEmpty(queryId)) {
             if (annotated == null) {
                 throw new IllegalArgumentException("Query is missing ID: " + query);
             }
             queryId = annotated.getName();
         }
         return query()
                 .detailsFromAnnotation(query.operationDescription(), descriptor, relativeType)
                 .type(query.type())
                 .pagingModes(query.pagingModes())
                 .countPolicies(query.countPolicies())
                 .queryId(queryId)
                 .queryableFields(query.queryableFields())
                 .supportedSortKeys(query.sortKeys())
                 .build();
     }
 
     /**
      * Compares two queries.
      *
      * @param query Query to compare to
      * @return the value {@code 0} if the argument string is equal to
      * this string; a value less than {@code 0} if this string
      * is lexicographically less than the string argument; and a
      * value greater than {@code 0} if this string is
      * lexicographically greater than the string argument.
      */
     @Override
     public int compareTo(final Query query) {
         // Sort Order: EXPRESSION, FILTER, ID
         // @Checkstyle:off
         switch (query.getType()) {
             case EXPRESSION:
                 if (this.getType() == QueryType.EXPRESSION) {
                     return 0;
                 }
                 return 1;
             case FILTER:
                 if (this.getType() == QueryType.FILTER) {
                     return 0;
                 }
                 if (this.getType() == QueryType.EXPRESSION) {
                     return -1;
                 }
                 return 1;
             case ID:
                 if (this.getType() == QueryType.ID) {
                     return this.queryId.compareTo(query.getQueryId());
                 }
                 return -1;
             default:
                 throw new IllegalStateException("Unsupported QueryType: " + query.getType());
         }
         // @Checkstyle:on
     }
 
     /**
      * Builder to help construct the Read.
      */
     public static final class Builder extends Operation.Builder<Builder> {
 
         private QueryType type;
         private PagingMode[] pagingModes;
         private CountPolicy[] countPolicies;
         private String queryId;
         private String[] queryableFields;
         private String[] supportedSortKeys;
 
         /**
          * Returns the builder instance.
          *
          * @return Builder
          */
         @Override
         protected Builder self() {
             return this;
         }
 
         /**
          * Set the query type.
          *
          * @param type query type enum
          * @return Builder
          */
         @JsonProperty("type")
         public Builder type(QueryType type) {
             this.type = type;
             return this;
         }
 
         /**
          * Set the paging mode.
          *
          * @param pagingMode Query paging mode enum
          * @return Builder
          */
         @JsonProperty("pagingModes")
         public Builder pagingModes(PagingMode... pagingMode) {
             this.pagingModes = pagingMode;
             return this;
         }
 
         /**
          * Set the supported page count policies.
          * If the array is empty, this means that the query does not support any form of count policy, and no value
          * for count policy should be specified.
          *
          * @param countPolicy Array of supported paging mode policies
          * @return Builder
          */
         @JsonProperty("countPolicies")
         public Builder countPolicies(CountPolicy... countPolicy) {
             this.countPolicies = countPolicy;
             return this;
         }
 
         /**
          * Set the query id. Required if “type” is ID.
          *
          * @param queryId Query id
          * @return Builder
          */
         @JsonProperty("queryId")
         public Builder queryId(String queryId) {
             this.queryId = queryId;
             return this;
         }
 
         /**
          * Set the queryable fields.
          *
          * @param queryableFields Array of the fileds that are queryable
          * @return Builder
          */
         @JsonProperty("queryableFields")
         public Builder queryableFields(String... queryableFields) {
             this.queryableFields = queryableFields;
             return this;
         }
 
         /**
          * Set the supported sort keys.
          *
          * @param supportedSortKeys Array of supported sort keys
          * @return Builder
          */
         @JsonProperty("supportedSortKeys")
         public Builder supportedSortKeys(String... supportedSortKeys) {
             this.supportedSortKeys = supportedSortKeys;
             return this;
         }
 
         /**
          * Builds the Query instance.
          *
          * @return Query instance
          */
         public Query build() {
             return new Query(this);
         }
     }
 
 }