package ca.bc.webarts.tools;

import java.net.*;
import javax.net.ssl.HttpsURLConnection;
import java.io.*;
import java.util.*;
import java.text.*;

/**
 * MyCookieHandler is a simple utilty for handling cookies when working
 * with java.net.URL and java.net.URLConnection
 * objects.<br>
 *
 * It provides all the details of the calls to set and get the cookies...
 *<pre>
 *     MyCookieHandler cm = new MyCookieHandler();
 *     URL url = new URL("http://www.hccp.org/test/cookieTest.jsp");
 *
 *      . . .
 *
 *     // getting cookies:
 *     URLConnection conn = url.openConnection();
 *     conn.connect();
 *
 *     // setting cookies
 *     cm.storeCookies(conn);
 *     cm.setCookies(url.openConnection());
 *
 *</pre>
 *  <u><b>MyCookieHandler abstracts all the following java api code...</b></u>
 *  <h1>HOW-TO: Handling cookies using the java.net.* API</h1>
 *  <h3>Author: <i>Ian Brown <a href="mailto:spam@hccp.org">spam@hccp.org</a></i></h3>
 *  <p>
 *  This is a brief overview on how to retrieve cookies from HTTP responses and how to return cookies in HTTP requests to the appropriate server using the <b>java.net.*</b> APIs.
 *  <br>
 *  <b><ul>
 *  <li><a href="#what_are_cookies">What are cookies?</a></li>
 *  <li><a href="#retrieving_cookies">Retrieving cookies from a response.</a></li>
 *  <li><a href="#setting_values">Setting a cookie value in a request.</a></li>
 *  <li><a href="#setting_multiple">Setting <i>multiple</i> cookie values in a request.</a></li>
 *  <li><a href="#sample_code">Sample code.</a></li>
 *  </ul>
 *  </b>
 *  <p>
 *  <a name="what_are_cookies"/><h2>What are cookies?</h2>Cookies are small strings of data of the form  <i>name</i>=<i>value</i>. These are delivered to the client via the header variables in an HTTP response. Upon recieving a cookie from a web server, the client application should store that cookie, returning it to the server in subsequent requests. For greater detail see the Netscape specification: <a href="http://web.archive.org/web/20101114022703/http://wp.netscape.com/newsref/std/cookie_spec.html">http://wp.netscape.com/newsref/std/cookie_spec.html</a></p>
 *
 *  <p>
 *  <a name="retrieving_cookies"/><h2>Retrieving cookies from a response:</h2>
 *  <ol>
 *  <li><b>Open a <i>java.net.URLConnection</i> to the server:</b><br>
 *  <pre>
 *  URL myUrl = new URL("http://www.hccp.org/cookieTest.jsp");
 *  URLConnection urlConn = myUrl.openConnection();
 *  urlConn.connect();
 *  </pre>
 *  </li>
 *  <li><b>Loop through response headers looking for cookies:</b><br>
 *  <p>Since a server may set multiple cookies in a single request, we will need to loop through the response headers, looking for all headers named "Set-Cookie".</p>
 *  <pre>
 *  String headerName=null;
 *  for (int i=1; (headerName = uc.getHeaderFieldKey(i))!=null; i++) {
 *    if (headerName.equals("Set-Cookie")) {
 *    String cookie = urlConn.getHeaderField(i);
 *    ...
 *
 *  </pre>
 *  </li>
 *  <li><b>Extract cookie name and value from cookie string:</b><br>
 *  <p>The string returned by the <b>getHeaderField(int index)</b> method is a series of <i>name=value</i> separated by semi-colons (;). The first name/value pairing is actual data string we are interested in (<i>i.e. "sessionId=0949eeee22222rtg" or "userId=igbrown"</i>), the subsequent name/value pairings are meta-information that we would use to manage the storage of the cookie (<i>when it expires, etc.</i>).</p>
 *  <pre>
 *          cookie = cookie.substring(0, cookie.indexOf(";"));
 *          String cookieName = cookie.substring(0, cookie.indexOf("="));
 *          String cookieValue = cookie.substring(cookie.indexOf("=") + 1, cookie.length());
 *
 *  </pre>
 *  This is basically it. We now have the cookie name (<i>cookieName</i>) and the cookie value (<i>cookieValue</i>).
 *  </li>
 *
 *  </ol>
 *  </p>
 *  <p>
 *  <a name="setting_values"/><h2>Setting a cookie value in a request:</h2>
 *  <ol>
 *  <li><b>Values must be set prior to calling the connect method:</b><br>
 *  <pre>
 *  URL myUrl = new URL("http://www.hccp.org/cookieTest.jsp");
 *  URLConnection urlConn = myUrl.openConnection();
 *  </pre>
 *  </li>
 *  <li><b>Create a cookie string:</b><br>
 *  <pre>
 *  String myCookie = "userId=igbrown";
 *  </pre>
 *  </li>
 *  <li><b>Add the cookie to  a request:</b><br>
 *  <p>Using the <i>setRequestProperty(String name, String value);</i> method, we will add a property named "Cookie", passing the cookie string created in the previous step as the property value.
 *  <pre>
 *  urlConn.setRequestProperty("Cookie", myCookie);
 *  </pre>
 *  </p>
 *  </li>
 *  <li><b>Send the cookie to the server:</b><br>
 *  <p>To send the cookie, simply call connect() on the URLConnection for which we have added the cookie property:
 *  <pre>urlConn.connect()</pre>
 *  </p>
 *  </li>
 *  </ol>
 *  </p>
 *  <p>
 *  <a name="setting_multiple"/><h2>Setting a <i>multiple</i> cookie values in a request:</h2>
 *  <ol>
 *  <li>Perform the same steps as the above item (<i>Setting a a cookie value in a request</i>), replacing the single valued cookie string with something like the following:
 *  <pre>
 *  String myCookies = "userId=igbrown; sessionId=SID77689211949; isAuthenticated=true";
 *  </pre>
 *  This string contains three cookies (<i>userId</i>, <i>sessionId</i>, and <i>isAuthenticated</i>). Separate cookie name/value pairs with <i>"; "</i> (semicolon and whitespace).<br><br>
 *  Note that you cannot set multiple request properties using the same name, so trying to call the setRequestProperty("Cookie" , someCookieValue) method will just overwrite any previously set value.
 *  </li>
 *  </ol>
 *  </p>
 *  <p>
 *  <a name="sample_code"/><h2>Sample Code:</h2>
 *
 *  <table cellpadding=3 bgcolor="000000>
 *  <tr">
 *  <td bgcolor="eeeeee">
 *  <table width="100%"><tr><td><tt><b>MyCookieHandler.java</b></tt></td><td align="right"><tt>Download this example at <a href="http://www.hccp.org/cvs/org/hccp/net/MyCookieHandler.java">http://www.hccp.org/cvs/org/hccp/net/MyCookieHandler.java</a></tt></td></tr></table>
 *  </td>
 *  </tr>
 *  <tr>
 *  <td bgcolor="eeeeee">
 *   code goes here...
 *  </td>
 *  </tr>
 *  </table>
 *  </p>
 *
 *     @author Ian Brown
 **/

public class MyCookieHandler
{

  private Map<String, Map> store;

  private static final String SET_COOKIE = "Set-Cookie";
  private static final String COOKIE_VALUE_DELIMITER = ";";
  private static final String PATH = "path";
  private static final String EXPIRES = "expires";
  private static final String DATE_FORMAT = "EEE, dd-MMM-yyyy hh:mm:ss z";
  private static final String SET_COOKIE_SEPARATOR="; ";
  private static final String COOKIE = "Cookie";

  private static final char NAME_VALUE_SEPARATOR = '=';
  private static final char DOT = '.';

  private DateFormat dateFormat;


  /** Defaulkt Constructor. **/
  public MyCookieHandler()
  {
    store = new HashMap<String, Map>();
    dateFormat = new SimpleDateFormat(DATE_FORMAT);
  }

/*
  public void storeCookies(HttpsURLConnection conn) throws IOException
  {
    storeCookies((java.net.URLConnection) conn);
  }


  public void storeCookies(HttpURLConnection conn) throws IOException
  {
    storeCookies((java.net.URLConnection) conn);
  }
*/

  /**
   * Retrieves and stores cookies returned by the host on the other side
   * of the the open java.net.URLConnection.
   *
   * The connection MUST have been opened using the connect()
   * method or a IOException will be thrown.
   *
   * @param conn a java.net.URLConnection - must be open, or IOException will be thrown
   * @throws java.io.IOException Thrown if conn is not open.
   */
  public void storeCookies(java.net.URLConnection conn) throws IOException
  {

    // let's determine the domain from where these cookies are being sent
    String domain = getDomainFromHost(conn.getURL().getHost());

    Map domainStore; // this is where we will store cookies for this domain

    // now let's check the store to see if we have an entry for this domain
    if (store.containsKey(domain))
    {
        // we do, so lets retrieve it from the store
        domainStore = (Map)store.get(domain);
    }
    else
    {
        // we don't, so let's create it and put it in the store
        domainStore = new HashMap<String, Map<String, String> >();
        store.put(domain, domainStore);
    }
    // OK, now we are ready to get the cookies out of the URLConnection

    String headerName=null;
    for (int i=1; (headerName = conn.getHeaderFieldKey(i)) != null; i++)
    {
      if (headerName.equalsIgnoreCase(SET_COOKIE))
      {
        Map<String, String> cookie = new HashMap<String, String>();
        StringTokenizer st = new StringTokenizer(conn.getHeaderField(i), COOKIE_VALUE_DELIMITER);

        // the specification dictates that the first name/value pair
        // in the string is the cookie name and value, so let's handle
        // them as a special case:
        if (st.hasMoreTokens())
        {
            String token  = st.nextToken();
            String name = token.substring(0, token.indexOf(NAME_VALUE_SEPARATOR));
            String value = token.substring(token.indexOf(NAME_VALUE_SEPARATOR) + 1, token.length());
            cookie.put(name, value);
            domainStore.put(name, cookie);
        }

        while (st.hasMoreTokens())
        {
            String token  = st.nextToken();
            cookie.put(token.substring(0, token.indexOf(NAME_VALUE_SEPARATOR)).toLowerCase(),
                       token.substring(token.indexOf(NAME_VALUE_SEPARATOR) + 1, token.length()));
        }
      }
    }
  }


  /**
   * Prior to opening a URLConnection, calling this method will set all
   * unexpired cookies that match the path or subpaths for thi underlying URL
   *
   * The connection MUST NOT have been opened
   * method or an IOException will be thrown.
   *
   * @param conn a java.net.URLConnection - must NOT be open, or IOException will be thrown
   * @throws java.io.IOException Thrown if conn has already been opened.
   */
  public void setCookies(URLConnection conn) throws IOException
  {

    // let's determine the domain and path to retrieve the appropriate cookies
    URL url = conn.getURL();
    String domain = getDomainFromHost(url.getHost());
    String path = url.getPath();

    Map domainStore = (Map)store.get(domain);
    if (domainStore == null) return;
    StringBuffer cookieStringBuffer = new StringBuffer();

    Iterator cookieNames = domainStore.keySet().iterator();
    while(cookieNames.hasNext())
    {
      String cookieName = (String)cookieNames.next();
      Map cookie = (Map)domainStore.get(cookieName);
      // check cookie to ensure path matches  and cookie is not expired
      // if all is cool, add cookie to header string
      if (comparePaths((String)cookie.get(PATH), path) && isNotExpired((String)cookie.get(EXPIRES)))
      {
        cookieStringBuffer.append(cookieName);
        cookieStringBuffer.append("=");
        cookieStringBuffer.append((String)cookie.get(cookieName));
        if (cookieNames.hasNext()) cookieStringBuffer.append(SET_COOKIE_SEPARATOR);
      }
    }
    try
    {
        conn.setRequestProperty(COOKIE, cookieStringBuffer.toString());
    }
    catch (java.lang.IllegalStateException ise)
    {
        IOException ioe = new IOException("Illegal State! Cookies cannot be set on a URLConnection that is already connected. "
        + "Only call setCookies(java.net.URLConnection) AFTER calling java.net.URLConnection.connect().");
        throw ioe;
    }
  }


  private String getDomainFromHost(String host)
  {
    if (host.indexOf(DOT) != host.lastIndexOf(DOT))
    {
        return host.substring(host.indexOf(DOT) + 1);
    }
    else
    {
        return host;
    }
  }


  private boolean isNotExpired(String cookieExpires)
  {
    if (cookieExpires == null) return true;
    Date now = new Date();
    try
    {
        return (now.compareTo(dateFormat.parse(cookieExpires))) <= 0;
    }
    catch (java.text.ParseException pe)
    {
        pe.printStackTrace();
        return false;
    }
  }


  private boolean comparePaths(String cookiePath, String targetPath)
  {
    if (cookiePath == null)
    {
        return true;
    }
    else if (cookiePath.equals("/"))
    {
        return true;
    }
    else if (targetPath.regionMatches(0, cookiePath, 0, cookiePath.length()))
    {
        return true;
    }
    else {
        return false;
    }
  }


  /**
   * Returns a string representation of stored cookies organized by domain.
   */

  public String toString()
  {
    return store.toString();
  }


  public static void main(String[] args)
  {
    MyCookieHandler cm = new MyCookieHandler();
    try {
        URL url = new URL("http://www.hccp.org/test/cookieTest.jsp");
        URLConnection conn = url.openConnection();
        conn.connect();
        cm.storeCookies(conn);
        System.out.println(cm);
        cm.setCookies(url.openConnection());
    }
    catch (IOException ioe)
    {
        ioe.printStackTrace();
    }
  }
}