/*******************************************************************************
 * Copyright (c) 2002-2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   IBM - Initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.wsi.internal.core.util;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import java.util.Locale;
import java.util.StringTokenizer;

import sun.net.www.MessageHeader;

import com.ibm.icu.text.SimpleDateFormat;

/**
 * This class checks HTTP request headers about RFC 2616.
 *
 * @author Volodin 
 */
public class HttpHeadersValidator
{

  private static final String HEADER_ALLOW = "Allow";
  private static final String HEADER_CONTENT_TYPE = "Content-Type";
  private static final String HEADER_CONTENT_ENCODING = "Content-Encoding";
  private static final String HEADER_CONTENT_LANGUAGE = "Content-Language";
  private static final String HEADER_CONTENT_LENGHT = "Content-Length";
  private static final String HEADER_CONTENT_LOCATION = "Content-Location";
  private static final String HEADER_CONTENT_RANGE = "Content-Range";
  private static final String HEADER_EXPIRES = "Expires";
  private static final String HEADER_LAST_MODIFIED = "Last-Modified";
  private static final String HEADER_CACHE_CONTROL = "Cache-Control";
  private static final String HEADER_CONNECTION = "Connection";
  private static final String HEADER_DATE = "Date";
  private static final String HEADER_PRAGMA = "Pragma";
  private static final String HEADER_TRAILER = "Trailer";
  private static final String HEADER_TRANSFER_ENCODING = "Transfer-Encoding";

  private static final String HEADER_UPGRADE = "Upgrade";
  private static final String HEADER_VIA = "Via";
  private static final String HEADER_WARNING = "Warning";

  private static final String HEADER_ACCEPT = "Accept";
  private static final String HEADER_ACCEPT_CHARSET = "Accept-Charset";
  private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";
  private static final String HEADER_ACCEPT_LANGUAGE = "Accept-Language";
  private static final String HEADER_AUTHORIZATION = "Authorization";
  private static final String HEADER_EXPECT = "Expect";
  private static final String HEADER_FROM = "From";
  private static final String HEADER_HOST = "Host";
  private static final String HEADER_IF_MATCH = "If-Match";
  private static final String HEADER_IF_MODIFIED_SINCE = "If-Modified-Since";
  private static final String HEADER_IF_NONE_MATCH = "If-None-Match";
  private static final String HEADER_IF_RANGE = "If-Range";
  private static final String HEADER_IF_UNMODIFIED_SINCE =
    "If-Unmodified-Since";
  private static final String HEADER_MAX_FORWARDS = "Max-Forwards";
  private static final String HEADER_PROXY_AUTHORIZATION =
    "Proxy-Authorization";
  private static final String HEADER_RANGE = "Range";
  private static final String HEADER_REFERER = "Referer";
  private static final String HEADER_TE = "TE";
  private static final String HEADER_USER_AGENT = "User-Agent";

  /**
   * This class checks e-mail string about RFC 822.
   */
  public static class MailboxValidator
  {
    private static final char[] SPECIAL =
      { '(', ')', '<', '>', '@', ',', ';', ':', '\\', '\"', '.', '[', ']' };

    /**
    	* Validates e-mail string.
    * @param mailbox e-mail string
    * @return boolean  true if e-mail string is conform to RFC 822, false otherwise.
    */

    public static boolean validateMailbox(String mailbox)
    {

      if (!isFullAddr(mailbox) && !isShortAddr(mailbox))
        return false;

      return true;
    }

    /**
     * Method isSimpleAddr.
     * @param mailbox
     * @return boolean
     */
    private static boolean isShortAddr(String mailbox)
    {
      int indexAt = mailbox.indexOf('@');
      if (indexAt == -1)
        return false;

      if (!isLocalPart(mailbox.substring(0, indexAt))
        || !isDomain(mailbox.substring(indexAt + 1)))
        return false;

      return true;
    }

    /**
     * Method isDomaim.
     * @param string
     * return boolean
     */
    private static boolean isDomain(String string)
    {
      if (string.trim().length() == 0)
        return false;
      StringTokenizer st = new StringTokenizer(string, ".");
      while (st.hasMoreTokens())
      {
        String subDomain = st.nextToken();
        if (!isAtom(subDomain) && !isDomainLiteral(subDomain))
          return false;

      }
      return true;
    }

    /**
     * Method isDomainLiteral.
     * @param subDomain
     * @return boolean
     */
    private static boolean isDomainLiteral(String subDomain)
    {
      if (getLastDomainLiteral(subDomain, 0) == subDomain.length())
      {
        return true;
      }
      else
      {
        return false;
      }
    }

    private static int getLastDomainLiteral(String str, int startIndex)
    {

      int index = startIndex;
      //int newIndex = 0;

      // if end if the string
      if (startIndex == str.length())
        return startIndex;
      // if the begin is not '['
      if (str.charAt(index) != '[')
        return startIndex;

      index++;
      while (true)
      {
        index = getLastDtext(str, index);
        if (index == str.length())
          return startIndex;
        if (BasicRules.isQuotedPair(str, index - 1))
        {
          index++;
          if (index == str.length())
            return startIndex;
        }
        else
          break;
      }
      // if the end is not ']'
      if (str.charAt(index) != ']')
        return startIndex;

      index++;
      return index;
    }

    private static int getLastDtext(String str, int startIndex)
    {
      if (str.length() == startIndex)
        return startIndex;
      int i = 0;
      for (; i < str.length(); i++)
      {
        char ch = str.charAt(i);
        i = BasicRules.getLastIndexLWS(str, i);
        if (!BasicRules.isCHAR(ch)
          || str.charAt(i) == '['
          || str.charAt(i) == ']'
          || str.charAt(i) == '\\'
          || str.charAt(i) == BasicRules.CR)
        {
          return i + 1;
        }
      }
      return i + 1;
    }

    /**
     * Method isLocalPart.
     * @param string
     * @return boolean
     */
    private static boolean isLocalPart(String string)
    {
      if (string.trim().length() == 0)
        return false;
      StringTokenizer st = new StringTokenizer(string, ".");
      while (st.hasMoreTokens())
      {
        if (!isWord(st.nextToken()))
          return false;
      }
      return true;
    }

    /**
     * Method isWord.
     * @param string
     * @return boolean
     */
    private static boolean isWord(String string)
    {
      if (!isAtom(string) && !isQuotedString(string))
        return false;
      return true;
    }

    /**
     * Method isAtom.
     * @param string
     * @return boolean
     */
    private static boolean isAtom(String string)
    {
      if (string.length() == 0)
        return false;
      for (int i = 0; i < string.length(); i++)
      {
        if (!BasicRules.isCHAR(string.charAt(i))
          || isSpecial(string.charAt(i))
          || string.charAt(i) == ' '
          || BasicRules.isCTL(string.charAt(i)))
        {
          return false;
        }
      }
      return true;
    }

    /**
     * Method isSpecial.
     * @param c
     * @return boolean
     */
    private static boolean isSpecial(char ch)
    {
      for (int index = 0; index < SPECIAL.length; index++)
      {
        if (ch == SPECIAL[index])
          return true;
      }
      return false;
    }

    /**
     * Method isFullAddr.
     * @param mailbox
     * @return boolean
     */
    private static boolean isFullAddr(String mailbox)
    {
      if (mailbox.length() == 0)
        return false;
      int idxLT = mailbox.indexOf('<');
      if (idxLT == -1)
        return false;

      //is phrase
      String phrase = mailbox.substring(0, idxLT);
      StringTokenizer st = new StringTokenizer(phrase, " ");
      if (st.countTokens() == 0)
        return false;
      while (st.hasMoreTokens())
      {
        if (!isWord(st.nextToken()))
          return false;
      }
      if (phrase.charAt(phrase.length() - 1) != BasicRules.SP)
      {
        return false;
      }

      //is route-addr
      String routeAddr = mailbox.substring(idxLT + 1);
      // is route
      int idxTwoSpot = routeAddr.indexOf(':');
      if (idxTwoSpot != -1)
      {
        StringTokenizer stRouteAddr =
          new StringTokenizer(routeAddr.substring(0, idxTwoSpot), ",");
        if (!stRouteAddr.hasMoreTokens())
          return false;
        while (stRouteAddr.hasMoreTokens())
        {
          if (!isDomain(stRouteAddr.nextToken()))
            return false;
        }
      }

      //is addr spec
      int idxGT = routeAddr.indexOf('>');
      if (idxGT == -1 || idxGT != (routeAddr.length() - 1))
        return false;

      if (!isShortAddr(routeAddr.substring(idxTwoSpot + 1, idxGT)))
        return false;

      return true;
    }

  }

  /**
   * Validates HTTP request headers.
   * @param headers HTTP request headers
   * @return boolean  true if all HTTP headers string is conform to RFC 2616, false otherwise.
   */

  public static boolean validateHttpRequestHeaders(String headers)
  {

    MessageHeader mh = new MessageHeader();
    try
    {
      mh.parseHeader(new ByteArrayInputStream(headers.getBytes()));
    }
    catch (IOException e)
    {
      return false;
    }

    String header = null;
    String value = null;

    header = mh.getKey(0);
    if (header != null)
      return false;

    value = mh.getValue(0);
    if (value == null)
      return false;

    //method
    StringTokenizer st = new StringTokenizer(value, " ");
    if (!st.hasMoreElements())
      return false;
    String str = st.nextToken();
    if (!isToken(str))
      return false;

    if (!st.hasMoreElements())
      return false;
    str = st.nextToken();
    if (!isURI(str) && !str.equals("*"))
      return false;

    if (!st.hasMoreElements())
      return false;
    str = st.nextToken();
    if (!isHTTPVersion(str))
      return false;

    int i = 1;
    try
    {
      while ((header = mh.getKey(i)) != null)
      {
        value = mh.getValue(i);
        i++;

        // is message-header token
        if (!isToken(header))
          return false;

        //---- entity-headers

        if (header.equals(HEADER_ALLOW))
        {
          if (!isValidAllow(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_CONTENT_TYPE))
        {
          if (!isMediaType(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_CONTENT_ENCODING))
        {
          if (!isToken(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_CONTENT_LANGUAGE))
        {
          if (!isLanguageTag(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_CONTENT_LENGHT))
        {
          if (!isDidgit(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_CONTENT_LOCATION))
        {
          if (!isURI(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_CONTENT_RANGE))
        {
          if (!isValidContentRange(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_EXPIRES)
          || header.equals(HEADER_LAST_MODIFIED))
        {
          if (!isHTTPDate(value))
            return false;
          else
            continue;
        }

        //---- general-headers
        if (header.equals(HEADER_CACHE_CONTROL))
        {
          if (!isValidCacheControl(value))
            return false;

          continue;
          //return true;
        }

        if (header.equals(HEADER_CONNECTION))
        {
          if (!isToken(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_DATE))
        {
          if (!isHTTPDate(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_PRAGMA))
        {
          if (!isPragmaDerective(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_TRAILER))
        {
          if (!isToken(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_TRANSFER_ENCODING))
        {
          if (!isTransferCoding(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_UPGRADE))
        {
          if (!isValidUpgrade(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_VIA))
        {
          if (!isValidVia(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_WARNING))
        {
          if (!isValidWarning(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_ACCEPT))
        {
          if (!isValidAccept(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_ACCEPT_CHARSET))
        {
          if (!isValidAcceptCharSet(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_ACCEPT_ENCODING))
        {
          if (!isValidAcceptEncoding(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_ACCEPT_LANGUAGE))
        {
          if (!isValidAcceptLanguage(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_AUTHORIZATION)
          || header.equals(HEADER_PROXY_AUTHORIZATION))
        {
          if (!isCredentials(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_EXPECT))
        {
          if (!isExpectation(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_FROM))
        {
          if (!MailboxValidator.validateMailbox(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_IF_MATCH)
          || header.equals(HEADER_IF_NONE_MATCH))
        {
          if (!isValidIfMatch(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_IF_RANGE))
        {
          if (!isEntityTag(value) && !isHTTPDate(value))
            return false;
          else
            continue;
        }

        //---			
        if (header.equals(HEADER_IF_MODIFIED_SINCE))
        {
          if (!isHTTPDate(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_IF_UNMODIFIED_SINCE))
        {
          if (!isHTTPDate(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_MAX_FORWARDS))
        {
          if (!isDidgit(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_USER_AGENT))
        {
          if (!isValidUserAgent(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_TE))
        {
          if (!isValidTE(value))
            return false;
          else
            continue;
        }

        if (header.equals(HEADER_RANGE))
        {
          if (!isRange(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_HOST))
        {
          if (!isHost(value))
            return false;
          else
            continue;
        }
        if (header.equals(HEADER_REFERER))
        {
          if (!isURI(value))
            return false;
          else
            continue;
        }

      }
    }
    catch (Exception e)
    {
      return false;
    }
    return true;
  }

  /**
   * Method isValidIfMatch.
   * @param value
   * @return boolean
   */
  private static boolean isValidIfMatch(String value)
  {
    if (value.trim().length() == 0)
      return true;
    if ("*".equals(value.trim()))
      return true;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      if (!isEntityTag(str))
        return false;

    }

    return true;
  }

  /**
   * Method isValidUpgrade.
   * @param value
   * @return boolean
   */
  private static boolean isValidUpgrade(String value)
  {
    if (value.trim().length() == 0)
      return false;
    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      if (!isProduct(str))
        return false;

    }
    return true;
  }

  /**
   * Method isValidCacheControl.
   * @param value
   * @return boolean
   */
  private static boolean isValidCacheControl(String value)
  {

    if (value.trim().length() == 0)
      return false;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      int index = str.indexOf('=');
      if (index == -1)
      {

      }
      else
      {
        if (!isToken(str.substring(0, index)))
          return false;
        String strAfterEq = str.substring(index + 1);
        if (!isToken(strAfterEq) && !isQuotedString(strAfterEq))
        {
          return false;
        }
      }
    }

    return true;
  }

  /**
   * Method isHTTPVersion.
   * @param str
   * @return boolean
   */
  private static boolean isHTTPVersion(String str)
  {
    if (!str.startsWith("HTTP/"))
      return false;
    int idx = "HTTP/".length();

    int idx2 = str.indexOf(".");

    // 1*DIGIT
    String s = str.substring(idx, idx2);
    if (!isDidgit(s))
      return false;

    s = str.substring(idx2 + 1);
    if (!isDidgit(s))
      return false;

    return true;
  }

  /**
   * Method isValidWarning.
   * @param value
   * @return boolean
   */
  private static boolean isValidWarning(String value)
  {
    if (value.length() == 0)
      return false;
    value = value.trim();
    StringTokenizer st = new StringTokenizer(value, " ");
    String str = st.nextToken();

    if (str.length() > 3 || !isDidgit(str))
      return false;

    if (!st.hasMoreTokens())
      return false;
    str = st.nextToken();
    if (!isHost(str) && !isToken(str))
      return false;

    //if(!st.hasMoreTokens()) return false;
    str = st.nextToken("").trim();
    //???

    int lastQuotedString = BasicRules.getLastQuotedString(str, 0);
    if (lastQuotedString == str.length())
    {
      return true;
    }
    else
    {
      String data = str.substring(lastQuotedString);
      if (data.charAt(data.length()) != '\"')
        return false;
      if (str.charAt(0) != '\"')
        return false;
      if (!isHTTPDate(str.substring(1, data.length() - 1)))
        return false;
    }

    return true;
  }

  /**
   * Method isValidVia.
   * @param value
   * @return boolean
   */
  private static boolean isValidVia(String value)
  {
    if (value.trim().length() == 0)
      return false;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {

      String str = st.nextToken().trim();

      StringTokenizer st2 = new StringTokenizer(str, " ");

      // protocol/version
      str = st2.nextToken();
      int idx = str.indexOf("/");
      if (idx == -1)
      {
        if (!isToken(str))
          return false;
      }
      else
      {
        if (!isToken(str.substring(0, idx))
          || !isToken(str.substring(idx + 1)))
          return false;
      }

      //host
      str = st2.nextToken();
      if (!isHost(str) && !isToken(str))
        return false;

      //comment
      if (st2.hasMoreTokens())
      {
        str = st2.nextToken("");
        if (!isComment(str.trim()))
          return false;
      }
    }
    return true;
  }

  /**
   * Method isHost.
   * @param value
   * @return boolean
   */
  private static boolean isHost(String value)
  {

    try
    {
      new URL("http://" + value);
    }
    catch (MalformedURLException e)
    {
      return false;
    }
    return true;
  }

  /**
   * Method isValidAllow.
   * @param value
   * @return boolean
   */
  private static boolean isValidAllow(String value)
  {
    if (value.trim().length() == 0)
      return true;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      if (!isToken(str))
        return false;
    }
    return true;
  }

  /**
   * Method isValidContentRange.
   * @param value
   * @return boolean
   */
  private static boolean isValidContentRange(String value)
  {
    if (value.length() == 0)
      return false;
    if (!value.startsWith("bytes"))
      return false;
    String str = value.substring("bytes".length()).trim();

    int idx = str.indexOf("/");
    if (idx == -1)
      return false;

    String byteRange = str.substring(0, idx);
    int idx2 = byteRange.indexOf("-");
    if (idx2 == -1)
    {
      if (!byteRange.equals("*"))
        return false;
    }
    else
    {
      if (!isDidgit(byteRange.substring(0, idx2))
        || !isDidgit(byteRange.substring(idx2 + 1)))
        return false;
    }

    if (!isDidgit(str.substring(idx + 1))
      && !str.substring(idx + 1).equals("*"))
      return false;

    return true;
  }

  /**
   * Method isRange.
   * @param value
   * @return boolean
   */
  private static boolean isRange(String value)
  {
    if (value.length() == 0)
      return false;
    if (!value.startsWith("bytes="))
      return false;
    String strByteRange = value.substring("bytes=".length());

    StringTokenizer st = new StringTokenizer(strByteRange, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken();
      int idx = str.indexOf("-");
      if (idx == -1)
        return false;
      if (idx == 0)
      {
        if (!isDidgit(str.substring(1)))
          return false;
      }
      else
      {
        if (idx == (str.length() - 1))
        {
          if (!isDidgit(str.substring(0, str.length() - 1)))
            return false;
        }
        else
        {
          if (!isDidgit(str.substring(0, idx))
            || !isDidgit(str.substring(idx + 1)))
            return false;
        }

      }

    }
    return true;
  }

  /**
   * Method isValidTE.
   * @param value
   * @return boolean
   */
  private static boolean isValidTE(String value)
  {
    if (value.trim().length() == 0)
      return true;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      if (st.equals("trailers"))
        return true;

      int idx = str.indexOf(";");
      if (idx == -1)
      {
        if (!isLanguageRange(str))
          return false;
      }
      else
      {
        String _1 = str.substring(0, idx).trim();
        String _2 = str.substring(idx + 1).trim();
        if (!isLanguageRange(_1))
          return false;
        if (!isQAndQValue(_2))
          return false;
      }

    }

    return true;
  }

  /**
   * Method isValidUserAgent.
   * @param value
   * @return boolean
   */
  private static boolean isValidUserAgent(String value)
  {
    if (value.length() == 0)
      return false;
    StringTokenizer st = new StringTokenizer(value, " ");
    while (st.hasMoreElements())
    {
      String str = st.nextToken();
      if (!isProduct(str) && !isComment(str))
        return false;

    }

    return true;
  }

  /**
   * Method isComment.
   * @param str
   * @return boolean
   */
  private static boolean isComment(String str)
  {
    if (BasicRules.getLastComment(str, 0) != str.length())
      return false;
    return true;
  }

  /**
   * Method isValidAcceptLanguage.
   * @param value
   * @return boolean
   */
  private static boolean isValidAcceptLanguage(String value)
  {
    if (value.trim().length() == 0)
      return false;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      int idx = str.indexOf(";");
      if (idx == -1)
      {
        if (!isToken(str))
          return false;
      }
      else
      {
        String _1 = str.substring(0, idx).trim();
        String _2 = str.substring(idx + 1).trim();
        if (!isToken(_1))
          return false;
        if (!isAcceptParams(_2))
          return false;
      }

    }

    return true;
  }

  /**
   * Method isLanguageRange.
   * @param str
   * @return boolean
   */
  private static boolean isLanguageRange(String str)
  {
    if (str.trim().equals("*"))
      return true;
    StringTokenizer st = new StringTokenizer(str, "-");
    while (st.hasMoreElements())
    {
      if (!is8ALPHA(st.nextToken()))
        return false;
    }
    return true;
  }

  /**
   * Method isValidAcceptEncoding.
   * @param value
   * @return boolean
   */
  private static boolean isValidAcceptEncoding(String value)
  {
    if (value.trim().length() == 0)
      return false;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      int idx = str.indexOf(";");
      if (idx == -1)
      {
        if (!isToken(str) && !str.equals("*"))
          return false;
      }
      else
      {
        String _1 = str.substring(0, idx).trim();
        String _2 = str.substring(idx + 1).trim();

        if ((!isToken(_1) && !_1.equals("*")))
          return false;
        if (!isQAndQValue(_2))
          return false;
      }

    }

    return true;
  }

  /**
   * Method isValidAcceptCharSet.
   * @param value
   * @return boolean
   */
  private static boolean isValidAcceptCharSet(String value)
  {
    if (value.trim().length() == 0)
      return false;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      int idx = str.indexOf(";");
      if (idx == -1)
      {
        if (!isToken(str) && !str.equals("*"))
          return false;
      }
      else
      {
        String _1 = str.substring(0, idx).trim();
        String _2 = str.substring(idx + 1).trim();

        if ((!isToken(_1) && !_1.equals("*")))
          return false;
        if (!isQAndQValue(_2))
          return false;
      }

    }

    return true;
  }

  /**
   * Method isValidAccept.
   * @param value
   * @return boolean
   */
  private static boolean isValidAccept(String value)
  {
    if (value.trim().length() == 0)
      return true;

    StringTokenizer st = new StringTokenizer(value, ",");
    while (st.hasMoreElements())
    {
      String str = st.nextToken().trim();
      int idx = str.indexOf(";");
      if (idx == -1)
      {
        if (!isMediaRange(str))
          return false;
      }
      else
      {
        if (!isMediaRange(str.substring(0, idx).trim())
          || !isAcceptParams(str.substring(idx + 1).trim()))
          return false;

      }

    }
    return true;
  }

  /**
   * Method isAcceptParams.
   * @param string
   * @return boolean
   */
  private static boolean isAcceptParams(String string)
  {
    if (string.trim().length() == 0)
      return false;

    StringTokenizer st = new StringTokenizer(string, ";");
    String str = st.nextToken();

    int idx = str.indexOf("=");
    if (idx == -1)
    {
      if (str.equals("q") || !isToken(str))
        return false;
    }
    else
    {
      if (str.substring(0, idx).equals("q"))
      {
        if (!isQValue(str.substring(idx + 1)))
          return false;
      }
      else
      {
        if (!isParameterWithoutValue(str))
          return false;
      }
    }

    while (st.hasMoreElements())
    {
      str = st.nextToken();
      if (!isParameterWithoutValue(str))
        return false;
    }
    return true;
  }

  /**
   * Method isQAndQValue.
   * @param str
   * @return boolean
   */
  private static boolean isQAndQValue(String str)
  {
    str = str.trim();
    if (!str.trim().startsWith("q="))
      return false;
    if (!isQValue(str.substring("q=".length())))
      return false;
    return true;
  }

  /**
   * Method isQValue.
   * @param string
   * @return boolean
   */
  private static boolean isQValue(String string)
  {
    if (string.trim().length() == 0)
      return false;

    int idx = string.indexOf(".");
    if (idx == -1)
    {
      if (!"0".equals(string) && !"1".equals(string))
        return false;
    }
    else
    {
      String strDig = string.substring(idx + 1);
      if (strDig.length() > 3)
        return false;

      if (string.substring(0, idx).equals("0"))
      {
        if (!isDidgit(strDig))
          return false;

      }
      else
      {
        if (!string.substring(0, idx).equals("1"))
          return false;

        for (int i = 0; i < strDig.length(); i++)
        {
          if (strDig.charAt(i) != '0')
            return false;
        }
      }

    }
    return true;
  }

  /**
   * Method isMediaRange.
   * @param str
   * @return boolean
   */
  private static boolean isMediaRange(String str)
  {
    if (str.trim().length() == 0)
      return false;

    int idx = str.indexOf("/");
    if (idx == -1)
      return false;

    if (!isToken(str.substring(0, idx)) && !str.substring(0, idx).equals("*"))
      return false;
    if (!isToken(str.substring(idx + 1))
      && !str.substring(idx + 1).equals("*"))
      return false;

    return true;
  }

  /**
   * Method isEntityTag.
   * @param value
   * @return boolean
   */
  private static boolean isEntityTag(String value)
  {

    int idx = 0;
    if (value.startsWith("W/"))
      idx = 2;
    if (!isQuotedString(value.substring(idx)))
      return false;
    return true;
  }

  /**
   * Method isExpectation.
   * @param value
   * @return boolean
   */
  private static boolean isExpectation(String value)
  {
    if (value.equals("100-continue"))
      return true;

    StringTokenizer st = new StringTokenizer(value, ";");
    while (st.hasMoreElements())
    {
      if (!isParameterWithoutValue(st.nextToken()))
        return false;
    }

    return true;
  }

  /**
   * Method isCredentials.
   * @param value
   * @return boolean
   */
  private static boolean isCredentials(String value)
  {
    StringTokenizer st = new StringTokenizer(value, " ");
    if (!isToken(st.nextToken()))
      return false;

    while (st.hasMoreElements())
    {
      String param = st.nextToken(",");
      if (!isParameter(param))
        return false;
    }
    return true;
  }

  /**
   * Method isProduct.
   * @param value
   * @return boolean
   */
  private static boolean isProduct(String value)
  {
    int idx = value.indexOf("/");
    if (idx == -1)
    {
      if (!isToken(value))
        return false;
    }
    else
    {
      if (!isToken(value.substring(0, idx))
        || !isToken(value.substring(idx + 1)))
        return false;
    }
    return true;
  }

  /**
   * Method isTransferCoding.
   * @param value
   * @return boolean
   */
  private static boolean isTransferCoding(String value)
  {
    if (value.equals("chunked"))
    {
      return true;
    }
    else
    {
      StringTokenizer st = new StringTokenizer(value, ";");
      if (!isToken(st.nextToken()))
        return false;

      while (st.hasMoreElements())
      {
        if (!isParameter(st.nextToken()))
          return false;
      }

    }

    return true;
  }

  /**
   * Method isParameter.
   * @param string
   * @return boolean
   */
  private static boolean isParameter(String string)
  {

    // check parameter	
    int idx = string.indexOf("=");
    if (!isToken(string.substring(0, idx)))
      return false;

    String parValue = string.substring(idx + 1);
    if (!isToken(parValue) && !isQuotedString(parValue))
      return false;

    return true;
  }

  /**
   * Method isParameterWithoutValue.
   * @param string
   * @return boolean
   */
  private static boolean isParameterWithoutValue(String string)
  {

    // check parameter	
    int idx = string.indexOf("=");
    if (idx != -1)
    {
      if (!isToken(string.substring(0, idx)))
        return false;
      String parValue = string.substring(idx + 1);
      if (!isToken(parValue) && !isQuotedString(parValue))
        return false;

    }
    else
    {
      if (!isToken(string))
        return false;
    }

    return true;
  }

  /**
   * Method isPragmaDerective.
   * @param value
   * @return boolean
   */
  private static boolean isPragmaDerective(String value)
  {
    if (value.equals("no-cache"))
      return true;
    else
    {
      int idx = value.indexOf("=");
      if (idx == -1)
      {
        if (isToken(value))
          return true;
      }
      else
      {
        String str = value.substring(idx + 1);
        if (isToken(value.substring(0, idx))
          && (isToken(str) || isQuotedString(str)))
          return true;
      }
    }
    return true;
  }

  /**
   * Method isHTTPDate.
   * @param value
   * @return boolean
   */
  private static boolean isHTTPDate(String value)
  {

    String rfc1123_date = "EEE, dd MMM yyyy hh:mm:ss 'GMT'";
    String rfc850_date = "EEEE, dd-MMM-yy hh:mm:ss 'GMT'";
    String asctime_date = "EEE MMM d hh:mm:ss yyyy";

    try
    {
      SimpleDateFormat sdf = new SimpleDateFormat(rfc1123_date, Locale.US);
      if (sdf.parse(value) != null)
        return true;
    }
    catch (ParseException e)
    {
    }

    try
    {
      SimpleDateFormat sdf = new SimpleDateFormat(rfc850_date, Locale.US);
      if (sdf.parse(value) != null)
        return true;
    }
    catch (ParseException e)
    {
    }

    try
    {
      SimpleDateFormat sdf = new SimpleDateFormat(asctime_date, Locale.US);
      if (sdf.parse(value) != null)
        return true;
    }
    catch (ParseException e)
    {
    }

    return false;

  }

  /**
   * Method isURI.
   * @param value
   * @return boolean
   */
  private static boolean isURI(String value)
  {
    try
    {
      new URL(value);
    }
    catch (MalformedURLException e)
    {
      try
      {
        new URL("http://localhost" + value);
      }
      catch (MalformedURLException e2)
      {
        return false;
      }
    }

    return true;
  }

  /**
   * Method isLanguageTag.
   * @param value
   * @return boolean
   */
  private static boolean isLanguageTag(String value)
  {
    int idx = value.indexOf("-");
    if (idx == -1)
    {
      return is8ALPHA(value);
    }
    else
    {
      if (!is8ALPHA(value.substring(0, idx))
        || !is8ALPHA(value.substring(idx + 1)))
        return false;
      else
        return true;

    }
  }

  /**
   * Method is8ALPHA.
   * @param string
   * @return boolean
   */
  private static boolean is8ALPHA(String string)
  {
    if (string.length() > 8 || !isALPHA(string))
      return false;
    else
      return true;
  }

  /**
   * Method isALPHA.
   * @param string
   * @return boolean
   */
  private static boolean isALPHA(String string)
  {
    for (int i = 0; i < string.length(); i++)
    {
      if (!BasicRules.isCHAR(string.charAt(i)))
        return false;
    }

    return true;
  }

  /**
   * Method isDidgit.
   * @param value
   * @return boolean
   */
  private static boolean isDidgit(String value)
  {
    if (value.length() == 0)
      return false;
    char[] chs = value.toCharArray();
    for (int i = 0; i < chs.length; i++)
    {
      if (chs[i] < '0' || chs[i] > '9')
        return false;
    }

    return true;
  }

  /**
   * Method isMediaType.
   * @param value
   * @return boolean
   */
  private static boolean isMediaType(String value)
  {
    StringTokenizer st = new StringTokenizer(value, ";");
    String mediaType = st.nextToken();

    int idx = mediaType.indexOf("/");
    if (!isToken(mediaType.substring(0, idx))
      || !isToken(mediaType.substring(idx + 1)))
    {
      return false;
    }

    while (st.hasMoreElements())
    {
      if (!isParameter(st.nextToken(";").trim()))
        return false;
    }
    return true;
  }

  /**
   * Method isQuotedString.
   * @param parValue
   * @return boolean
   */
  private static boolean isQuotedString(String parValue)
  {
    if (BasicRules.getLastQuotedString(parValue, 0) != parValue.length())
    {
      return false;
    }
    return true;
  }

  /**
   * Method isToken.
   * @param value
   * @return boolean
   */
  private static boolean isToken(String value)
  {
    return BasicRules.isToken(value);
  }
}