package org.kuali.common.httplib.api.model;
   
   import static com.google.common.base.Charsets.UTF_8;
   import static com.google.common.base.Optional.absent;
   import static com.google.common.collect.Lists.newArrayList;
   import static com.google.common.io.ByteSource.wrap;
   import static com.google.common.io.Files.asByteSource;
   import static org.kuali.common.httplib.api.model.HttpMethod.DELETE;
   import static org.kuali.common.httplib.api.model.HttpMethod.POST;
  import static org.kuali.common.httplib.api.model.HttpMethod.PUT;
  import static org.kuali.common.httplib.api.model.HttpStatusCodeType.SERVER_ERROR;
  import static org.kuali.common.jute.base.Precondition.checkMin;
  import static org.kuali.common.jute.reflect.Reflection.checkNoNulls;
  
  import java.io.File;
  import java.nio.charset.Charset;
  import java.util.List;
  
  import com.fasterxml.jackson.annotation.JsonSetter;
  import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
  import com.google.common.base.Optional;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.Range;
  import com.google.common.io.ByteSource;
  
  @JsonDeserialize(builder = HttpOptions.Builder.class)
  public final class HttpOptions {
  
      private final Optional<Long> maxBytes;
      private final Optional<Integer> maxTimeMillis;
      private final Optional<Integer> connectTimeoutMillis;
      private final Optional<Integer> retryCount;
      private final Optional<Integer> retryDelayMillis;
      private final Optional<ByteSource> upload;
      private final Optional<File> outputFile;
      private final boolean cacheResponseInMemory;
      private final boolean printResponseToStdout;
      private final boolean followRedirects;
      private final HttpMethod requestMethod;
      private final Charset charset;
      private final boolean ignoreSecurity;
      private final boolean silent;
      private final ImmutableList<NameValue> data;
      private final Range<Integer> keepTryingRange;
      private final Optional<SecurityContext> security;
      private final ImmutableList<HeaderPair> headers;
      private final Optional<String> contentType;
  
      private HttpOptions(Builder builder) {
          this.contentType = builder.contentType;
          this.cacheResponseInMemory = builder.cacheResponseInMemory;
          this.printResponseToStdout = builder.printResponseToStdout;
          this.maxTimeMillis = builder.maxTimeMillis;
          this.connectTimeoutMillis = builder.connectTimeoutMillis;
          this.retryCount = builder.retryCount;
          this.retryDelayMillis = builder.retryDelayMillis;
          this.upload = builder.upload;
          this.followRedirects = builder.followRedirects;
          this.requestMethod = builder.requestMethod;
          this.outputFile = builder.outputFile;
          this.charset = builder.charset;
          this.maxBytes = builder.maxBytes;
          this.ignoreSecurity = builder.ignoreSecurity;
          this.silent = builder.silent;
          this.data = ImmutableList.copyOf(builder.data);
          this.headers = ImmutableList.copyOf(builder.headers);
          this.keepTryingRange = builder.keepTryingRange;
          this.security = builder.security;
      }
  
      public static HttpOptions build() {
          return builder().build();
      }
  
      public static Builder builder() {
          return new Builder();
      }
  
      public static class Builder implements org.apache.commons.lang3.builder.Builder<HttpOptions> {
  
          private Optional<Long> maxBytes = absent();
          private Optional<Integer> maxTimeMillis = absent();
          private Optional<Integer> connectTimeoutMillis = absent();
          private Optional<Integer> retryCount = absent();
          private Optional<Integer> retryDelayMillis = absent();
          private Optional<ByteSource> upload = absent();
          private boolean followRedirects = true;
          private HttpMethod requestMethod = HttpMethod.GET;
          private Optional<File> outputFile = absent();
          private Charset charset = UTF_8;
          private boolean ignoreSecurity = false;
          private boolean silent = true;
          private List<NameValue> data = newArrayList();
          private Range<Integer> keepTryingRange = SERVER_ERROR.getRange();
          private Optional<SecurityContext> security = absent();
          private boolean cacheResponseInMemory = true;
          private boolean printResponseToStdout = false;
          private List<HeaderPair> headers = newArrayList();
          private Optional<String> contentType = absent();
 
         private static HttpOptions validate(HttpOptions instance) {
             checkNoNulls(instance);
             checkMin(instance.maxBytes, 0, "maxBytes");
             checkMin(instance.maxTimeMillis, 0, "maxTimeMillis");
             checkMin(instance.connectTimeoutMillis, 0, "connectTimeoutMillis");
             checkMin(instance.retryCount, 0, "retryCount");
             checkMin(instance.retryDelayMillis, 0, "retryDelayMillis");
             return instance;
         }
 
         public Builder withContentType(Optional<String> contentType) {
             this.contentType = contentType;
             return this;
         }
 
         public Builder withContentType(String contentType) {
             return withContentType(Optional.of(contentType));
         }
 
         public Builder withHeaders(List<HeaderPair> headers) {
             this.headers = headers;
             return this;
         }
 
         @JsonSetter
         public Builder withSecurity(Optional<SecurityContext> security) {
             this.security = security;
             return this;
         }
 
         public Builder withSecurity(SecurityContext security) {
             return withSecurity(Optional.of(security));
         }
 
         public Builder withCacheResponseInMemory(boolean cacheResponseInMemory) {
             this.cacheResponseInMemory = cacheResponseInMemory;
             return this;
         }
 
         public Builder cacheResponseInMemory() {
             return withCacheResponseInMemory(true);
         }
 
         public Builder withPrintResponseToStdout(boolean printResponseToStdout) {
             this.printResponseToStdout = printResponseToStdout;
             return this;
         }
 
         public Builder printResponseToStdout() {
             return withPrintResponseToStdout(true);
         }
 
         @JsonSetter
         public Builder withOutputFile(Optional<File> outputFile) {
             this.outputFile = outputFile;
             return this;
         }
 
         public Builder withOutputFile(File outputFile) {
             return withOutputFile(Optional.of(outputFile));
         }
 
         public Builder withKeepTryingRange(Range<Integer> keepTryingRange) {
             this.keepTryingRange = keepTryingRange;
             return this;
         }
 
         public Builder withData(List<NameValue> data) {
             this.data = data;
             return this;
         }
 
         public Builder withSilent(boolean silent) {
             this.silent = silent;
             return this;
         }
 
         public Builder ignoreSecurity() {
             return withIgnoreSecurity(true);
         }
 
         public Builder withIgnoreSecurity(boolean ignoreSecurity) {
             this.ignoreSecurity = ignoreSecurity;
             return this;
         }
 
         @JsonSetter
         public Builder withMaxBytes(Optional<Long> maxBytes) {
             this.maxBytes = maxBytes;
             return this;
         }
 
         public Builder withMaxBytes(long maxBytes) {
             return withMaxBytes(Optional.of(maxBytes));
         }
 
         public Builder withCharset(Charset charset) {
             this.charset = charset;
             return this;
         }
 
         public Builder withEncoding(String encoding) {
             return withCharset(Charset.forName(encoding));
         }
 
         public Builder post() {
             return withRequestMethod(POST);
         }
 
         public Builder delete() {
             return withRequestMethod(DELETE);
         }
 
         public Builder put() {
             return withRequestMethod(PUT);
         }
 
         public Builder withRequestMethod(HttpMethod requestMethod) {
             this.requestMethod = requestMethod;
             return this;
         }
 
         @JsonSetter
         public Builder withRetryCount(Optional<Integer> retries) {
             this.retryCount = retries;
             return this;
         }
 
         public Builder withRetryCount(int retries) {
             return withRetryCount(Optional.of(retries));
         }
 
         public Builder withFollowRedirects(boolean followRedirects) {
             this.followRedirects = followRedirects;
             return this;
         }
 
         public Builder followRedirects() {
             return withFollowRedirects(true);
         }
 
         @JsonSetter
         public Builder withConnectTimeoutMillis(Optional<Integer> connectTimeoutMillis) {
             this.connectTimeoutMillis = connectTimeoutMillis;
             return this;
         }
 
         public Builder withConnectTimeoutMillis(int connectTimeoutMillis) {
             return withConnectTimeoutMillis(Optional.of(connectTimeoutMillis));
         }
 
         @JsonSetter
         public Builder withMaxTimeMillis(Optional<Integer> maxTimeMillis) {
             this.maxTimeMillis = maxTimeMillis;
             return this;
         }
 
         public Builder withMaxTimeMillis(int maxTimeMillis) {
             return withMaxTimeMillis(Optional.of(maxTimeMillis));
         }
 
         @JsonSetter
         public Builder withRetryDelayMillis(Optional<Integer> retryDelayMillis) {
             this.retryDelayMillis = retryDelayMillis;
             return this;
         }
 
         public Builder withRetryDelayMillis(int retryDelayMillis) {
             return withRetryDelayMillis(Optional.of(retryDelayMillis));
         }
 
         @JsonSetter
         public Builder withUpload(Optional<ByteSource> upload) {
             this.upload = upload;
             return this;
         }
 
         public Builder withUpload(ByteSource upload) {
             return withUpload(Optional.of(upload));
         }
 
         public Builder upload(File file) {
             return withUpload(asByteSource(file));
         }
 
         public Builder upload(String content, Charset charset) {
             return withUpload(wrap(content.getBytes(charset)));
         }
 
         @Override
         public HttpOptions build() {
             return validate(new HttpOptions(this));
         }
 
     }
 
     public Optional<Integer> getMaxTimeMillis() {
         return maxTimeMillis;
     }
 
     public Optional<Integer> getConnectTimeoutMillis() {
         return connectTimeoutMillis;
     }
 
     public Optional<Integer> getRetries() {
         return retryCount;
     }
 
     public Optional<Integer> getRetryDelayMillis() {
         return retryDelayMillis;
     }
 
     public Optional<ByteSource> getUpload() {
         return upload;
     }
 
     public boolean isFollowRedirects() {
         return followRedirects;
     }
 
     public HttpMethod getMethod() {
         return requestMethod;
     }
 
     public Optional<Integer> getRetryCount() {
         return retryCount;
     }
 
     public HttpMethod getRequestMethod() {
         return requestMethod;
     }
 
     public Optional<Long> getMaxBytes() {
         return maxBytes;
     }
 
     public boolean isIgnoreSecurity() {
         return ignoreSecurity;
     }
 
     public boolean isSilent() {
         return silent;
     }
 
     public List<NameValue> getData() {
         return data;
     }
 
     public Charset getCharset() {
         return charset;
     }
 
     public Range<Integer> getKeepTryingRange() {
         return keepTryingRange;
     }
 
     public Optional<File> getOutputFile() {
         return outputFile;
     }
 
     public boolean isCacheResponseInMemory() {
         return cacheResponseInMemory;
     }
 
     public Optional<SecurityContext> getSecurity() {
         return security;
     }
 
     public boolean isPrintResponseToStdout() {
         return printResponseToStdout;
     }
 
     public List<HeaderPair> getHeaders() {
         return headers;
     }
 
     public Optional<String> getContentType() {
         return contentType;
     }
 
 }