package org.kuali.common.httplib.api.model;
   
   import static com.google.common.base.Optional.absent;
   import static com.google.common.collect.Lists.newArrayList;
   import static org.apache.commons.lang3.StringUtils.trimToNull;
   import static org.kuali.common.jute.base.Optionals.fromTrimToNull;
   import static org.kuali.common.jute.base.Precondition.checkNotBlank;
   import static org.kuali.common.jute.base.Precondition.checkNotNull;
   
  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;
  
  /**
   * {@code name} will not be null, the empty string (""), or pure whitespace.
   *
   * {@code value} will not be null, and (if present) will not be the empty string (""), or pure whitespace.
   *
   * An HTTP header with no value sounds like it is technically allowed, although the spec does not directly address this:
   *
   * <pre>
   * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
   *
   * The field-content does not include any leading or trailing LWS: linear white space occurring before the first non-whitespace character of the field-value or after the last
   * non-whitespace character of the field-value. Such leading or trailing LWS MAY be removed without changing the semantics of the field value. Any LWS that occurs between
   * field-content MAY be replaced with a single SP before interpreting the field value or forwarding the message downstream.
   * </pre>
   *
   * This class translates Apache's {@code org.apache.http.Header.getValue()} into an immutable Guava {@code Optional<String>} where {@code Optional.absent()} is used to represent
   * header values that are the empty string ("") or pure whitespace.
   */
  @JsonDeserialize(builder = Header.Builder.class)
  public final class Header {
  
      private final String name;
      private final Optional<String> value;
      private final ImmutableList<HeaderElement> elements;
  
      private Header(Builder builder) {
          this.name = builder.name;
          this.value = builder.value;
          this.elements = ImmutableList.copyOf(builder.elements);
      }
  
      /**
       * Leading and trailing whitespace is trimmed from both {@code name} and {@code value} before copying values.
       *
       * There may be whitespace in the middle of the {@code name} or {@code value}, but the first and last characters are guaranteed to be non-whitespace text.
       */
      public static ImmutableList<Header> copyOf(Iterable<? extends org.apache.http.Header> mutable) {
          List<Header> list = newArrayList();
          for (org.apache.http.Header element : mutable) {
              Header immutable = copyOf(element);
              list.add(immutable);
          }
          return ImmutableList.copyOf(list);
      }
  
      /**
       * Leading and trailing whitespace is trimmed from both {@code name} and {@code value} before copying values.
       *
       * There may be whitespace in the middle of the {@code name} or {@code value}, but the first and last characters are guaranteed to be non-whitespace text.
       */
      public static Header copyOf(org.apache.http.Header mutable) {
          Builder builder = builder();
          builder.withName(trimToNull(mutable.getName()));
          builder.withValue(fromTrimToNull(mutable.getValue()));
          return builder.build();
      }
  
      public static Builder builder() {
          return new Builder();
      }
  
      public static class Builder implements org.apache.commons.lang3.builder.Builder<Header> {
  
          private String name;
          private Optional<String> value = absent();
          private List<HeaderElement> elements = newArrayList();
  
          public Builder withName(String name) {
              this.name = name;
              return this;
          }
  
          @JsonSetter
          public Builder withValue(Optional<String> value) {
              this.value = value;
              return this;
          }
  
          public Builder withValue(String value) {
              return withValue(Optional.of(value));
          }
  
          public Builder withElements(List<HeaderElement> elements) {
             this.elements = elements;
             return this;
         }
 
         @Override
         public Header build() {
             return validate(new Header(this));
         }
 
         private static Header validate(Header instance) {
             checkNotBlank(instance.name, "name");
             checkNotBlank(instance.value, "value");
             checkNotNull(instance.elements, "elements");
             return instance;
         }
     }
 
     public String getName() {
         return name;
     }
 
     public Optional<String> getValue() {
         return value;
     }
 
     public List<HeaderElement> getElements() {
         return elements;
     }
 
 }