/*
    * ====================================================================
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   */
  
  package org.apache.http.message;
  
  import java.util.NoSuchElementException;
  
  import org.apache.http.FormattedHeader;
  import org.apache.http.Header;
  import org.apache.http.HeaderElement;
  import org.apache.http.HeaderElementIterator;
  import org.apache.http.HeaderIterator;
  import org.apache.http.util.Args;
  import org.apache.http.util.CharArrayBuffer;
  
  /**
   * Basic implementation of a {@link HeaderElementIterator}.
   *
   * @since 4.0
   */
  public class BasicHeaderElementIterator implements HeaderElementIterator {
  
      private final HeaderIterator headerIt;
      private final HeaderValueParser parser;
  
      private HeaderElement currentElement = null;
      private CharArrayBuffer buffer = null;
      private ParserCursor cursor = null;
  
      /**
       * Creates a new instance of BasicHeaderElementIterator
       */
      public BasicHeaderElementIterator(
              final HeaderIterator headerIterator,
              final HeaderValueParser parser) {
          this.headerIt = Args.notNull(headerIterator, "Header iterator");
          this.parser = Args.notNull(parser, "Parser");
      }
  
  
      public BasicHeaderElementIterator(final HeaderIterator headerIterator) {
          this(headerIterator, BasicHeaderValueParser.INSTANCE);
      }
  
  
      private void bufferHeaderValue() {
          this.cursor = null;
          this.buffer = null;
          while (this.headerIt.hasNext()) {
              final Header h = this.headerIt.nextHeader();
              if (h instanceof FormattedHeader) {
                  this.buffer = ((FormattedHeader) h).getBuffer();
                  this.cursor = new ParserCursor(0, this.buffer.length());
                  this.cursor.updatePos(((FormattedHeader) h).getValuePos());
                  break;
              }
              final String value = h.getValue();
              if (value != null) {
                  this.buffer = new CharArrayBuffer(value.length());
                  this.buffer.append(value);
                  this.cursor = new ParserCursor(0, this.buffer.length());
                  break;
              }
          }
      }
  
      private void parseNextElement() {
          // loop while there are headers left to parse
          while (this.headerIt.hasNext() || this.cursor != null) {
              if (this.cursor == null || this.cursor.atEnd()) {
                  // get next header value
                  bufferHeaderValue();
              }
              // Anything buffered?
              if (this.cursor != null) {
                 // loop while there is data in the buffer
                 while (!this.cursor.atEnd()) {
                     final HeaderElement e = this.parser.parseHeaderElement(this.buffer, this.cursor);
                     if (!(e.getName().isEmpty() && e.getValue() == null)) {
                         // Found something
                         this.currentElement = e;
                         return;
                     }
                 }
                 // if at the end of the buffer
                 if (this.cursor.atEnd()) {
                     // discard it
                     this.cursor = null;
                     this.buffer = null;
                 }
             }
         }
     }
 
     @Override
     public boolean hasNext() {
         if (this.currentElement == null) {
             parseNextElement();
         }
         return this.currentElement != null;
     }
 
     @Override
     public HeaderElement nextElement() throws NoSuchElementException {
         if (this.currentElement == null) {
             parseNextElement();
         }
 
         if (this.currentElement == null) {
             throw new NoSuchElementException("No more header elements available");
         }
 
         final HeaderElement element = this.currentElement;
         this.currentElement = null;
         return element;
     }
 
     @Override
     public final Object next() throws NoSuchElementException {
         return nextElement();
     }
 
     @Override
     public void remove() throws UnsupportedOperationException {
         throw new UnsupportedOperationException("Remove not supported");
     }
 
 }