/*
 * Created on Mar 9, 2003
 *
 * To change this generated comment go to 
 * Window>Preferences>Java>Code Generation>Code Template
 */
package context.arch.enactor;

import java.util.ArrayList;
import java.util.List;

import context.arch.storage.Attributes;

/**
 * Defines a parameter for a rule. A parameter has a name, optional description, and
 * a value or set of values. Each parameter value in a set of values will be bound
 * by the enactor with a set of attributes depending upon current widget values.
 * 
 * For instance, a parameter signifying a movement level after which to turn on room lights
 * may have an attribute that specifies room name. The parameter can then maintain a set of 
 * movement level values scoped to that room name attribute.
 * 
 * Currently, parameters or enactors do no management of multiple values themselves, but
 * applications can maintain various sets of attributes and let listeners know about them.
 * This may change in the future with increased system support for parameter sets.
 * 
 * @author newbergr
 */
public class EnactorParameter {
	
	protected Enactor enactor;
	protected String description;
	protected String name;
	protected Attributes attsTemplate;
//	protected ArrayList values = new ArrayList(); // this is terrible and should have been a type safe Map or Hashtable instead of a List of Object pairs --Brian
//	protected Map<Attributes, Object> values = new LinkedHashMap<Attributes, Object>(); // preserves insertion order ; // actually, this is inconvenient to obtain by index too --Brian
	protected List<Attributes> attributes = new ArrayList<Attributes>(); // couple two lists together instead;
	protected List<Object> values = new ArrayList<Object>();

	/**
	 * constructs a parameter with a given name, and no base attributes.
	 * 
	 * @param nm the name of this parameter
	 */
	public EnactorParameter(String nm) {
		this(nm, new Attributes());
	}

	/**
	 * constructs a parameter with a name and a base set of attributes.
	 * 
	 * @param nm
	 * @param template
	 */
	public EnactorParameter(String nm, Attributes template) {
		name = nm;
		attsTemplate = template;
	}

	public void setEnactor(Enactor r) {
		enactor = r;
	}

	public Enactor getEnactor() {
		return enactor;
	}

	public String getName() {
		return name;
	}

	public String getDescription() {
		return description;
	}

	/**
	 * sets the description, a sentence that describes the
	 * function of this parameter.
	 * 
	 * @param description The description to set
	 */
	public void setDescription(String description) {
		this.description = description;
	}

	/**
	 * returns the base attribute template for this parameter. only
	 * attributes contained in the template can be set on the parameter.
	 *  
	 * @return the attribute template
	 */
	public Attributes getAttributesTemplate() {
		return attsTemplate;
	}

	/**
	 * set a value for the parameter with the given attributes. only
	 * attributes that are contained in the attribute template are stored, and 
	 * the value is stored along with the attribute.
	 * 
	 * TODO: overwrite values with identical attributes
	 * 
	 * @param atts
	 * @param value
	 */
	public void setValue(Attributes atts, Object value) {
		Attributes validAtts = atts.getSubset(attsTemplate);
		if (!validAtts.isEmpty()) {
			attributes.add(validAtts);
			values.add(value);
			enactor.fireParameterValueChanged(this, validAtts, value);
		}
	}

	public int getNumValues() {
		return values.size();
	}

	public Attributes getAttributesAt(int i) {
//		return (Attributes) ((Object[]) values.get(i))[0];
		return attributes.get(i);
	}

	public Object getValueAt(int i) {
//		return (Attributes) ((Object[]) values.get(i))[1];
		return values.get(i);
	}
}