package edu.mit.lcs;

import java.sql.*;
import javax.servlet.http.*;
import java.text.*;
import java.util.*;

/**
 * An Entity represents a set of property-value pairs derived from
 * either a ResultSet from a SQL query or from the parameters from an
 * HTTP form submission.  The values may be retrieved in a variety of
 * useful ways to make writing jsp code simpler.
 *
 * One complexity arises from the fact that in an HTTP request, it is
 * possible for a property to be associated with a number of different
 * values; for example, from the results of a <select multiple> form.
 * Therefore, we must allow such multiple values to be stored, and we
 * must establish a convention for how they are to be retrieved.
 */

public class Entity {
    HashMap singles;
    HashMap multiples;
    HashMap errors;

    public Entity() {
	singles = new HashMap();
	multiples = null;
    }

    /**
     * Create an Entity from a ResultSet.
     * The Entity stores every column value of the row from the
     * database under a key which is the ColumnName of that column.
     * Thus, all keys are Strings.  The value stored is as returned by
     * getString() from the ResultSet, and may thus is also a String.
     * Because HashTables cannot store null values, we store nulls as
     * the empty string.
     * 
     * There is one special treatment for Date values, which are
     * normally represented in SQL databases in the form
     * 'yyyy-mm-dd'.  If a column is recognized as being a date (from
     * the meta-data), then it is converted into the more usual
     * mm/dd/yy date format.
     */

    public Entity(ResultSet rs) {
	this();
	if (rs!=null) {
	    ResultSetMetaData rsmd;
	    try { 
		rsmd = rs.getMetaData();
		if (rsmd!=null) {
		    int ncols = rsmd.getColumnCount();
		    for (int i=1; i<=ncols; i++) {
			String key = rsmd.getColumnName(i);
			String val;
			if (rsmd.getColumnType(i)==Types.DATE) {
			    java.sql.Date d = rs.getDate(i);
			    if (d==null || rs.getString(i).equals("")) {
				val = "";
			    } else {
				val = dmyDateFormat.format(d);
			    }
			} else {
			    val = rs.getString(i);
			}
			singles.put(key, (val==null)? "" : val);
		    }
		}
	    }
	    catch (Exception e) {
		System.out.println("Error making Entity from ResultSet: " + e);
		if (errors==null) errors = new HashMap();
		errors.put("from ResultSet", e.toString());
	    }
	}
    }

    /**
     * Create an Entity from an HttpServletRequest.
     * The Entity stores every Parameter name and value as
     * retrieved by the request.  Both keys and values are Strings.
     */
    public Entity(HttpServletRequest rq) {
	this();
	Enumeration e = rq.getParameterNames();
	while (e.hasMoreElements()) {
	    String key = (String)e.nextElement();
	    String [] vals = rq.getParameterValues(key);
	    // String val = rq.getParameter(key).trim();
	    if (vals.length==0) {
		if (errors==null) errors = new HashMap();
		errors.put(key, e.toString());
	    } else if (vals.length==1) {
		singles.put(key,vals[0]);
	    } else {
		if (multiples==null) multiples = new HashMap();
		multiples.put(key,vals);
	    }
	}
    }


    /** Maps the specified key to the specified value.
     */

    public void put(Object key, Object val) {
	if (multiples!=null) multiples.remove(key);
	singles.put(key, val);
    }

    /**
     * get retrieves a value indicated by the String key.
     * If there are multiple values, the value retrieved is a
     * concatenation of the values, separated by commas.
     * We may return null only if there is no value associated with
     * key.
     */

    public String get(String key) {
	Object val = singles.get(key);
	if (val==null) return null;
	String [] vals = null;
	if (multiples!=null) vals = (String [])multiples.get(key);
	if (vals!=null) return concatenate(vals,",");
	return (String) val;
    }

    /**
     * getS is like get but always returns a non-null String;
     * namely, if get would return null, getS returns ""
     */

    public String getS(String key) {
	String val = get(key);
	return (val!=null) ? val : "";
    }

    /**
     * getH is like getS, but makes sure that any characters in the
     * String that might confuse an HTML interpreter are turned into
     * the proper HTML equivalent of the character.
     */
    public String getH(String item) {
	return HTMLEncode(getS(item));
    }

    /**
     * Utility function to concatenate strings with a separator.
     */

    public static String concatenate(String [] vals, String sep) {
	StringBuffer sb = new StringBuffer();
	for (int i = 0; i < vals.length; i++) {
	    if (i>0) sb.append(sep);
	    sb.append(vals[i]);
	}
	return sb.toString();
    }

    public static String concatenate(String [] vals) {
	return concatenate(vals, " ");
    }

    /**
     * getValues returns a String [] of values.  If there was only one
     * value, we create the array.
     */

    public String [] getValues(String key) {
	String [] vals = null;
	if (multiples!=null) vals = (String [])multiples.get(key);
	if (vals!=null) return vals;
	String val = (String)singles.get(key);
	if (val==null) return null;
	vals = new String[1];
	vals[0] = val;
	return vals;
    }	    

    /**
     * Converts an Entity to an HTML expression of a table that
     * presents the content of the Entity.
     */

    public String toHtml() {
	StringBuffer st = new StringBuffer();
	st.append("<table border=1>\n<tr><th>Key</th><th>Value(s)</th></tr>\n");
	Iterator e = singles.keySet().iterator();
	while (e.hasNext()) {
	    String key = (String)e.next();
	    String val = getS(key);
	    st.append("<tr><td>" + key + "</td><td>"
		      + val + "</td></tr>\n");
	}
	if (errors!=null) {
	    st.append("<tr><th>Key</th><th>Error</th></tr>");
	    Iterator e2 = errors.keySet().iterator();
	    while (e2.hasNext()) {
		String key = (String)e2.next();
		String val = getS(key);
		st.append("<tr><td>" + key + "</td><td>"
		      + val + "</td></tr>\n");
	    }
	}
	st.append("<table>\n");
	return st.toString();
    }

    /**
     * getSqlDate returns is like get, but returns a date suitable for
     * storing into a Sql database date field by parsing the String
     * stored under key in one of the forms 12/25/1975, Jan 1975, or
     * 1975.  First checks if it's already in the right format.
     */

    public String getSqlDate (String key) {
	String val = getS(key);
	if (val==null) return val;
	java.util.Date d = null;
	try {
	    d = sqlDateFormat.parse(val);
	} catch (ParseException e0) {
	    try {
		d = dmyDateFormat.parse(val);
	    } catch (ParseException e1) {
		try {
		    d = myDateFormat.parse(val);
		} catch (ParseException e2) {
		    try {
			d = yDateFormat.parse(val);
		    } catch (ParseException e3) {}
		}
	    }
	}
	if (d==null) return "";
	return new java.sql.Date(d.getTime()).toString();
    }

    public String getMdyDate (String key) {
	String val = getS(key);
	if (val==null) return val;
	java.util.Date d = null;
	try {
	    d = sqlDateFormat.parse(val);
	} catch (ParseException e0) {
	    try {
		d = dmyDateFormat.parse(val);
	    } catch (ParseException e1) {
		try {
		    d = myDateFormat.parse(val);
		} catch (ParseException e2) {
		    try {
			d = yDateFormat.parse(val);
		    } catch (ParseException e3) {}
		}
	    }
	}
	if (d==null) return "";
	return dmyDateFormat.format(new java.util.Date(d.getTime()));
    }


    /**
     * DateFormats for simple forms of dates we often find useful:
     * 12/25/1975, Sep. 1993, 1942, 1975-12-25.
     */

    public static final SimpleDateFormat dmyDateFormat
	= new SimpleDateFormat("MM/dd/yyyy");

    public static final SimpleDateFormat myDateFormat
	= new SimpleDateFormat("MMM yyyy");

    public static final SimpleDateFormat yDateFormat
	= new SimpleDateFormat("yyyy");

    public static final SimpleDateFormat sqlDateFormat
	= new SimpleDateFormat("yyyy-MM-dd");

    static {
	dmyDateFormat.setLenient(false);
	myDateFormat.setLenient(false);
	yDateFormat.setLenient(false);
	sqlDateFormat.setLenient(false);
    }
	    
    /**
     * Encodes characters that are interpreted specially by HTML into
     * their HTML equivalents.  < to &lt;, > to &gt;, etc.
     */

    public static String HTMLEncode(String s) {
	StringBuffer st = new StringBuffer();
	for (int i = 0; i < s.length(); i++) {
	    boolean copy = true;
	    char ch = s.charAt(i);
	    for (int j = 0; j < c.length ; j++) {
		if (c[j]==ch) {
		    st.append(expansion[j]);
		    copy = false;
		    break;
		}
	    }
	    if (copy) st.append(ch);
	}
	return st.toString();
    }

    private static final char c[] = { '<', '>', '&', '\"'};
    private static final String expansion[] = {"&lt;", "&gt;", "&amp;",
					       "&quot;"};

}