/*
    * Copyright (c) 2001 - 2005 ivata limited.
    * All rights reserved.
    * -----------------------------------------------------------------------------
    * ivata masks may be redistributed under the GNU General Public
    * License as published by the Free Software Foundation;
    * version 2 of the License.
    *
    * These programs are free software; you can redistribute them and/or
   * modify them under the terms of the GNU General Public License
   * as published by the Free Software Foundation; version 2 of the License.
   *
   * These programs are distributed in the hope that they will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   *
   * See the GNU General Public License in the file LICENSE.txt for more
   * details.
   *
   * If you would like a copy of the GNU General Public License write to
   *
   * Free Software Foundation, Inc.
   * 59 Temple Place - Suite 330
   * Boston, MA 02111-1307, USA.
   *
   *
   * To arrange commercial support and licensing, contact ivata at
   *                  http://www.ivata.com/contact.jsp
   * -----------------------------------------------------------------------------
   * $Log: ValueObjectFieldWriter.java,v $
   * Revision 1.8  2005/04/09 18:04:18  colinmacleod
   * Changed copyright text to GPL v2 explicitly.
   *
   * Revision 1.7  2005/01/19 12:50:34  colinmacleod
   * Added attribute delegate methods.
   *
   * Revision 1.6  2005/01/11 10:12:28  colinmacleod
   * Added workaround for when valuesParam is null.
   *
   * Revision 1.5  2005/01/07 08:08:23  colinmacleod
   * Moved up a version number.
   * Changed copyright notices to 2005.
   * Updated the documentation:
   *   - started working on multiproject:site docu.
   *   - changed the logo.
   * Added checkstyle and fixed LOADS of style issues.
   * Added separate thirdparty subproject.
   * Added struts (in web), util and webgui (in webtheme) from ivata op.
   *
   * Revision 1.4  2004/12/30 20:20:42  colinmacleod
   * Set style class if mandatory.
   *
   * Revision 1.3  2004/12/29 15:30:10  colinmacleod
   * Added asserts to check parameters are not null.
   *
   * Revision 1.2  2004/12/23 21:28:31  colinmacleod
   * Modifications to add ivata op compatibility.
   *
   * Revision 1.1  2004/11/11 13:41:08  colinmacleod
   * First version in CVS. Added to display value object contents.
   *
   * Revision 1.1.1.1  2004/05/16 20:40:32  colinmacleod
   * Ready for 0.1 release
   * -----------------------------------------------------------------------------
   */
  package com.ivata.mask.web.field.valueobject;
  import com.ivata.mask.Mask;
  import com.ivata.mask.field.Field;
  import com.ivata.mask.util.StringHandling;
  import com.ivata.mask.valueobject.ValueObject;
  import com.ivata.mask.web.field.AttributesWriter;
  import com.ivata.mask.web.field.FieldWriter;
  import com.ivata.mask.web.format.HTMLFormatter;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.struts.taglib.TagUtils;
  import org.dom4j.Document;
  import org.dom4j.DocumentFactory;
  import org.dom4j.Element;
  import java.lang.reflect.InvocationTargetException;
  import java.net.MalformedURLException;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Vector;
  import javax.servlet.jsp.PageContext;
  /***
   * <p>
   * This writer is used to display links to other value objects.
   * </p>
   *
   * @since ivata masks 0.2 (2004-05-14)
   * @author Colin MacLeod
   * <a href='mailto:colin.macleod@ivata.com'>colin.macleod@ivata.com</a>
   * @version $Revision: 1.8 $
   */
  public class ValueObjectFieldWriter implements FieldWriter {
      /***
      * <p>
      * This is the style class used for combo (single choice) lists.
      * </p>
      */
     public static final String CSS_COMBO = "combo";
     /***
      * <p>
      * This is the style class used for multiple choice lists.
      * </p>
      */
     public static final String CSS_LIST = "list";
     /***
      * <p>
      * This is the value which is output as a default. TODO: i18n
      * </p>
      */
     public static final String DEFAULT_DISPLAY_VALUE = "[None]";
     /***
      * <p>
      * This is the value which is output as a default. TODO: i18n
      * </p>
      */
     public static final String DEFAULT_VALUE = "";
     /***
      * <p>
      * This is the value which is output as a new entry. TODO: i18n
      * </p>
      */
     public static final String NEW_DISPLAY_VALUE = "[New]";
     /***
      * <p>
      * Local page of the action to which we'll link, for a read-only field.
      * </p>
      */
     private String actionPage;
     /***
      * Refer to {@link #getAllValueObjects}.
      */
     private Collection allValueObjects;
     /***
      * <p>
      * Stores all of the field's attributes and values, then writes them out
      * later.
      * </p>
      */
     private AttributesWriter attributesWriter;
     /***
      * <p>
      * Field to be displayed.
      * </p>
      */
     private Field field;
     /***
      * <p>
      * Used to format the returned text.
      * </p>
      */
     private HTMLFormatter formatter;
     /***
      * <p>
      * Stores all of the hidden field's attributes and values, then writes them
      * out later. This is used for a sublist.
      * </p>
      */
     private AttributesWriter hiddenAttributesWriter;
     /***
      * <p>
      * Construct a field writer.
      * </p>
      *
      * @param fieldParam
      *            defines the field to be displayed.
      * @param actionPageParam
      *            Refer to {@link DefaultFieldWriter#getActionPage}.
      * @param allValueObjectsParam
      *            Refer to {@link #getAllValueObjects}.
      * @param formatterParam
      *            Refer to {@link #getFormatter}.
      * @param listHeightParam
      *            set as the size attribute in the field.
      * @param multipleParam
      *            if <code>true</code>, then the user can make more than one
      *            selection.
      */
     public ValueObjectFieldWriter(final Field fieldParam,
             final String actionPageParam,
             final Collection allValueObjectsParam,
             final HTMLFormatter formatterParam, final int listHeightParam,
             final boolean multipleParam) {
         super();
         this.field = fieldParam;
         this.actionPage = actionPageParam;
         this.allValueObjects = allValueObjectsParam;
         this.formatter = formatterParam;
         boolean multiple = multipleParam;
         // we don't want to actually submit the values in a sublist
         String propertyNameSuffix;
         if (isSublist()) {
             propertyNameSuffix = "_sublist";
             // sublists can be multi-choice
             multiple = false;
         } else {
             propertyNameSuffix = "";
         }
         attributesWriter = new AttributesWriter(fieldParam, propertyNameSuffix);
         attributesWriter
                 .setAttribute("size", Integer.toString(listHeightParam));
         if (fieldParam.isMandatory()) {
             attributesWriter.appendAttribute("class", "mandatory");
         }
         if (multiple) {
             attributesWriter.setAttribute("multiple", "multiple");
             // if the field type wasn't set explicitly, set the class here
             if (StringHandling.isNullOrEmpty(fieldParam.getType())) {
                 attributesWriter.appendAttribute("class", CSS_LIST);
             }
         } else {
             attributesWriter.remove("multiple");
             // if the field type wasn't set explicitly, set the class here
             if (StringHandling.isNullOrEmpty(fieldParam.getType())) {
                 attributesWriter.appendAttribute("class", CSS_COMBO);
             }
         }
     }
     /***
      * All possible value objects to display in a list - for a choice. The user
      * will be given the chance to choose from only these values.
      *
      * @return Returns the all value objects as a <code>Collection</code> of
      *         <code>ValueObject</code> instances.
      */
     protected final Collection getAllValueObjects() {
         return allValueObjects;
     }
     /***
      * <p>
      * Access the attributes writer, which is responsible for converting the
      * field attributes into text.
      * </p>
      *
      * @return attributes writer.
      */
     protected final AttributesWriter getAttributesWriter() {
         return attributesWriter;
     }
     /***
      * <p>
      * Access the field to be displayed.
      * </p>
      *
      * @return field to be displayed.
      */
     protected final Field getField() {
         return field;
     }
     /***
      * Used to format the displayed, usually ensuring line breaks are converted
      * into HTML.
      *
      * @return Returns the formatter.
      */
     protected final HTMLFormatter getFormatter() {
         return formatter;
     }
     /***
      * <p>
      * Find out whether or not this field represents a sublist.
      * </p>
      *
      * @return <code>true</code> if this is a sublist.
      */
     private boolean isSublist() {
         return "sublist".equals(field.getType());
     }
     /***
      * Refer to {@link FieldWriter#clearAttribute}.
      *
      * @param name Refer to {@link FieldWriter#clearAttribute}.
      */
     public void removeAttribute(final String name) {
         attributesWriter.remove(name);
     }
     /***
      * Refer to {@link FieldWriter#setAttribute}.
      *
      * @param name Refer to {@link FieldWriter#setAttribute}.
      * @param value Refer to {@link FieldWriter#setAttribute}.
      */
     public void setAttribute(final String name, final String value) {
         attributesWriter.setAttribute(name, value);
     }
     /***
      * Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      *
      * @param pageContextParam
      *            Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      * @param valueObjectParam
      *            Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      * @param displayOnlyParam
      *            Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      * @return Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      */
     public final String write(final PageContext pageContextParam,
             final ValueObject valueObjectParam,
             final boolean displayOnlyParam) {
         assert (pageContextParam != null);
         assert (valueObjectParam != null);
         Collection values;
         Object object;
         try {
             object = PropertyUtils.getProperty(valueObjectParam, field
                     .getPath());
             // this lets us handle both collections and individual value objects
             // in the same way
             if (object != null) {
                 if (object instanceof ValueObject) {
                     values = new Vector();
                     values.add(object);
                 } else {
                     // it must be a collection (will throw class cast exception
                     // if you tried to assign something else)
                     values = (Collection) object;
                 }
             } else {
                 values = null;
             }
         } catch (IllegalAccessException e) {
             throw new RuntimeException("ERROR (" + e.getClass().getName()
                     + ") in ValueObjectFieldWriter: " + e.getMessage());
         } catch (InvocationTargetException e) {
             throw new RuntimeException("ERROR (" + e.getClass().getName()
                     + ") in ValueObjectFieldWriter: " + e.getMessage());
         } catch (NoSuchMethodException e) {
             // if there is no matching method, just set all values to null
             values = null;
         }
         if (displayOnlyParam) {
             return writeDisplayOnly(pageContextParam, values);
         } else {
             return writeChoiceField(pageContextParam, values);
         }
     }
     /***
      * Display a field (which is not read-only).
      *
      * @param pageContextParam
      *            Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      * @param valuesParam
      *            contains all the possible values as strings.
      * @return string representing the combo box.
      */
     public final String writeChoiceField(final PageContext pageContextParam,
             final Collection valuesParam) {
         List values = new Vector();
         if (valuesParam != null) {
             values.addAll(valuesParam);
         }
         // if there is nothing to display, display, well, nothing...
         if (allValueObjects.size() == 0) {
             return DEFAULT_DISPLAY_VALUE;
         }
         // if no current values are specified, match the default value
         if (values == null) {
             values = new Vector();
             values.add(DEFAULT_VALUE);
         }
         // clear the value attribute if there is no value
         String stringValue;
         StringBuffer buffer = new StringBuffer();
         // if this is a sublist, we actually store the entries to submit in XML
         // in a hidden field
         Iterator allValueIterator;
         if (isSublist()) {
             writeHiddenContents(buffer, field, values);
             // sublists call JavaScript to do their funky stuff
             String onChangeSublist = "onChangeSublist(\""
                     + hiddenAttributesWriter.getAttribute("id")
                     + "\");return true";
             attributesWriter.setAttribute("onchange", onChangeSublist);
             // for a sublist, we only show the values in this list - not all
             // possible values
             allValueIterator = values.iterator();
         } else {
             // for all other choices, we show all possible values so you can
             // choose one or more
             allValueIterator = allValueObjects.iterator();
         }
         buffer.append("<select");
         buffer.append(attributesWriter.toString());
         buffer.append(">");
         // if this is not a mandatory field, show the default value
         if (!isSublist() && !field.isMandatory()) {
             buffer.append("\n<option value='");
             buffer.append(DEFAULT_VALUE);
             buffer.append("'>");
             buffer.append(DEFAULT_DISPLAY_VALUE);
             buffer.append("</option>");
         }
         while (allValueIterator.hasNext()) {
             ValueObject thisObject = (ValueObject) allValueIterator.next();
             buffer.append("\n<option value='");
             buffer.append(thisObject.getIdString());
             // check all chosen values against this value
             Iterator valueIterator = values.iterator();
             while (valueIterator.hasNext()) {
                 Object value = valueIterator.next();
                 String idString;
                 if (value instanceof String) {
                     idString = (String) value;
                 } else {
                     idString = ((ValueObject) value).getIdString();
                 }
                 // only put out selections if this is not a sublist field
                 if (idString.equals(thisObject.getIdString()) && !isSublist()) {
                     buffer.append("' selected='selected");
                     break;
                 }
             }
             String displayValue;
             // sublist displays the field values themselves - this is easier to
             // replicate in the JavaScript (than the getDisplayValue method)
             if (isSublist()) {
                 Mask mask = field.getValueObjectMask();
                 Iterator fieldsIterator = mask.getFields().iterator();
                 StringBuffer displayValueBuffer = new StringBuffer();
                 while (fieldsIterator.hasNext()) {
                     if (displayValueBuffer.length() > 0) {
                         displayValueBuffer.append(" ");
                     }
                     Field subField = (Field) fieldsIterator.next();
                     String subDisplayValue;
                     Object subObject;
                     try {
                         subObject = PropertyUtils.getProperty(thisObject,
                                 subField.getName());
                     } catch (IllegalAccessException e) {
                         throw new RuntimeException(e);
                     } catch (InvocationTargetException e) {
                         throw new RuntimeException(e);
                     } catch (NoSuchMethodException e) {
                         throw new RuntimeException(e);
                     }
                     if (subObject == null) {
                         subDisplayValue = DEFAULT_DISPLAY_VALUE;
                     } else if (subObject instanceof ValueObject) {
                         subDisplayValue = ((ValueObject) subObject)
                                 .getDisplayValue();
                     } else {
                         subDisplayValue = subObject.toString();
                     }
                     displayValueBuffer.append(subDisplayValue);
                 }
                 displayValue = displayValueBuffer.toString();
             } else {
                 displayValue = thisObject.getDisplayValue();
             }
             buffer.append("'>");
             buffer.append(formatter.format(displayValue));
             buffer.append("</option>");
         }
         // if this is a sublist append a 'new' option
         if (isSublist()) {
             buffer.append("\n<option value='");
             buffer.append(DEFAULT_VALUE);
             buffer.append("' selected='selected'>");
             buffer.append(NEW_DISPLAY_VALUE);
             buffer.append("</option>");
         }
         buffer.append("</select>");
         stringValue = buffer.toString();
         return stringValue;
     }
     /***
      * Display the correct field value from the value object - for a read-only
      * field.
      *
      * @param pageContextParam
      *            Refer to {@link com.ivata.mask.web.field.FieldWriter#write}.
      * @param valuesParam
      *            Refer to {@link #writeChoiceField}.
      * @return Refer to {@link #writeChoiceField}.
      * @see com.ivata.mask.web.field.FieldWriter#write
      */
     public final String writeDisplayOnly(final PageContext pageContextParam,
             final Collection valuesParam) {
         // if there are no values, display nothing!
         if (valuesParam == null) {
             return "";
         }
         Iterator valueIterator = valuesParam.iterator();
         StringBuffer buffer = new StringBuffer();
         String type = field.getType();
         while (valueIterator.hasNext()) {
             ValueObject valueObject = (ValueObject) valueIterator.next();
             // clear the value attribute if there is no value
             String stringValue = valueObject.getDisplayValue();
             attributesWriter.setAttribute("value", stringValue);
             // don't link sublists - they are input on the mask for the
             // containing do directly
             if (!"sublist".equals(type)) {
                 buffer.append("<a href='");
                 try {
                     Map params = new HashMap();
                     params.put("baseClass", valueObject.getClass().getName());
                     params.put("idString", valueObject.getIdString());
                     params.put("displayOnly", "true");
                     String uRL = TagUtils.getInstance().computeURL(
                             pageContextParam, null, null, actionPage, null,
                             null, params, null, false);
                     buffer.append(uRL);
                 } catch (MalformedURLException e) {
                     throw new RuntimeException("ERROR ("
                             + e.getClass().getName()
                             + ") in ValueObjectFieldWriter: " + e.getMessage());
                 }
                 buffer.append("'>");
             }
             buffer.append(valueObject.getDisplayValue());
             if (!"sublist".equals(type)) {
                 buffer.append("</a>");
             }
             // if there are more elements after this one, put them on the next
             // line
             if (valueIterator.hasNext()) {
                 buffer.append("<br/>\n");
             }
         }
         return buffer.toString();
     }
     /***
      * <p>
      * If this is a sublist, we actually store the entries to submit in XML in a
      * hidden field. This method generates that hidden field into the string
      * buffer provided.
      * </p>
      *
      * @param bufferParam
      *            String buffer into which we will write the results.
      * @param fieldParam
      *            Field to be written out.
      * @param valuesParam
      *            Refer to {@link #writeChoiceField}.
      */
     private void writeHiddenContents(final StringBuffer bufferParam,
             final Field fieldParam, final Collection valuesParam) {
         Document document = DocumentFactory.getInstance().createDocument();
         Element rootElement = document.addElement("sublist");
         Mask mask = fieldParam.getValueObjectMask();
         // go through all the values and output them
         Iterator valueIterator = valuesParam.iterator();
         while (valueIterator.hasNext()) {
             ValueObject valueObject = (ValueObject) valueIterator.next();
             Element dOElement = rootElement.addElement("valueObject");
             dOElement.addAttribute("id", valueObject.getIdString());
             // now output all fields of this value object
             Iterator fieldIterator = mask.getFields().iterator();
             while (fieldIterator.hasNext()) {
                 Field subField = (Field) fieldIterator.next();
                 Element fieldElement = dOElement.addElement("field");
                 fieldElement.addAttribute("id", subField.getName());
                 Object value;
                 try {
                     value = PropertyUtils.getProperty(valueObject, subField
                             .getName());
                 } catch (IllegalAccessException e) {
                     throw new RuntimeException("ERROR ("
                             + e.getClass().getName()
                             + ") in ValueObjectFieldWriter: " + e.getMessage(),
                             e);
                 } catch (InvocationTargetException e) {
                     throw new RuntimeException("ERROR ("
                             + e.getClass().getName()
                             + ") in ValueObjectFieldWriter: " + e.getMessage(),
                             e);
                 } catch (NoSuchMethodException e) {
                     throw new RuntimeException("ERROR ("
                             + e.getClass().getName()
                             + ") in ValueObjectFieldWriter: " + e.getMessage(),
                             e);
                 }
                 if (value != null) {
                     // if it is a value object, then set the value to the id
                     if (value instanceof ValueObject) {
                         fieldElement.setText(((ValueObject) value)
                                 .getIdString());
                     } else {
                         // otherwise use the string value
                         fieldElement.setText(value.toString());
                     }
                 }
             }
         }
         // finally add empty ones with no id - this ensures we always have the
         // field names
         Iterator fieldIterator = mask.getFields().iterator();
         Element dOElement = rootElement.addElement("valueObject");
         dOElement.addAttribute("schema", "true");
         while (fieldIterator.hasNext()) {
             Field subField = (Field) fieldIterator.next();
             Element fieldElement = dOElement.addElement("field");
             fieldElement.addAttribute("id", subField.getName());
             fieldElement.setText("");
         }
         // now output all fields of this value object
         hiddenAttributesWriter = new AttributesWriter(fieldParam);
         hiddenAttributesWriter.setAttribute("type", "hidden");
         hiddenAttributesWriter.setAttribute("value", document.asXML());
         bufferParam.append("<input");
         bufferParam.append(hiddenAttributesWriter.toString());
         bufferParam.append("/>");
         // id field holds the value of the value object id
         AttributesWriter idAttributesWriter = new AttributesWriter(fieldParam,
                 "_id");
         idAttributesWriter.setAttribute("type", "hidden");
         bufferParam.append("<input");
         bufferParam.append(idAttributesWriter.toString());
         bufferParam.append("/>");
         // index field holds the index of the item within the select
         AttributesWriter indexAttributesWriter = new AttributesWriter(
                 fieldParam, "_index");
         indexAttributesWriter.setAttribute("type", "hidden");
         bufferParam.append("<input");
         bufferParam.append(indexAttributesWriter.toString());
         bufferParam.append("/>");
     }
 }